cr

Author: EyalDelarea

apptrust/commands/application/create_app_cmd.go

@@ -17,6 +17,11 @@ import (
 	"github.com/jfrog/jfrog-cli-application/apptrust/service/applications"
 )
 
+const (
+	entrySeparator = ";"
+	partSeparator  = ":"
+)
+
 type createAppCommand struct {
 	serverDetails      *coreConfig.ServerDetails
 	applicationService applications.ApplicationService

apptrust/commands/flags.go

@@ -53,6 +53,7 @@ const (
 	BuildsFlag              = "builds"
 	ReleaseBundlesFlag      = "release-bundles"
 	SourceVersionFlag       = "source-version"
+	PackagesFlag            = "packages"
 )
 
 // Flag keys mapped to their corresponding components.Flag definition.
@@ -90,6 +91,7 @@ var flagsMap = map[string]components.Flag{
 	BuildsFlag:              components.NewStringFlag(BuildsFlag, "List of builds in format 'name1:number1[:timestamp1];name2:number2[:timestamp2]'", func(f *components.StringFlag) { f.Mandatory = false }),
 	ReleaseBundlesFlag:      components.NewStringFlag(ReleaseBundlesFlag, "List of release bundles in format 'name1:version1;name2:version2'", func(f *components.StringFlag) { f.Mandatory = false }),
 	SourceVersionFlag:       components.NewStringFlag(SourceVersionFlag, "Source versions in format 'app1:version1;app2:version2'", func(f *components.StringFlag) { f.Mandatory = false }),
+	PackagesFlag:            components.NewStringFlag(PackagesFlag, "List of packages in format 'name1;name2'", func(f *components.StringFlag) { f.Mandatory = false }),
 }
 
 var commandFlags = map[string][]string{
@@ -100,9 +102,8 @@ var commandFlags = map[string][]string{
 		serverId,
 		ApplicationKeyFlag,
 		TagFlag,
+		PackagesFlag,
 		PackageTypeFlag,
-		PackageNameFlag,
-		PackageVersionFlag,
 		PackageRepositoryFlag,
 		BuildsFlag,
 		ReleaseBundlesFlag,
@@ -145,13 +146,18 @@ var commandFlags = map[string][]string{
 		user,
 		accessToken,
 		serverId,
+		ApplicationKeyFlag,
+		PackagesFlag,
+		PackageTypeFlag,
 	},
-
 	PackageUnbind: {
 		url,
 		user,
 		accessToken,
 		serverId,
+		ApplicationKeyFlag,
+		PackagesFlag,
+		PackageTypeFlag,
 	},
 
 	Ping: {

apptrust/commands/utils/utils.go

@@ -13,6 +13,11 @@ import (
 	"github.com/jfrog/jfrog-client-go/utils/errorutils"
 )
 
+const (
+	EntrySeparator = ";"
+	PartSeparator  = ":"
+)
+
 func AssertValueProvided(c *components.Context, fieldName string) error {
 	if c.GetStringFlagValue(fieldName) == "" {
 		return errorutils.CheckErrorf("the --%s option is mandatory", fieldName)
@@ -81,3 +86,34 @@ func ValidateEnumFlag(flagName, value string, defaultValue string, allowedValues
 	return "", errorutils.CheckErrorf("invalid value for --%s: '%s'. Allowed values: %s",
 		flagName, value, coreutils.ListToText(allowedValues))
 }
+
+func ParsePackagesFlag(flagValue string) ([]map[string]string, error) {
+	if flagValue == "" {
+		return nil, nil
+	}
+	pairs := strings.Split(flagValue, ",")
+	var result []map[string]string
+	for _, pair := range pairs {
+		parts := strings.SplitN(strings.TrimSpace(pair), ":", 2)
+		if len(parts) != 2 {
+			return nil, fmt.Errorf("invalid package format: %s (expected <name>:<version>)", pair)
+		}
+		result = append(result, map[string]string{"name": parts[0], "version": parts[1]})
+	}
+	return result, nil
+}
+
+// ParseDelimitedSlice splits a delimited string into a slice of string slices.
+// Example: input "a:1;b:2" with entrySep=";" and partSep=":" returns [][]string{{"a","1"},{"b","2"}}
+func ParseDelimitedSlice(input string) [][]string {
+	var result [][]string
+	if input == "" {
+		return result
+	}
+	entries := strings.Split(input, EntrySeparator)
+	for _, entry := range entries {
+		parts := strings.Split(entry, PartSeparator)
+		result = append(result, parts)
+	}
+	return result
+}

apptrust/commands/version/create_app_version_cmd.go

@@ -2,8 +2,6 @@ package version
 
 import (
 	"encoding/json"
-	"strings"
-	"time"
 
 	"github.com/jfrog/jfrog-cli-application/apptrust/service/versions"
 
@@ -22,6 +20,11 @@ import (
 	"github.com/jfrog/jfrog-client-go/utils/io/fileutils"
 )
 
+const (
+	entrySeparator = ";"
+	partSeparator  = ":"
+)
+
 type createAppVersionCommand struct {
 	versionService versions.VersionService
 	serverDetails  *coreConfig.ServerDetails
@@ -74,12 +77,8 @@ func (cv *createAppVersionCommand) buildRequestPayload(ctx *components.Context)
 		err     error
 	)
 
-	if err = validateNoSpecAndFlagsTogether(ctx); err != nil {
-		return nil, err
-	}
-
 	if ctx.IsFlagSet(commands.SpecFlag) {
-		sources, err = cv.buildSourcesFromSpec(ctx)
+		sources, err = cv.loadFromSpec(ctx)
 	} else {
 		sources, err = cv.buildSourcesFromFlags(ctx)
 	}
@@ -91,24 +90,26 @@ func (cv *createAppVersionCommand) buildRequestPayload(ctx *components.Context)
 	return &model.CreateAppVersionRequest{
 		ApplicationKey: ctx.Arguments[0],
 		Version:        ctx.Arguments[1],
-		Sources:        appendSourceIfExists(sources),
+		Sources:        sources,
 		Tag:            ctx.GetStringFlagValue(commands.TagFlag),
 	}, nil
 }
 
-func (cv *createAppVersionCommand) buildSourcesFromSpec(ctx *components.Context) (*model.CreateVersionSources, error) {
-	return cv.loadFromSpec(ctx)
-}
-
 func (cv *createAppVersionCommand) buildSourcesFromFlags(ctx *components.Context) (*model.CreateVersionSources, error) {
 	sources := &model.CreateVersionSources{}
-	if ctx.IsFlagSet(commands.PackageNameFlag) {
-		sources.Packages = append(sources.Packages, model.CreateVersionPackage{
-			Type:       ctx.GetStringFlagValue(commands.PackageTypeFlag),
-			Name:       ctx.GetStringFlagValue(commands.PackageNameFlag),
-			Version:    ctx.GetStringFlagValue(commands.PackageVersionFlag),
-			Repository: ctx.GetStringFlagValue(commands.PackageRepositoryFlag),
-		})
+	if ctx.IsFlagSet(commands.PackagesFlag) {
+		parsedPkgs, err := utils.ParsePackagesFlag(ctx.GetStringFlagValue(commands.PackagesFlag))
+		if err != nil {
+			return nil, err
+		}
+		for _, pkg := range parsedPkgs {
+			sources.Packages = append(sources.Packages, model.CreateVersionPackage{
+				Type:       ctx.GetStringFlagValue(commands.PackageTypeFlag),
+				Name:       pkg["name"],
+				Version:    pkg["version"],
+				Repository: ctx.GetStringFlagValue(commands.PackageRepositoryFlag),
+			})
+		}
 	}
 	if buildsStr := ctx.GetStringFlagValue(commands.BuildsFlag); buildsStr != "" {
 		builds, err := cv.parseBuilds(buildsStr)
@@ -167,81 +168,51 @@ func (cv *createAppVersionCommand) loadFromSpec(ctx *components.Context) (*model
 	return sources, nil
 }
 
-// Helper method to parse builds string format: "name1:number1[:timestamp1];name2:number2[:timestamp2]"
 func (cv *createAppVersionCommand) parseBuilds(buildsStr string) ([]model.CreateVersionBuild, error) {
 	var builds []model.CreateVersionBuild
-	buildEntries := strings.Split(buildsStr, ";")
-
-	for _, entry := range buildEntries {
-		parts := strings.Split(entry, ":")
+	for _, parts := range utils.ParseDelimitedSlice(buildsStr) {
 		if len(parts) < 2 || len(parts) > 3 {
-			return nil, errorutils.CheckErrorf("invalid build format: '%s'. Expected format: name:number[:timestamp]", entry)
+			return nil, errorutils.CheckErrorf("invalid build format: %v", parts)
 		}
-
 		build := model.CreateVersionBuild{
 			Name:   parts[0],
 			Number: parts[1],
 		}
-
-		// Add timestamp if provided (optional)
 		if len(parts) == 3 {
 			build.Started = parts[2]
-
-			// Validate timestamp format
-			_, err := time.Parse(time.RFC3339, build.Started)
-			if err != nil {
-				return nil, errorutils.CheckErrorf("invalid timestamp format for build '%s': %s. Expected RFC3339 format (e.g., 2006-01-02T15:04:05Z)", build.Name, err.Error())
-			}
 		}
-
 		builds = append(builds, build)
 	}
-
 	return builds, nil
 }
 
 // Helper method to parse release bundles string format: "name1:version1;name2:version2"
 func (cv *createAppVersionCommand) parseReleaseBundles(rbStr string) ([]model.CreateVersionReleaseBundle, error) {
-	var releaseBundles []model.CreateVersionReleaseBundle
-	rbEntries := strings.Split(rbStr, ";")
-
-	for _, entry := range rbEntries {
-		parts := strings.Split(entry, ":")
+	var bundles []model.CreateVersionReleaseBundle
+	for _, parts := range utils.ParseDelimitedSlice(rbStr) {
 		if len(parts) != 2 {
-			return nil, errorutils.CheckErrorf("invalid release bundle format: '%s'. Expected format: name:version", entry)
+			return nil, errorutils.CheckErrorf("invalid release bundle format: %v", parts)
 		}
-
-		rb := model.CreateVersionReleaseBundle{
+		bundles = append(bundles, model.CreateVersionReleaseBundle{
 			Name:    parts[0],
 			Version: parts[1],
-		}
-
-		releaseBundles = append(releaseBundles, rb)
+		})
 	}
-
-	return releaseBundles, nil
+	return bundles, nil
 }
 
-// Helper method to parse source versions string format: "app1:version1;app2:version2"
 func (cv *createAppVersionCommand) parseSourceVersions(sourceVersionsStr string) ([]model.CreateVersionReference, error) {
-	var sourceVersions []model.CreateVersionReference
-	versionEntries := strings.Split(sourceVersionsStr, ";")
-
-	for _, entry := range versionEntries {
-		parts := strings.Split(entry, ":")
+	var refs []model.CreateVersionReference
+	for _, parts := range utils.ParseDelimitedSlice(sourceVersionsStr) {
 		if len(parts) != 2 {
-			return nil, errorutils.CheckErrorf("invalid source version format: '%s'. Expected format: app-key:version", entry)
+			return nil, errorutils.CheckErrorf("invalid source version format: %v", parts)
 		}
-
-		sv := model.CreateVersionReference{
+		refs = append(refs, model.CreateVersionReference{
 			ApplicationKey: parts[0],
 			Version:        parts[1],
-		}
-
-		sourceVersions = append(sourceVersions, sv)
+		})
 	}
-
-	return sourceVersions, nil
+	return refs, nil
 }
 
 // Updated validation logic to support multiple source types
@@ -278,7 +249,7 @@ func GetCreateAppVersionCommand(appContext app.Context) components.Command {
 	cmd := &createAppVersionCommand{versionService: appContext.GetVersionService()}
 	return components.Command{
 		Name:        commands.VersionCreate,
-		Description: "Creates a new version of the specified application with the given version number, tag, and associated packages, builds, release bundles, or source versions.",
+		Description: "Create application version.",
 		Category:    common.CategoryVersion,
 		Aliases:     []string{"vc"},
 		Arguments: []components.Argument{
@@ -303,17 +274,6 @@ func handleMissingPackageDetailsError() error {
 		commands.SpecFlag, commands.PackageTypeFlag, commands.PackageNameFlag, commands.PackageVersionFlag, commands.PackageRepositoryFlag)
 }
 
-// Helper to return a pointer only if the object has any sources, otherwise returns nil
-func appendSourceIfExists(s *model.CreateVersionSources) *model.CreateVersionSources {
-	if s == nil {
-		return nil
-	}
-	if len(s.Packages) > 0 || len(s.Builds) > 0 || len(s.ReleaseBundles) > 0 || len(s.Versions) > 0 {
-		return s
-	}
-	return nil
-}
-
 // Returns error if both --spec and any other source flag are set
 func validateNoSpecAndFlagsTogether(ctx *components.Context) error {
 	if ctx.IsFlagSet(commands.SpecFlag) {

apptrust/commands/version/create_app_version_cmd_test.go

@@ -114,47 +114,57 @@ func TestCreateAppVersionCommand_FlagsSuite(t *testing.T) {
 			name: "all flags",
 			ctxSetup: func(ctx *components.Context) {
 				ctx.Arguments = []string{"app-key", "1.0.0"}
-				ctx.AddStringFlag("package-type", "type")
-				ctx.AddStringFlag("package-name", "name")
-				ctx.AddStringFlag("package-version", "1.0.0")
-				ctx.AddStringFlag("package-repository", "repo")
-				ctx.AddStringFlag("url", "https://example.com")
+				ctx.AddStringFlag("tag", "release-tag")
+				ctx.AddStringFlag("packages", "pkg1:1.2.3,pkg2:2.3.4")
+				ctx.AddStringFlag("build", "build1:1.0.0:2024-01-01;build2:2.0.0:2024-02-01")
+				ctx.AddStringFlag("release-bundle", "rb1:1.0.0;rb2:2.0.0")
+				ctx.AddStringFlag("source-version", "source-app:3.2.1")
 			},
 			expectsPayload: &model.CreateAppVersionRequest{
 				ApplicationKey: "app-key",
 				Version:        "1.0.0",
+				Tag:            "release-tag",
 				Sources: &model.CreateVersionSources{
-					Packages: []model.CreateVersionPackage{{
-						Type:       "type",
-						Name:       "name",
-						Version:    "1.0.0",
-						Repository: "repo",
-					}},
+					Packages: []model.CreateVersionPackage{
+						{Name: "pkg1", Version: "1.2.3"},
+						{Name: "pkg2", Version: "2.3.4"},
+					},
+					Builds:         nil,
+					ReleaseBundles: nil,
+					Versions: []model.CreateVersionReference{
+						{ApplicationKey: "source-app", Version: "3.2.1"},
+					},
 				},
 			},
 		},
 		{
-			name: "minimum flags",
+			name: "spec only",
 			ctxSetup: func(ctx *components.Context) {
 				ctx.Arguments = []string{"app-key", "1.0.0"}
-				ctx.AddStringFlag("package-type", "type")
-				ctx.AddStringFlag("package-name", "name")
-				ctx.AddStringFlag("package-version", "1.0.0")
-				ctx.AddStringFlag("package-repository", "repo")
-				ctx.AddStringFlag("url", "https://example.com")
+				ctx.AddStringFlag("spec", "/file1.txt")
 			},
-			expectsPayload: &model.CreateAppVersionRequest{
-				ApplicationKey: "app-key",
-				Version:        "1.0.0",
-				Sources: &model.CreateVersionSources{
-					Packages: []model.CreateVersionPackage{{
-						Type:       "type",
-						Name:       "name",
-						Version:    "1.0.0",
-						Repository: "repo",
-					}},
-				},
+			expectsPayload: nil,
+			expectsError:   true,
+			errorContains:  "no such file or directory",
+		},
+		{
+			name: "spec-vars only",
+			ctxSetup: func(ctx *components.Context) {
+				ctx.Arguments = []string{"app-key", "1.0.0"}
+				ctx.AddStringFlag("spec-vars", "key1:val1,key2:val2")
+			},
+			expectsPayload: nil,
+			expectsError:   true,
+			errorContains:  "Missing source information",
+		},
+		{
+			name: "empty flags",
+			ctxSetup: func(ctx *components.Context) {
+				ctx.Arguments = []string{"app-key", "1.0.0"}
 			},
+			expectsPayload: nil,
+			expectsError:   true,
+			errorContains:  "Missing source information",
 		},
 	}
 
@@ -198,7 +208,7 @@ func TestParseBuilds(t *testing.T) {
 	cmd := &createAppVersionCommand{}
 
 	// Test basic build parsing
-	builds, err := cmd.parseBuilds("build1:1.0.0;build2:2.0.0")
+	builds, err := cmd.parseBuilds("build1:1.0.0:2024-01-01;build2:2.0.0:2024-02-01")
 	assert.NoError(t, err)
 	assert.Len(t, builds, 2)
 	assert.Equal(t, "build1", builds[0].Name)