fix bug #414 where the jira consumer would not create issues with zer…

components/consumers/jira/utils/utils.go

@@ -21,11 +21,6 @@ func ProcessMessages(allowDuplicates, allowFP bool, sevThreshold int) ([]documen
 			return nil, 0, err
 		}
 		messages, discarded := ProcessRawMessages(responses, sevThreshold)
-		if err != nil {
-			log.Print("Could not Process Raw Messages: ", err)
-			return nil, 0, err
-		}
-
 		return messages, discarded, nil
 	}
 	log.Print("Parsing Enriched results")

pkg/jira/jira/apiutils_test.go

@@ -3,7 +3,7 @@ package jira
 import (
 	"testing"
 
-	jira "github.com/andygrunwald/go-jira"
+	"github.com/andygrunwald/go-jira"
 	"github.com/stretchr/testify/require"
 	"github.com/trivago/tgo/tcontainer"
 )

pkg/templating/template_description.go

@@ -17,6 +17,21 @@ const (
 	defaultRawFindingTemplate      = "Dracon found '{{.Title}}' at '{{.Target}}', severity '{{.Severity}}', rule id: '{{.Type}}', CVSS '{{.Cvss}}' Confidence '{{.Confidence}}' Original Description: {{.Description}}, Cve {{.Cve}}"
 )
 
