Evidence CLI - update fields names

Makefile

@@ -9,6 +9,9 @@ GOARCH = $(shell go env GOARCH)
 # ----------------------------------------------------------------------------------------------------------------------
 export PROJECT_DIR = $(CURDIR)
 
+prereq:
+	$(GOCMD) install go.uber.org/mock/[email protected]
+
 clean-mock:
 	@find . -name "*_mock.go" -delete
 

evidence/cli/command.go

@@ -3,9 +3,10 @@ package cli
 //go:generate ${PROJECT_DIR}/scripts/mockgen.sh ${GOFILE}
 
 import (
+	"github.com/jfrog/jfrog-cli-core/v2/plugins/components"
 	coreConfig "github.com/jfrog/jfrog-cli-core/v2/utils/config"
 )
 
 type EvidenceCommands interface {
-	CreateEvidence(*coreConfig.ServerDetails) error
+	CreateEvidence(ctx *components.Context, serverDetails *coreConfig.ServerDetails) error
 }

evidence/cli/command_build.go

@@ -4,6 +4,7 @@ import (
 	"github.com/jfrog/jfrog-cli-artifactory/evidence"
 	"github.com/jfrog/jfrog-cli-core/v2/plugins/components"
 	coreConfig "github.com/jfrog/jfrog-cli-core/v2/utils/config"
+	"github.com/jfrog/jfrog-client-go/utils/errorutils"
 )
 
 type evidenceBuildCommand struct {
@@ -18,14 +19,27 @@ func NewEvidenceBuildCommand(ctx *components.Context, execute execCommandFunc) E
 	}
 }
 
-func (erc *evidenceBuildCommand) CreateEvidence(serverDetails *coreConfig.ServerDetails) error {
+func (ebc *evidenceBuildCommand) CreateEvidence(ctx *components.Context, serverDetails *coreConfig.ServerDetails) error {
+	err := ebc.validateEvidenceBuildContext(ctx)
+	if err != nil {
+		return err
+	}
+
 	createCmd := evidence.NewCreateEvidenceBuild(
 		serverDetails,
-		erc.ctx.GetStringFlagValue(predicate),
-		erc.ctx.GetStringFlagValue(predicateType),
-		erc.ctx.GetStringFlagValue(key),
-		erc.ctx.GetStringFlagValue(keyId),
-		erc.ctx.GetStringFlagValue(project),
-		erc.ctx.GetStringFlagValue(build))
-	return erc.execute(createCmd)
+		ebc.ctx.GetStringFlagValue(predicate),
+		ebc.ctx.GetStringFlagValue(predicateType),
+		ebc.ctx.GetStringFlagValue(key),
+		ebc.ctx.GetStringFlagValue(keyId),
+		ebc.ctx.GetStringFlagValue(project),
+		ebc.ctx.GetStringFlagValue(buildName),
+		ebc.ctx.GetStringFlagValue(buildNumber))
+	return ebc.execute(createCmd)
+}
+
+func (ebc *evidenceBuildCommand) validateEvidenceBuildContext(ctx *components.Context) error {
+	if !ctx.IsFlagSet(buildNumber) || assertValueProvided(ctx, buildNumber) != nil {
+		return errorutils.CheckErrorf("'buildNumber' is a mandatory field for creating a Release Bundle evidence: --%s", buildNumber)
+	}
+	return nil
 }

evidence/cli/command_controller.go → evidence/cli/command_cli.go

@@ -26,12 +26,10 @@ func GetCommands() []components.Command {
 	}
 }
 
