return err on cyclical dependencies

src/extensions/bigbang/bigbang.go

@@ -104,7 +104,10 @@ func Run(tmpPaths types.ComponentPaths, c types.ZarfComponent) (types.ZarfCompon
 	c.Repos = append(c.Repos, urls...)
 
 	// Generate a list of HelmReleases that need to be deployed in order.
-	helmReleases := utils.SortDependencies(hrDependencies)
+	helmReleases, err := utils.SortDependencies(hrDependencies)
+	if err != nil {
+		return c, fmt.Errorf("unable to sort Big Bang HelmReleases: %w", err)
+	}
 
 	tenMinsInSecs := 10 * 60
 

src/pkg/utils/sort.go

@@ -4,6 +4,8 @@
 // Package utils provides generic helper functions.
 package utils
 
+import "fmt"
+
 // DependsOn is a struct that represents a node in a list of dependencies.
 type DependsOn struct {
 	Name         string
@@ -20,7 +22,7 @@ type DependsOn struct {
 //
 // Note sort order is dependent on the slice order of the input data for
 // nodes with the same in-degree (i.e. the same number of dependencies).
-func SortDependencies(data []DependsOn) []string {
+func SortDependencies(data []DependsOn) ([]string, error) {
 	// Initialize the in-degree and out-degree maps.
 	inDegree := make(map[string]int)
 	outDegree := make(map[string][]string)
@@ -70,10 +72,10 @@ func SortDependencies(data []DependsOn) []string {
 	// Return an empty result list to indicate this.
 	for _, degree := range inDegree {
 		if degree > 0 {
-			return []string{}
+			return result, fmt.Errorf("dependency cycle detected")
 		}
 	}
 
 	// Return the result list.
-	return result
+	return result, nil
 }

src/pkg/utils/sort_test.go

@@ -7,13 +7,16 @@ package utils
 import (
 	"reflect"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSortDependencies(t *testing.T) {
 	tests := []struct {
 		name     string
 		data     []DependsOn // input data: a map of nodes to their dependencies
 		expected []string    // expected output: a slice of nodes in order of their precedence
+		success  bool        // whether the test should succeed or fail
 	}{
 		{
 			name: "simple graph",
@@ -32,6 +35,7 @@ func TestSortDependencies(t *testing.T) {
 			},
 			// C has no dependencies, B depends on C, and A depends on both B and C
 			expected: []string{"C", "B", "A"},
+			success:  true,
 		},
 		{
 			name: "complex graph",
@@ -57,6 +61,7 @@ func TestSortDependencies(t *testing.T) {
 				},
 			},
 			expected: []string{"E", "D", "C", "B", "A"},
+			success:  true,
 		},
 		{
 			name: "graph with multiple roots",
@@ -84,6 +89,7 @@ func TestSortDependencies(t *testing.T) {
 				},
 			},
 			expected: []string{"F", "B", "A", "E", "C", "D"},
+			success:  true,
 		},
 		{
 			name: "graph with multiple sinks",
@@ -115,12 +121,37 @@ func TestSortDependencies(t *testing.T) {
 				},
 			},
 			expected: []string{"F", "C", "E", "B", "G", "D", "A"},
+			success:  true,
+		},
+		{
+			name: "graph with circular dependencies",
+			data: []DependsOn{
+				{
+					Name:         "A",
+					Dependencies: []string{"B"},
+				},
+				{
+					Name:         "B",
+					Dependencies: []string{"C"},
+				},
+				{
+					Name:         "C",
+					Dependencies: []string{"A"},
+				},
+			},
+			expected: []string{},
+			success:  false,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := SortDependencies(tt.data)
+			result, err := SortDependencies(tt.data)
+			if tt.success {
+				assert.NoError(t, err)
+			} else {
+				assert.Error(t, err)
+			}
 			if !reflect.DeepEqual(result, tt.expected) {
 				t.Errorf("expected %v but got %v", tt.expected, result)
 			}