fix static check

attiasas · attiasas · commit fb46e6cb1fd1 · 2025-11-10T12:16:55.000+02:00
diff --git a/artifactory_test.go b/artifactory_test.go
@@ -368,7 +368,9 @@ func getTestCdxFile(t *testing.T, tempDir string) string {
 	cdxFilePath := filepath.Join(tempDir, fmt.Sprintf("upload-integration-test-%s.cdx.json", utils.GetCurrentTimeUnix()))
 	file, err := os.Create(cdxFilePath)
 	assert.NoError(t, err)
-	defer file.Close()
+	defer func() {
+		assert.NoError(t, file.Close())
+	}()
 	// Write the BOM to the file
 	assert.NoError(t, cyclonedx.NewBOMEncoder(file, cyclonedx.BOMFileFormatJSON).SetPretty(true).Encode(bom))
 	return cdxFilePath
diff --git a/audit_test.go b/audit_test.go
diff --git a/commands/audit/audit.go b/commands/audit/audit.go
@@ -155,7 +155,7 @@ func CreateAuditResultsContext(serverDetails *config.ServerDetails, xrayVersion
 
 // If the user requested to include vulnerabilities, or if the user didn't provide any watches, project key, artifactory repo path or git repo key, we should include vulnerabilities.
 func shouldIncludeVulnerabilities(includeVulnerabilities bool, watches []string, artifactoryRepoPath, projectKey, gitRepoHttpsCloneUrl string) bool {
-	return includeVulnerabilities || !(len(watches) > 0 || projectKey != "" || artifactoryRepoPath != "" || gitRepoHttpsCloneUrl != "")
+	return includeVulnerabilities || len(watches) <= 0 && projectKey == "" && artifactoryRepoPath == "" && gitRepoHttpsCloneUrl == ""
 }
 
 func (auditCmd *AuditCommand) Run() (err error) {
@@ -363,7 +363,7 @@ func initAuditCmdResults(params *AuditParams) (cmdResults *results.SecurityComma
 		cmdResults.SetEntitledForJas(entitledForJas)
 	}
 	if entitledForJas {
-		cmdResults.SetSecretValidation(jas.CheckForSecretValidation(xrayManager, params.GetXrayVersion(), slices.Contains(params.AuditBasicParams.ScansToPerform(), utils.SecretTokenValidationScan)))
+		cmdResults.SetSecretValidation(jas.CheckForSecretValidation(xrayManager, params.GetXrayVersion(), slices.Contains(params.ScansToPerform(), utils.SecretTokenValidationScan)))
 	}
 	return
 }
@@ -560,7 +560,7 @@ func addJasScansToRunner(auditParallelRunner *utils.SecurityParallelRunner, audi
 		jas.WithResultsToCompare(auditParams.resultsToCompare),
 	}
 	jasScanner, err = jas.NewJasScanner(serverDetails, scannerOptions...)
-	jas.UpdateJasScannerWithExcludePatternsFromProfile(jasScanner, auditParams.AuditBasicParams.GetConfigProfile())
+	jas.UpdateJasScannerWithExcludePatternsFromProfile(jasScanner, auditParams.GetConfigProfile())
 
 	auditParallelRunner.ResultsMu.Unlock()
 	if err != nil {
@@ -610,7 +610,7 @@ func createJasScansTask(auditParallelRunner *utils.SecurityParallelRunner, scanR
 				ServerDetails:          serverDetails,
 				Scanner:                scanner,
 				Module:                 appsConfigModule,
-				ConfigProfile:          auditParams.AuditBasicParams.GetConfigProfile(),
+				ConfigProfile:          auditParams.GetConfigProfile(),
 				ScansToPerform:         auditParams.ScansToPerform(),
 				SourceResultsToCompare: scanner.GetResultsToCompareByRelativePath(utils.GetRelativePath(targetResult.Target, scanResults.GetCommonParentPath())),
 				SecretsScanType:        secrets.SecretsScannerType,
diff --git a/commands/audit/audit_test.go b/commands/audit/audit_test.go
@@ -197,10 +197,10 @@ func TestDetectScansToPerform(t *testing.T) {
 			detectScanTargets(results, test.params())
 			if assert.Len(t, results.Targets, len(test.expected)) {
 				sort.Slice(results.Targets, func(i, j int) bool {
-					return results.Targets[i].ScanTarget.Target < results.Targets[j].ScanTarget.Target
+					return results.Targets[i].Target < results.Targets[j].Target
 				})
 				sort.Slice(test.expected, func(i, j int) bool {
-					return test.expected[i].ScanTarget.Target < test.expected[j].ScanTarget.Target
+					return test.expected[i].Target < test.expected[j].Target
 				})
 				for i := range results.Targets {
 					if results.Targets[i].ScaResults != nil {
diff --git a/commands/scan/dockerscan.go b/commands/scan/dockerscan.go
@@ -85,7 +85,7 @@ func (dsc *DockerScanCommand) Run() (err error) {
 		Pattern(imageTarPath).
 		Target(dsc.resultsContext.RepoPath).
 		BuildSpec()).SetThreads(1)
-	dsc.ScanCommand.SetTargetNameOverride(dsc.imageTag)
+	dsc.SetTargetNameOverride(dsc.imageTag)
 	err = dsc.setCredentialEnvsForIndexerApp()
 	if err != nil {
 		return errorutils.CheckError(err)
@@ -96,7 +96,7 @@ func (dsc *DockerScanCommand) Run() (err error) {
 			err = errorutils.CheckError(e)
 		}
 	}()
-	return dsc.ScanCommand.RunAndRecordResults(utils.DockerImage, func(scanResults *results.SecurityCommandResults) (err error) {
+	return dsc.RunAndRecordResults(utils.DockerImage, func(scanResults *results.SecurityCommandResults) (err error) {
 		if scanResults == nil {
 			return
 		}
@@ -106,12 +106,12 @@ func (dsc *DockerScanCommand) Run() (err error) {
 }
 
 func (dsc *DockerScanCommand) recordResults(scanResults *results.SecurityCommandResults) (err error) {
-	hasViolationContext := dsc.ScanCommand.resultsContext.HasViolationContext()
-	if err = output.RecordSarifOutput(scanResults, dsc.ScanCommand.serverDetails, dsc.ScanCommand.resultsContext.IncludeVulnerabilities, hasViolationContext); err != nil {
+	hasViolationContext := dsc.resultsContext.HasViolationContext()
+	if err = output.RecordSarifOutput(scanResults, dsc.serverDetails, dsc.resultsContext.IncludeVulnerabilities, hasViolationContext); err != nil {
 		return
 	}
 	var summary output.ScanCommandResultSummary
-	if summary, err = output.NewDockerScanSummary(scanResults, dsc.ScanCommand.serverDetails, dsc.ScanCommand.resultsContext.IncludeVulnerabilities, hasViolationContext, dsc.imageTag); err != nil {
+	if summary, err = output.NewDockerScanSummary(scanResults, dsc.serverDetails, dsc.resultsContext.IncludeVulnerabilities, hasViolationContext, dsc.imageTag); err != nil {
 		return
 	}
 	return output.RecordSecurityCommandSummary(summary)
diff --git a/commands/source_mcp/source_mcp.go b/commands/source_mcp/source_mcp.go
@@ -1,6 +1,7 @@
 package source_mcp
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"os/exec"
@@ -28,25 +29,35 @@ type McpCommand struct {
 }
 
 func establishPipeToFile(dst io.WriteCloser, src io.Reader) {
-	defer dst.Close()
+	defer func() {
+		err := dst.Close()
+		if err != nil {
+			log.Error("Error closing destination pipe")
+		}
+	}()
 	_, err := io.Copy(dst, src)
 	if err != nil {
 		log.Error("Error establishing pipe")
 	}
 }
 
 func establishPipeFromFile(dst io.Writer, src io.ReadCloser) {
-	defer src.Close()
+	defer func() {
+		err := src.Close()
+		if err != nil {
+			log.Error("Error closing source pipe")
+		}
+	}()
 	_, err := io.Copy(dst, src)
 	if err != nil {
 		log.Error("Error establishing pipe")
 	}
 }
 
-func RunAmMcpWithPipes(env map[string]string, cmd string, input_pipe io.Reader, output_pipe io.Writer, error_pipe io.Writer, timeout int, args ...string) error {
+func RunAmMcpWithPipes(env map[string]string, cmd string, input_pipe io.Reader, output_pipe io.Writer, error_pipe io.Writer, timeout int, args ...string) (err error) {
 	am_path, err := jas.GetAnalyzerManagerExecutable()
 	if err != nil {
-		return err
+		return
 	}
 
 	allArgs := append([]string{cmd}, args...)
@@ -59,21 +70,33 @@ func RunAmMcpWithPipes(env map[string]string, cmd string, input_pipe io.Reader,
 		log.Error(fmt.Sprintf("Error creating MCPService stdin pipe: %v", _error))
 		return _error
 	}
-	defer stdin.Close()
+	defer func() {
+		if _error := stdin.Close(); _error != nil {
+			err = errors.Join(err, fmt.Errorf("error closing MCPService stdin pipe: %v", _error))
+		}
+	}()
 
 	stdout, _error := command.StdoutPipe()
 	if _error != nil {
 		log.Error(fmt.Sprintf("Error creating MCPService stdout pipe: %v", _error))
 		return _error
 	}
-	defer stdout.Close()
+	defer func() {
+		if _error := stdout.Close(); _error != nil {
+			err = errors.Join(err, fmt.Errorf("error closing MCPService stdout pipe: %v", _error))
+		}
+	}()
 
 	stderr, _error := command.StderrPipe()
 	if _error != nil {
 		log.Error(fmt.Sprintf("Error creating MCPService stderr pipe: %v", _error))
 		return _error
 	}
-	defer stderr.Close()
+	defer func() {
+		if _error := stderr.Close(); _error != nil {
+			err = errors.Join(err, fmt.Errorf("error closing MCPService stderr pipe: %v", _error))
+		}
+	}()
 
 	go establishPipeToFile(stdin, input_pipe)
 	go establishPipeFromFile(error_pipe, stderr)
diff --git a/enrich_test.go b/enrich_test.go
@@ -7,13 +7,12 @@ import (
 	"github.com/jfrog/jfrog-cli-security/commands/enrich/enrichgraph"
 	securityTests "github.com/jfrog/jfrog-cli-security/tests"
 	securityTestUtils "github.com/jfrog/jfrog-cli-security/tests/utils"
-	"github.com/jfrog/jfrog-cli-security/tests/utils/integration"
 	securityIntegrationTestUtils "github.com/jfrog/jfrog-cli-security/tests/utils/integration"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestXrayEnrichSbomOutput(t *testing.T) {
-	integration.InitEnrichTest(t, enrichgraph.EnrichMinimumVersionXray)
+	securityIntegrationTestUtils.InitEnrichTest(t, enrichgraph.EnrichMinimumVersionXray)
 	cleanUp := securityIntegrationTestUtils.UseTestHomeWithDefaultXrayConfig(t)
 	defer cleanUp()
 	testCases := []struct {
diff --git a/jas/runner/jasrunner.go b/jas/runner/jasrunner.go
@@ -54,10 +54,7 @@ type CveProvider func() (directCves []string, indirectCves []string)
 
 func AddJasScannersTasks(params JasRunnerParams) error {
 	// For docker scan we support only secrets and contextual scans.
-	runAllScanners := false
-	if params.ApplicableScanType == applicability.ApplicabilityScannerType || params.SecretsScanType == secrets.SecretsScannerType {
-		runAllScanners = true
-	}
+	runAllScanners := params.ApplicableScanType == applicability.ApplicabilityScannerType || params.SecretsScanType == secrets.SecretsScannerType
 
 	var errorsCollection error
 	if generalError := addJasScanTaskForModuleIfNeeded(params, utils.ContextualAnalysisScan, runContextualScan(&params)); generalError != nil {
diff --git a/sca/bom/buildinfo/technologies/conan/conan.go b/sca/bom/buildinfo/technologies/conan/conan.go
@@ -53,7 +53,7 @@ func getConanExecPath() (conanExecPath string, err error) {
 		return
 	}
 	if version.NewVersion(string(conanVersion)).Compare(conanV2) < 0 {
-		err = fmt.Errorf("Conan dependency tree building is currently supported for Conan V2. The current Conan version is: %s", conanVersion)
+		err = fmt.Errorf("conan dependency tree building is currently supported for Conan V2. The current Conan version is: %s", conanVersion)
 		return
 	}
 	log.Debug("Conan version: ", string(conanVersion))
diff --git a/sca/bom/buildinfo/technologies/go/golang.go b/sca/bom/buildinfo/technologies/go/golang.go
@@ -6,7 +6,6 @@ import (
 
 	biutils "github.com/jfrog/build-info-go/utils"
 	"github.com/jfrog/gofrog/datastructures"
-	goartifactoryutils "github.com/jfrog/jfrog-cli-artifactory/artifactory/commands/golang"
 	goutils "github.com/jfrog/jfrog-cli-artifactory/artifactory/commands/golang"
 	"github.com/jfrog/jfrog-cli-core/v2/utils/coreutils"
 	"github.com/jfrog/jfrog-cli-security/sca/bom/buildinfo/technologies"
@@ -39,14 +38,14 @@ func BuildDependencyTree(params technologies.BuildInfoBomGeneratorParams) (depen
 			err = errCacheFolder
 			return
 		}
-		if err = goartifactoryutils.SetGoModCache(projCacheDir); err != nil {
+		if err = goutils.SetGoModCache(projCacheDir); err != nil {
 			return
 		}
 	}
 
 	remoteGoRepo := params.DependenciesRepository
 	if remoteGoRepo != "" {
-		if err = goartifactoryutils.SetArtifactoryAsResolutionServer(params.ServerDetails, remoteGoRepo, goProxyParams); err != nil {
+		if err = goutils.SetArtifactoryAsResolutionServer(params.ServerDetails, remoteGoRepo, goProxyParams); err != nil {
 			return
 		}
 	}
diff --git a/sca/bom/indexer/indexerbom.go b/sca/bom/indexer/indexerbom.go
@@ -68,7 +68,7 @@ func (ibg *IndexerBomGenerator) WithOptions(options ...bom.SbomGeneratorOption)
 
 func (ibg *IndexerBomGenerator) PrepareGenerator() (err error) {
 	if ibg.xrayManager == nil || ibg.xrayVersion == "" {
-		return fmt.Errorf("Xray manager and version must be set using WithXray option")
+		return fmt.Errorf("xray manager and version must be set using WithXray option")
 	}
 	if ibg.indexerPath, err = DownloadIndexerIfNeeded(ibg.xrayManager, ibg.xrayVersion); err != nil {
 		return
diff --git a/sca/scan/scangraph/runner.go b/sca/scan/scangraph/runner.go
@@ -60,20 +60,20 @@ func (sg *ScanGraphStrategy) SbomEnrichTask(target *cyclonedx.BOM) (enriched *cy
 }
 
 func (sg *ScanGraphStrategy) DeprecatedScanTask(target *cyclonedx.BOM) (techResults services.ScanResponse, err error) {
-	if sg.ScanGraphParams.XrayGraphScanParams().ScanType != services.Dependency {
-		return services.ScanResponse{}, fmt.Errorf("scanning %s components is not supported", sg.ScanGraphParams.XrayGraphScanParams().ScanType)
+	if sg.XrayGraphScanParams().ScanType != services.Dependency {
+		return services.ScanResponse{}, fmt.Errorf("scanning %s components is not supported", sg.XrayGraphScanParams().ScanType)
 	}
 	// Transform the target BOM to the information needed for the scan graph.
 	flatTree, fullTree := results.BomToTree(target)
 	if flatTree == nil || len(flatTree.Nodes) == 0 {
 		// If there is no tree, or a tree without any non-root dependencies - we don't need to scan it
 		return services.ScanResponse{}, nil
 	}
-	sg.ScanGraphParams.XrayGraphScanParams().DependenciesGraph = flatTree
+	sg.XrayGraphScanParams().DependenciesGraph = flatTree
 	if targetTechnology := resolveTechnologyFromBOM(target); targetTechnology != techutils.NoTech {
 		// Report the technology to Xray.
-		sg.ScanGraphParams.SetTechnology(targetTechnology)
-		sg.ScanGraphParams.XrayGraphScanParams().Technology = targetTechnology.String()
+		sg.SetTechnology(targetTechnology)
+		sg.XrayGraphScanParams().Technology = targetTechnology.String()
 	}
 	// Send the scan graph params to run the scan.
 	return runXrayDependenciesTreeScanGraph(&sg.ScanGraphParams, fullTree)
diff --git a/tests/utils/test_utils.go b/tests/utils/test_utils.go
@@ -172,10 +172,10 @@ func convertJasSimpleJsonPathsForOS(jas *formats.SourceCodeRow) {
 	if jas == nil {
 		return
 	}
-	jas.Location.File = getJasConvertedPath(jas.Location.File)
+	jas.File = getJasConvertedPath(jas.File)
 	if jas.Applicability != nil {
 		for i := range jas.Applicability.Evidence {
-			jas.Applicability.Evidence[i].Location.File = getJasConvertedPath(jas.Applicability.Evidence[i].Location.File)
+			jas.Applicability.Evidence[i].File = getJasConvertedPath(jas.Applicability.Evidence[i].File)
 		}
 	}
 	for i := range jas.CodeFlow {
@@ -217,7 +217,7 @@ func convertScaSimpleJsonPathsForOS(potentialComponents *[]formats.ComponentRow,
 		for i := range cves {
 			if cves[i].Applicability != nil {
 				for j := range cves[i].Applicability.Evidence {
-					cves[i].Applicability.Evidence[j].Location.File = filepath.ToSlash(cves[i].Applicability.Evidence[j].Location.File)
+					cves[i].Applicability.Evidence[j].File = filepath.ToSlash(cves[i].Applicability.Evidence[j].File)
 				}
 			}
 		}
diff --git a/tests/validations/test_mocks.go b/tests/validations/test_mocks.go
@@ -114,7 +114,7 @@ func getXscServerApiHandler(t *testing.T, params MockServerParams) func(w http.R
 		}
 
 		if r.RequestURI == fmt.Sprintf(versionApiUrl, apiUrlPart, "xsc") {
-			_, err := w.Write([]byte(fmt.Sprintf(`{"xsc_version": "%s"}`, params.XscVersion)))
+			_, err := fmt.Fprintf(w, `{"xsc_version": "%s"}`, params.XscVersion)
 			if !assert.NoError(t, err) {
 				return
 			}
@@ -125,7 +125,7 @@ func getXscServerApiHandler(t *testing.T, params MockServerParams) func(w http.R
 				if params.ReturnMsi == "" {
 					params.ReturnMsi = TestMsi
 				}
-				_, err := w.Write([]byte(fmt.Sprintf(`{"multi_scan_id": "%s"}`, params.ReturnMsi)))
+				_, err := fmt.Fprintf(w, `{"multi_scan_id": "%s"}`, params.ReturnMsi)
 				if !assert.NoError(t, err) {
 					return
 				}
@@ -154,7 +154,7 @@ func XrayServer(t *testing.T, params MockServerParams) (*httptest.Server, *confi
 	serverMock, serverDetails := CreateXrayRestsMockServer(func(w http.ResponseWriter, r *http.Request) {
 		if r.RequestURI == fmt.Sprintf(versionApiUrl, "api/v1/", "xray") {
 			apiCallCounts[VersionApi]++
-			_, err := w.Write([]byte(fmt.Sprintf(`{"xray_version": "%s", "xray_revision": "xxx"}`, params.XrayVersion)))
+			_, err := fmt.Fprintf(w, `{"xray_version": "%s", "xray_revision": "xxx"}`, params.XrayVersion)
 			if !assert.NoError(t, err) {
 				return
 			}
diff --git a/utils/results/common.go b/utils/results/common.go
@@ -66,7 +66,7 @@ func CheckIfFailBuild(auditResults *SecurityCommandResults) (bool, error) {
 		} else {
 			// If JasResults are not empty we check old and new violation while considering Applicability status and Skip-not-applicable policy rule.
 			if err := checkIfFailBuildConsideringApplicability(target, auditResults.EntitledForJas, &shouldFailBuild); err != nil {
-				return false, fmt.Errorf("failed to check if build should fail for target %s: %w", target.ScanTarget.Target, err)
+				return false, fmt.Errorf("failed to check if build should fail for target %s: %w", target.Target, err)
 			}
 		}
 		if shouldFailBuild {
diff --git a/utils/results/conversion/convertor_test.go b/utils/results/conversion/convertor_test.go
@@ -83,11 +83,7 @@ func TestConvertResults(t *testing.T) {
 			default:
 				t.Fatalf("Unsupported command type: %s", testCase.cmdType)
 			}
-			pretty := false
-			if testCase.contentFormat == Sarif {
-				pretty = true
-			}
-			convertor := NewCommandResultsConvertor(ResultConvertParams{IncludeVulnerabilities: true, HasViolationContext: true, IncludeLicenses: true, Pretty: pretty})
+			convertor := NewCommandResultsConvertor(ResultConvertParams{IncludeVulnerabilities: true, HasViolationContext: true, IncludeLicenses: true, Pretty: testCase.contentFormat == Sarif})
 
 			switch testCase.contentFormat {
 			case SimpleJson:
diff --git a/utils/results/conversion/simplejsonparser/simplejsonparser.go b/utils/results/conversion/simplejsonparser/simplejsonparser.go
@@ -624,12 +624,12 @@ func getOperationalRiskViolationReadableData(violation services.Violation) *oper
 func removeScaDuplications(issues []formats.VulnerabilityOrViolationRow, multipleRoots bool) []formats.VulnerabilityOrViolationRow {
 	var uniqueIssues = make(map[string]*formats.VulnerabilityOrViolationRow)
 	for i := range issues {
-		packageKey := results.GetUniqueKey(issues[i].ImpactedDependencyDetails.ImpactedDependencyName, issues[i].ImpactedDependencyDetails.ImpactedDependencyVersion, issues[i].IssueId, len(issues[i].FixedVersions) > 0)
+		packageKey := results.GetUniqueKey(issues[i].ImpactedDependencyName, issues[i].ImpactedDependencyVersion, issues[i].IssueId, len(issues[i].FixedVersions) > 0)
 		if uniqueIssue, exist := uniqueIssues[packageKey]; exist {
 			// combine attributes from the same issue
 			uniqueIssue.FixedVersions = utils.UniqueIntersection(uniqueIssue.FixedVersions, issues[i].FixedVersions...)
 			uniqueIssue.ImpactPaths = AppendImpactPathsIfUnique(uniqueIssue.ImpactPaths, issues[i].ImpactPaths, multipleRoots)
-			uniqueIssue.ImpactedDependencyDetails.Components = AppendComponentIfUnique(uniqueIssue.ImpactedDependencyDetails.Components, issues[i].ImpactedDependencyDetails.Components)
+			uniqueIssue.Components = AppendComponentIfUnique(uniqueIssue.Components, issues[i].Components)
 			continue
 		}
 		uniqueIssues[packageKey] = &issues[i]
diff --git a/utils/results/conversion/summaryparser/summaryparser.go b/utils/results/conversion/summaryparser/summaryparser.go
@@ -83,15 +83,15 @@ func (sc *CmdResultsSummaryConverter) parseScaViolations(target results.ScanTarg
 	if err = sc.validateBeforeParse(); err != nil || sc.currentScan.Violations == nil {
 		return
 	}
-	if sc.currentScan.Violations.ScanResultSummary.ScaResults == nil {
-		sc.currentScan.Violations.ScanResultSummary.ScaResults = &formats.ScaScanResultSummary{}
+	if sc.currentScan.Violations.ScaResults == nil {
+		sc.currentScan.Violations.ScaResults = &formats.ScaScanResultSummary{}
 	}
 	// Parse general SCA results
 	if scaResponse.Scan.ScanId != "" {
-		sc.currentScan.Violations.ScanResultSummary.ScaResults.ScanIds = utils.UniqueUnion(sc.currentScan.Violations.ScanResultSummary.ScaResults.ScanIds, scaResponse.Scan.ScanId)
+		sc.currentScan.Violations.ScaResults.ScanIds = utils.UniqueUnion(sc.currentScan.Violations.ScaResults.ScanIds, scaResponse.Scan.ScanId)
 	}
 	if scaResponse.Scan.XrayDataUrl != "" {
-		sc.currentScan.Violations.ScanResultSummary.ScaResults.MoreInfoUrls = utils.UniqueUnion(sc.currentScan.Violations.ScanResultSummary.ScaResults.MoreInfoUrls, scaResponse.Scan.XrayDataUrl)
+		sc.currentScan.Violations.ScaResults.MoreInfoUrls = utils.UniqueUnion(sc.currentScan.Violations.ScaResults.MoreInfoUrls, scaResponse.Scan.XrayDataUrl)
 	}
 	if scaResponse.IsScanFailed() {
 		return
diff --git a/utils/results/output/securityJobSummary.go b/utils/results/output/securityJobSummary.go
@@ -137,10 +137,11 @@ func (rsa ResultSummaryArgs) GetUrl(index commandsummary.Index, scanIds ...strin
 }
 
 func (rsa ResultSummaryArgs) ToArgs(index commandsummary.Index) (args []string) {
-	if index == commandsummary.BuildScan {
+	switch index {
+	case commandsummary.BuildScan:
 		args = append(args, rsa.BuildName)
 		args = append(args, rsa.BuildNumbers...)
-	} else if index == commandsummary.DockerScan {
+	case commandsummary.DockerScan:
 		image := rsa.DockerImage
 		// if user did not provide image tag, add latest
 		if !strings.Contains(image, ":") {
diff --git a/xray_test.go b/xray_test.go

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ func getConanExecPath() (conanExecPath string, err error) {`
`53`	`53`	`return`
`54`	`54`	`}`
`55`	`55`	`if version.NewVersion(string(conanVersion)).Compare(conanV2) < 0 {`
`56`		`- err = fmt.Errorf("Conan dependency tree building is currently supported for Conan V2. The current Conan version is: %s", conanVersion)`
	`56`	`+ err = fmt.Errorf("conan dependency tree building is currently supported for Conan V2. The current Conan version is: %s", conanVersion)`
`57`	`57`	`return`
`58`	`58`	`}`
`59`	`59`	`log.Debug("Conan version: ", string(conanVersion))`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ import (`
`6`	`6`
`7`	`7`	`biutils "github.com/jfrog/build-info-go/utils"`
`8`	`8`	`"github.com/jfrog/gofrog/datastructures"`
`9`		`- goartifactoryutils "github.com/jfrog/jfrog-cli-artifactory/artifactory/commands/golang"`
`10`	`9`	`goutils "github.com/jfrog/jfrog-cli-artifactory/artifactory/commands/golang"`
`11`	`10`	`"github.com/jfrog/jfrog-cli-core/v2/utils/coreutils"`
`12`	`11`	`"github.com/jfrog/jfrog-cli-security/sca/bom/buildinfo/technologies"`
`@@ -39,14 +38,14 @@ func BuildDependencyTree(params technologies.BuildInfoBomGeneratorParams) (depen`
`39`	`38`	`err = errCacheFolder`
`40`	`39`	`return`
`41`	`40`	`}`
`42`		`- if err = goartifactoryutils.SetGoModCache(projCacheDir); err != nil {`
	`41`	`+ if err = goutils.SetGoModCache(projCacheDir); err != nil {`
`43`	`42`	`return`
`44`	`43`	`}`
`45`	`44`	`}`
`46`	`45`
`47`	`46`	`remoteGoRepo := params.DependenciesRepository`
`48`	`47`	`if remoteGoRepo != "" {`
`49`		`- if err = goartifactoryutils.SetArtifactoryAsResolutionServer(params.ServerDetails, remoteGoRepo, goProxyParams); err != nil {`
	`48`	`+ if err = goutils.SetArtifactoryAsResolutionServer(params.ServerDetails, remoteGoRepo, goProxyParams); err != nil {`
`50`	`49`	`return`
`51`	`50`	`}`
`52`	`51`	`}`