-var execFunc = func(command commands.Command) error {
-	return commands.Exec(command)
-}
+var execFunc = commands.Exec
 
 func createEvidence(c *components.Context) error {
-	if err := validateCreateEvidenceContext(c); err != nil {
+	if err := validateCreateEvidenceCommonContext(c); err != nil {
 		return err
 	}
 	subject, err := getAndValidateSubject(c)
@@ -45,20 +43,20 @@ func createEvidence(c *components.Context) error {
 
 	var command EvidenceCommands
 	switch subject {
-	case repoPath:
+	case subjectRepoPath:
 		command = NewEvidenceCustomCommand(c, execFunc)
 	case releaseBundle:
 		command = NewEvidenceReleaseBundleCommand(c, execFunc)
-	case build:
+	case buildName:
 		command = NewEvidenceBuildCommand(c, execFunc)
 	default:
 		return errors.New("unsupported subject")
 	}
 
-	return command.CreateEvidence(serverDetails)
+	return command.CreateEvidence(c, serverDetails)
 }
 
-func validateCreateEvidenceContext(c *components.Context) error {
+func validateCreateEvidenceCommonContext(c *components.Context) error {
 	if show, err := pluginsCommon.ShowCmdHelpIfNeeded(c, c.Arguments); show || err != nil {
 		return err
 	}
@@ -68,13 +66,13 @@ func validateCreateEvidenceContext(c *components.Context) error {
 	}
 
 	if !c.IsFlagSet(predicate) || assertValueProvided(c, predicate) != nil {
-		return errorutils.CheckErrorf("'predicate' is a mandatory field for creating a custom evidence: --%s", predicate)
+		return errorutils.CheckErrorf("'predicate' is a mandatory field for creating evidence: --%s", predicate)
 	}
 	if !c.IsFlagSet(predicateType) || assertValueProvided(c, predicateType) != nil {
-		return errorutils.CheckErrorf("'predicate-type' is a mandatory field for creating a custom evidence: --%s", predicateType)
+		return errorutils.CheckErrorf("'predicate-type' is a mandatory field for creating evidence: --%s", predicateType)
 	}
 	if !c.IsFlagSet(key) || assertValueProvided(c, key) != nil {
-		return errorutils.CheckErrorf("'key' is a mandatory field for creating a custom evidence: --%s", key)
+		return errorutils.CheckErrorf("'key' is a mandatory field for creating evidence: --%s", key)
 	}
 	return nil
 }
@@ -88,7 +86,7 @@ func getAndValidateSubject(c *components.Context) (string, error) {
 	}
 
 	if len(foundSubjects) == 0 {
-		return "", errorutils.CheckErrorf("Subject must be one of the fields: [%s]", strings.Join(subjectTypes, ", "))
+		return "", errorutils.CheckErrorf("subject must be one of the fields: [%s]", strings.Join(subjectTypes, ", "))
 	}
 	if len(foundSubjects) > 1 {
 		return "", errorutils.CheckErrorf("multiple subjects found: [%s]", strings.Join(foundSubjects, ", "))

evidence/cli/command_cli_test.go

@@ -0,0 +1,125 @@
+package cli
+
+import (
+	"flag"
+	"github.com/golang/mock/gomock"
+	"github.com/jfrog/jfrog-cli-core/v2/common/commands"
+	"github.com/jfrog/jfrog-cli-core/v2/plugins/components"
+	"github.com/stretchr/testify/assert"
+	"github.com/urfave/cli"
+	"testing"
+)
+
+func TestCreateEvidence_Context(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	app := cli.NewApp()
+	app.Commands = []cli.Command{
+		{
+			Name: "create",
+		},
+	}
+	set := flag.NewFlagSet(predicate, 0)
+	ctx := cli.NewContext(app, set, nil)
+
+	tests := []struct {
+		name      string
+		flags     []components.Flag
+		expectErr bool
+	}{
+		{
+			name: "InvalidContext - Missing Subject",
+			flags: []components.Flag{
+				setDefaultValue(predicate, predicate),
+				setDefaultValue(predicateType, predicateType),
+				setDefaultValue(key, key),
+			},
+			expectErr: true,
+		},
+		{
+			name: "InvalidContext - Missing Predicate",
+			flags: []components.Flag{
+				setDefaultValue("", ""),
+				setDefaultValue(predicateType, "InToto"),
+				setDefaultValue(key, "PGP"),
+			},
+			expectErr: true,
+		},
+		{
+			name: "InvalidContext - Subject Duplication",
+			flags: []components.Flag{
+				setDefaultValue(predicate, predicate),
+				setDefaultValue(predicateType, "InToto"),
+				setDefaultValue(key, "PGP"),
+				setDefaultValue(subjectRepoPath, subjectRepoPath),
+				setDefaultValue(releaseBundle, releaseBundle),
+				setDefaultValue(releaseBundleVersion, releaseBundleVersion),
+			},
+			expectErr: true,
+		},
+		{
+			name: "ValidContext - ReleaseBundle",
+			flags: []components.Flag{
+				setDefaultValue(predicate, predicate),
+				setDefaultValue(predicateType, "InToto"),
+				setDefaultValue(key, "PGP"),
+				setDefaultValue(releaseBundle, releaseBundle),
+				setDefaultValue(releaseBundleVersion, releaseBundleVersion),
+				setDefaultValue("url", "url"),
+			},
+			expectErr: false,
+		},
+		{
+			name: "ValidContext - RepoPath",
+			flags: []components.Flag{
+				setDefaultValue(predicate, predicate),
+				setDefaultValue(predicateType, "InToto"),
+				setDefaultValue(key, "PGP"),
+				setDefaultValue(subjectRepoPath, subjectRepoPath),
+				setDefaultValue("url", "url"),
+			},
+			expectErr: false,
+		},
+		{
+			name: "ValidContext - Build",
+			flags: []components.Flag{
+				setDefaultValue(predicate, predicate),
+				setDefaultValue(predicateType, "InToto"),
+				setDefaultValue(key, "PGP"),
+				setDefaultValue(buildName, buildName),
+				setDefaultValue(buildNumber, buildNumber),
+				setDefaultValue("url", "url"),
+			},
+			expectErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			context, err1 := components.ConvertContext(ctx, tt.flags...)
+			if err1 != nil {
+				return
+			}
+
+			execFunc = func(command commands.Command) error {
+				return nil
+			}
+			// Replace execFunc with the mockExec function
+			defer func() { execFunc = exec }() // Restore original execFunc after test
+
+			err := createEvidence(context)
+			if tt.expectErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func setDefaultValue(flag string, defaultValue string) components.Flag {
+	f := components.NewStringFlag(flag, flag)
+	f.DefaultValue = defaultValue
+	return f
+}

evidence/cli/command_custom.go

@@ -17,14 +17,14 @@ func NewEvidenceCustomCommand(ctx *components.Context, execute execCommandFunc)
 		execute: execute,
 	}
 }
-
-func (ecc *evidenceCustomCommand) CreateEvidence(serverDetails *coreConfig.ServerDetails) error {
+func (ecc *evidenceCustomCommand) CreateEvidence(_ *components.Context, serverDetails *coreConfig.ServerDetails) error {
 	createCmd := evidence.NewCreateEvidenceCustom(
 		serverDetails,
 		ecc.ctx.GetStringFlagValue(predicate),
 		ecc.ctx.GetStringFlagValue(predicateType),
 		ecc.ctx.GetStringFlagValue(key),
 		ecc.ctx.GetStringFlagValue(keyId),
-		ecc.ctx.GetStringFlagValue(repoPath))
+		ecc.ctx.GetStringFlagValue(subjectRepoPath),
+		ecc.ctx.GetStringFlagValue(subjectSha256))
 	return ecc.execute(createCmd)
 }