chore: add unit tests for creator.LoadPackageDefinition

src/pkg/packager/create.go

@@ -39,11 +39,6 @@ func (p *Packager) Create() (err error) {
 		return err
 	}
 
-	// Perform early package validation.
-	if err := p.cfg.Pkg.Validate(); err != nil {
-		return fmt.Errorf("unable to validate package: %w", err)
-	}
-
 	if !p.confirmAction(config.ZarfCreateStage) {
 		return fmt.Errorf("package creation canceled")
 	}

src/pkg/packager/creator/creator.go

@@ -11,7 +11,7 @@ import (
 
 // Creator is an interface for creating Zarf packages.
 type Creator interface {
-	LoadPackageDefinition(dst *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error)
+	LoadPackageDefinition(src *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error)
 	Assemble(dst *layout.PackagePaths, components []types.ZarfComponent, arch string) error
 	Output(dst *layout.PackagePaths, pkg *types.ZarfPackage) error
 }

src/pkg/packager/creator/normal.go

@@ -61,8 +61,8 @@ func NewPackageCreator(createOpts types.ZarfCreateOptions, cwd string) *PackageC
 }
 
 // LoadPackageDefinition loads and configures a zarf.yaml file during package create.
-func (pc *PackageCreator) LoadPackageDefinition(dst *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error) {
-	pkg, warnings, err = dst.ReadZarfYAML()
+func (pc *PackageCreator) LoadPackageDefinition(src *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error) {
+	pkg, warnings, err = src.ReadZarfYAML()
 	if err != nil {
 		return types.ZarfPackage{}, nil, err
 	}
@@ -86,7 +86,7 @@ func (pc *PackageCreator) LoadPackageDefinition(dst *layout.PackagePaths) (pkg t
 	warnings = append(warnings, templateWarnings...)
 
 	// After templates are filled process any create extensions
-	pkg.Components, err = pc.processExtensions(pkg.Components, dst, pkg.Metadata.YOLO)
+	pkg.Components, err = pc.processExtensions(pkg.Components, src, pkg.Metadata.YOLO)
 	if err != nil {
 		return types.ZarfPackage{}, nil, err
 	}
@@ -119,6 +119,11 @@ func (pc *PackageCreator) LoadPackageDefinition(dst *layout.PackagePaths) (pkg t
 		}
 	}
 
+	// Perform early package validation.
+	if err := pkg.Validate(); err != nil {
+		return types.ZarfPackage{}, nil, fmt.Errorf("unable to validate package: %w", err)
+	}
+
 	return pkg, warnings, nil
 }
 

src/pkg/packager/creator/normal_test.go

@@ -8,6 +8,8 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/defenseunicorns/zarf/src/pkg/layout"
+	"github.com/defenseunicorns/zarf/src/types"
 	"github.com/stretchr/testify/require"
 )
 
@@ -56,3 +58,44 @@ func TestDifferentialPackagePathSetCorrectly(t *testing.T) {
 		})
 	}
 }
+
+func TestLoadPackageDefinition(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		testDir   string
+		expectErr bool
+	}{
+		{
+			name:      "valid package definition",
+			testDir:   "valid",
+			expectErr: false,
+		},
+		{
+			name:      "invalid package definition",
+			testDir:   "invalid",
+			expectErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			src := layout.New(filepath.Join("testdata", tt.testDir))
+			pc := NewPackageCreator(types.ZarfCreateOptions{}, "")
+			pkg, _, err := pc.LoadPackageDefinition(src)
+
+			switch {
+			case tt.expectErr:
+				require.Error(t, err)
+				require.Empty(t, pkg)
+			default:
+				require.NoError(t, err)
+				require.NotEmpty(t, pkg)
+			}
+		})
+	}
+}

src/pkg/packager/creator/skeleton.go

@@ -42,8 +42,8 @@ func NewSkeletonCreator(createOpts types.ZarfCreateOptions, publishOpts types.Za
 }
 
 // LoadPackageDefinition loads and configure a zarf.yaml file when creating and publishing a skeleton package.
-func (sc *SkeletonCreator) LoadPackageDefinition(dst *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error) {
-	pkg, warnings, err = dst.ReadZarfYAML()
+func (sc *SkeletonCreator) LoadPackageDefinition(src *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error) {
+	pkg, warnings, err = src.ReadZarfYAML()
 	if err != nil {
 		return types.ZarfPackage{}, nil, err
 	}
@@ -60,11 +60,16 @@ func (sc *SkeletonCreator) LoadPackageDefinition(dst *layout.PackagePaths) (pkg
 
 	warnings = append(warnings, composeWarnings...)
 
-	pkg.Components, err = sc.processExtensions(pkg.Components, dst)
+	pkg.Components, err = sc.processExtensions(pkg.Components, src)
 	if err != nil {
 		return types.ZarfPackage{}, nil, err
 	}
 
+	// Perform early package validation.
+	if err := pkg.Validate(); err != nil {
+		return types.ZarfPackage{}, nil, fmt.Errorf("unable to validate package: %w", err)
+	}
+
 	for _, warning := range warnings {
 		message.Warn(warning)
 	}

src/pkg/packager/creator/skeleton_test.go

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2021-Present The Zarf Authors
+
+// Package creator contains functions for creating Zarf packages.
+package creator
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/defenseunicorns/zarf/src/pkg/layout"
+	"github.com/defenseunicorns/zarf/src/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSkeletonLoadPackageDefinition(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		testDir   string
+		expectErr bool
+	}{
+		{
+			name:      "valid package definition",
+			testDir:   "valid",
+			expectErr: false,
+		},
+		{
+			name:      "invalid package definition",
+			testDir:   "invalid",
+			expectErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			src := layout.New(filepath.Join("testdata", tt.testDir))
+			sc := NewSkeletonCreator(types.ZarfCreateOptions{}, types.ZarfPublishOptions{})
+			pkg, _, err := sc.LoadPackageDefinition(src)
+
+			switch {
+			case tt.expectErr:
+				require.Error(t, err)
+				require.Empty(t, pkg)
+			default:
+				require.NoError(t, err)
+				require.NotEmpty(t, pkg)
+			}
+		})
+	}
+}

src/pkg/packager/creator/testdata/invalid/zarf.yaml

@@ -0,0 +1,5 @@
+kind: ZarfPackageConfig
+metadata:
+  name: minimal-invalid
+  # must have at least 1 component
+  description: Minimal invalid package

src/pkg/packager/creator/testdata/valid/zarf.yaml

@@ -0,0 +1,6 @@
+kind: ZarfPackageConfig
+metadata:
+  name: minimal-valid
+  description: Minimal valid package
+components:
+  - name: component1

src/types/validate.go

@@ -5,6 +5,7 @@
 package types
 
 import (
+	"errors"
 	"fmt"
 	"path/filepath"
 	"regexp"
@@ -47,6 +48,10 @@ func (pkg ZarfPackage) Validate() error {
 		return fmt.Errorf(lang.PkgValidateErrPkgName, pkg.Metadata.Name)
 	}
 
+	if pkg.Components == nil {
+		return errors.New("package must have at least 1 component")
+	}
+
 	for _, variable := range pkg.Variables {
 		if err := variable.Validate(); err != nil {
 			return fmt.Errorf(lang.PkgValidateErrVariable, err)