+type (
+	enrichedIssue struct {
+		*v1.EnrichedIssue
+		ToolName       string
+		ScanStartTime  string
+		ScanID         string
+		ConfidenceText string
+		SeverityText   string
+		Count          uint
+		FirstFound     string
+	}
+
+	enrichedIssueOption func(*enrichedIssue) error
+)
+
 // TemplateStringRaw applies the provided go template to the Raw Issue provided and returns the resulting str
 func TemplateStringRaw(inputTemplate string, issue *v1.Issue) (*string, error) {
 	if inputTemplate == "" {
@@ -36,18 +51,7 @@ func TemplateStringRaw(inputTemplate string, issue *v1.Issue) (*string, error) {
 	return &res, nil
 }
 
-type enrichedIssue struct {
-	*v1.EnrichedIssue
-	ToolName       string
-	ScanStartTime  string
-	ScanID         string
-	ConfidenceText string
-	SeverityText   string
-	Count          uint
-	FirstFound     string
-}
-type enrichedIssueOption func(*enrichedIssue) error
-
+// EnrichedIssueWithToolName allows customising the Enriched Issue's ToolName.
 func EnrichedIssueWithToolName(toolname string) enrichedIssueOption {
 	return func(ei *enrichedIssue) error {
 		if toolname == "" {
@@ -58,16 +62,7 @@ func EnrichedIssueWithToolName(toolname string) enrichedIssueOption {
 	}
 }
 
-func EnrichedIssueWithScanStartTime(startTime time.Time) enrichedIssueOption {
-	return func(ei *enrichedIssue) error {
-		if time.Time.IsZero(startTime) {
-			return errors.New("invalid startTime zero")
-		}
-		ei.ScanStartTime = startTime.Format(time.RFC3339)
-		return nil
-	}
-}
-
+// EnrichedIssueWithConfidenceText allows customising the Enriched Issue's ConfidenceText.
 func EnrichedIssueWithConfidenceText(confidence string) enrichedIssueOption {
 	return func(ei *enrichedIssue) error {
 		if confidence == "" {
@@ -78,6 +73,7 @@ func EnrichedIssueWithConfidenceText(confidence string) enrichedIssueOption {
 	}
 }
 
+// EnrichedIssueWithSeverityText allows customising the Enriched Issue's SeverityText.
 func EnrichedIssueWithSeverityText(severity string) enrichedIssueOption {
 	return func(ei *enrichedIssue) error {
 		if severity == "" {
@@ -88,6 +84,7 @@ func EnrichedIssueWithSeverityText(severity string) enrichedIssueOption {
 	}
 }
 
+// EnrichedIssueWithCount allows customising the Enriched Issue's Count.
 func EnrichedIssueWithCount(count uint) enrichedIssueOption {
 	return func(ei *enrichedIssue) error {
 		if count <= 0 {
@@ -98,6 +95,7 @@ func EnrichedIssueWithCount(count uint) enrichedIssueOption {
 	}
 }
 
+// EnrichedIssueWithScanID allows customising the Enriched Issue's Scan ID.
 func EnrichedIssueWithScanID(scanID string) enrichedIssueOption {
 	return func(ei *enrichedIssue) error {
 		if scanID == "" {
@@ -108,12 +106,26 @@ func EnrichedIssueWithScanID(scanID string) enrichedIssueOption {
 	}
 }
 
+// EnrichedIssueWithScanStartTime allows customising the Enriched Issue's Scan start time.
+func EnrichedIssueWithScanStartTime(startTime time.Time) enrichedIssueOption {
+	return func(ei *enrichedIssue) error {
+		st := startTime.Format(time.RFC3339)
+		if startTime.IsZero() {
+			return errors.Errorf("invalid startTime zero: %s", st)
+		}
+		ei.ScanStartTime = st
+		return nil
+	}
+}
+
+// EnrichedIssueWithFirstFound allows customising the Enriched Issue's Scan first found time.
 func EnrichedIssueWithFirstFound(firstFound time.Time) enrichedIssueOption {
 	return func(ei *enrichedIssue) error {
-		if time.Time.IsZero(firstFound) {
-			return errors.New("invalid firstFound zero")
+		ff := firstFound.Format(time.RFC3339)
+		if firstFound.IsZero() {
+			return errors.Errorf("invalid firstFound zero %s", ff)
 		}
-		ei.FirstFound = firstFound.Format(time.RFC3339)
+		ei.FirstFound = ff
 		return nil
 	}
 }

pkg/templating/template_description_test.go

@@ -4,9 +4,9 @@ import (
 	"testing"
 	"time"
 
-	"google.golang.org/protobuf/types/known/timestamppb"
-
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/types/known/timestamppb"
 
 	v1 "github.com/ocurity/dracon/api/proto/v1"
 )
@@ -138,3 +138,148 @@ func Test_TemplateStringEnriched(t *testing.T) {
 		})
 	}
 }
+
+func TestDescriptionOptions(t *testing.T) {
+	type args struct {
+		option enrichedIssueOption
+	}
+
+	acceptableTime, err := time.Parse(time.RFC3339, "2024-10-10T20:06:33Z")
+	require.NoError(t, err)
+
+	for _, tt := range []struct {
+		name                  string
+		args                  args
+		wantErr               bool
+		expectedEnrichedIssue *enrichedIssue
+	}{
+		{
+			name: "zero startTime returns err",
+			args: args{
+				option: EnrichedIssueWithScanStartTime(time.Time{}),
+			},
+			wantErr: true,
+		},
+		{
+			name: "non zero startTime returns no err",
+			args: args{
+				option: EnrichedIssueWithScanStartTime(acceptableTime),
+			},
+			wantErr: false,
+			expectedEnrichedIssue: &enrichedIssue{
+				ScanStartTime: acceptableTime.Format(time.RFC3339),
+			},
+		},
+		{
+			name: "zero firstFound returns err",
+			args: args{
+				option: EnrichedIssueWithFirstFound(time.Time{}),
+			},
+			wantErr: true,
+		},
+		{
+			name: "non zero firstFound returns no err",
+			args: args{
+				option: EnrichedIssueWithFirstFound(acceptableTime),
+			},
+			wantErr: false,
+			expectedEnrichedIssue: &enrichedIssue{
+				FirstFound: acceptableTime.Format(time.RFC3339),
+			},
+		},
+		{
+			name: "empty tool name returns err",
+			args: args{
+				option: EnrichedIssueWithToolName(""),
+			},
+			wantErr: true,
+		},
+		{
+			name: "valid tool name returns no err",
+			args: args{
+				option: EnrichedIssueWithToolName("some-tool"),
+			},
+			wantErr: false,
+			expectedEnrichedIssue: &enrichedIssue{
+				ToolName: "some-tool",
+			},
+		},
+		{
+			name: "empty confidence text returns err",
+			args: args{
+				option: EnrichedIssueWithConfidenceText(""),
+			},
+			wantErr: true,
+		},
+		{
+			name: "valid confidence text returns no err",
+			args: args{
+				option: EnrichedIssueWithConfidenceText("conf-text-1"),
+			},
+			wantErr: false,
+			expectedEnrichedIssue: &enrichedIssue{
+				ConfidenceText: "conf-text-1",
+			},
+		},
+		{
+			name: "empty severity text returns err",
+			args: args{
+				option: EnrichedIssueWithSeverityText(""),
+			},
+			wantErr: true,
+		},
+		{
+			name: "valid severity text returns no err",
+			args: args{
+				option: EnrichedIssueWithSeverityText("severity-text-1"),
+			},
+			wantErr: false,
+			expectedEnrichedIssue: &enrichedIssue{
+				SeverityText: "severity-text-1",
+			},
+		},
+		{
+			name: "0 count returns err",
+			args: args{
+				option: EnrichedIssueWithCount(0),
+			},
+			wantErr: true,
+		},
+		{
+			name: "positive count text returns no err",
+			args: args{
+				option: EnrichedIssueWithCount(420),
+			},
+			wantErr: false,
+			expectedEnrichedIssue: &enrichedIssue{
+				Count: 420,
+			},
+		},
+		{
+			name: "empty scan ID returns err",
+			args: args{
+				option: EnrichedIssueWithScanID(""),
+			},
+			wantErr: true,
+		},
+		{
+			name: "valid scan id returns no err",
+			args: args{
+				option: EnrichedIssueWithScanID("scan-1"),
+			},
+			wantErr: false,
+			expectedEnrichedIssue: &enrichedIssue{
+				ScanID: "scan-1",
+			},
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			var ei enrichedIssue
+			if err := tt.args.option(&ei); tt.wantErr {
+				require.Error(t, err)
+				return
+			}
+			assert.Equal(t, tt.expectedEnrichedIssue, &ei)
+		})
+	}
+}