Add tests for run methods

Azure · Nov 27, 2024 · f45e661 · f45e661
1 parent dad219d
commit f45e661
Show file tree

Hide file tree

Showing 3 changed files with 131 additions and 22 deletions.
diff --git a/tooling/templatize/pkg/pipeline/run.go b/tooling/templatize/pkg/pipeline/run.go
@@ -48,6 +48,10 @@ type PipelineRunOptions struct {
 func (p *Pipeline) Run(ctx context.Context, options *PipelineRunOptions) error {
 	logger := logr.FromContextOrDiscard(ctx)
 
+	if p.subsciptionLookupFunc == nil {
+		p.subsciptionLookupFunc = lookupSubscriptionID
+	}
+
 	// set working directory to the pipeline file directory for the
 	// duration of the execution so that all commands and file references
 	// within the pipeline file are resolved relative to the pipeline file
@@ -70,28 +74,24 @@ func (p *Pipeline) Run(ctx context.Context, options *PipelineRunOptions) error {
 	}()
 
 	for _, rg := range p.ResourceGroups {
-		err := rg.run(ctx, options)
+		// prepare execution context
+		subscriptionID, err := p.subsciptionLookupFunc(ctx, rg.Subscription)
+		executionTarget := executionTargetImpl{
+			subscriptionName: rg.Subscription,
+			subscriptionID:   subscriptionID,
+			region:           options.Region,
+			resourceGroup:    rg.Name,
+			aksClusterName:   rg.AKSCluster,
+		}
+		err = rg.run(ctx, options, &executionTarget)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (rg *ResourceGroup) run(ctx context.Context, options *PipelineRunOptions) error {
-	// prepare execution context
-	subscriptionID, err := lookupSubscriptionID(ctx, rg.Subscription)
-	if err != nil {
-		return err
-	}
-	executionTarget := executionTargetImpl{
-		subscriptionName: rg.Subscription,
-		subscriptionID:   subscriptionID,
-		region:           options.Region,
-		resourceGroup:    rg.Name,
-		aksClusterName:   rg.AKSCluster,
-	}
-
+func (rg *ResourceGroup) run(ctx context.Context, options *PipelineRunOptions, executionTarget ExecutionTarget) error {
 	logger := logr.FromContextOrDiscard(ctx)
 
 	kubeconfigFile, err := executionTarget.KubeConfig(ctx)
@@ -101,7 +101,7 @@ func (rg *ResourceGroup) run(ctx context.Context, options *PipelineRunOptions) e
 				logger.V(5).Error(err, "failed to delete kubeconfig file", "kubeconfig", kubeconfigFile)
 			}
 		}()
-	} else if err != nil || kubeconfigFile == "" && executionTarget.GetAkSClusterName() != "" {
+	} else if err != nil {
 		return fmt.Errorf("failed to prepare kubeconfig: %w", err)
 	}
 
@@ -118,7 +118,7 @@ func (rg *ResourceGroup) run(ctx context.Context, options *PipelineRunOptions) e
 				),
 			),
 			kubeconfigFile,
-			&executionTarget, options,
+			executionTarget, options,
 		)
 		if err != nil {
 			return err

diff --git a/tooling/templatize/pkg/pipeline/run_test.go b/tooling/templatize/pkg/pipeline/run_test.go
@@ -8,16 +8,18 @@ import (
 )
 
 func TestStepRun(t *testing.T) {
+	fooundOutput := ""
 	s := &Step{
 		Name:    "test",
 		Action:  "Shell",
 		Command: []string{"echo", "hello"},
 		outputFunc: func(output string) {
-			assert.Equal(t, output, "hello\n")
+			fooundOutput = output
 		},
 	}
 	err := s.run(context.Background(), "", &executionTargetImpl{}, &PipelineRunOptions{})
 	assert.NilError(t, err)
+	assert.Equal(t, fooundOutput, "hello\n")
 }
 
 func TestStepRunSkip(t *testing.T) {
@@ -80,3 +82,105 @@ func TestPipelineValidate(t *testing.T) {
 	err := p.Validate()
 	assert.Error(t, err, "resource group name is required")
 }
+
+func TestResourceGroupRun(t *testing.T) {
+	foundOutput := ""
+	rg := &ResourceGroup{
+		Steps: []*Step{
+			{
+				Name:    "step",
+				Action:  "Shell",
+				Command: []string{"echo", "hello"},
+				outputFunc: func(output string) {
+					foundOutput = output
+				},
+			},
+		},
+	}
+	err := rg.run(context.Background(), &PipelineRunOptions{}, &executionTargetImpl{})
+	assert.NilError(t, err)
+	assert.Equal(t, foundOutput, "hello\n")
+}
+
+func TestResourceGroupError(t *testing.T) {
+	tmpVals := make([]string, 0)
+	rg := &ResourceGroup{
+		Steps: []*Step{
+			{
+				Name:    "step",
+				Action:  "Shell",
+				Command: []string{"echo", "hello"},
+				outputFunc: func(output string) {
+					tmpVals = append(tmpVals, output)
+				},
+			},
+			{
+				Name:    "step",
+				Action:  "Shell",
+				Command: []string{"faaaaafffaa"},
+				outputFunc: func(output string) {
+					tmpVals = append(tmpVals, output)
+				},
+			},
+			{
+				Name:    "step",
+				Action:  "Shell",
+				Command: []string{"echo", "hallo"},
+				outputFunc: func(output string) {
+					tmpVals = append(tmpVals, output)
+				},
+			},
+		},
+	}
+	err := rg.run(context.Background(), &PipelineRunOptions{}, &executionTargetImpl{})
+	assert.Error(t, err, "failed to execute shell command:  exec: \"faaaaafffaa\": executable file not found in $PATH")
+	// Test processing ends after first error
+	assert.Equal(t, len(tmpVals), 1)
+}
+
+type testExecutionTarget struct{}
+
+func (t *testExecutionTarget) KubeConfig(_ context.Context) (string, error) {
+	return "", nil
+}
+func (t *testExecutionTarget) GetSubscriptionID() string { return "test" }
+func (t *testExecutionTarget) GetAkSClusterName() string { return "test" }
+func (t *testExecutionTarget) GetResourceGroup() string  { return "test" }
+func (t *testExecutionTarget) GetRegion() string         { return "test" }
+
+func TestResourceGroupRunRequireKubeconfig(t *testing.T) {
+
+	rg := &ResourceGroup{Steps: []*Step{}}
+	err := rg.run(context.Background(), &PipelineRunOptions{}, &testExecutionTarget{})
+	assert.NilError(t, err)
+}
+
+func TestPipelineRun(t *testing.T) {
+	foundOutput := ""
+	pipeline := &Pipeline{
+		ResourceGroups: []*ResourceGroup{
+			{
+				Name:         "test",
+				Subscription: "test",
+				Steps: []*Step{
+					{
+						Name:    "step",
+						Action:  "Shell",
+						Command: []string{"echo", "hello"},
+						outputFunc: func(output string) {
+							foundOutput = output
+						},
+					},
+				},
+			},
+		},
+		subsciptionLookupFunc: func(_ context.Context, _ string) (string, error) {
+			return "test", nil
+		},
+	}
+
+	err := pipeline.Run(context.Background(), &PipelineRunOptions{})
+
+	assert.NilError(t, err)
+	assert.Equal(t, foundOutput, "hello\n")
+}
diff --git a/tooling/templatize/pkg/pipeline/types.go b/tooling/templatize/pkg/pipeline/types.go
@@ -1,10 +1,15 @@
 package pipeline
 
+import "context"
+
+type subsciptionLookup func(context.Context, string) (string, error)
+
 type Pipeline struct {
-	pipelineFilePath string
-	ServiceGroup     string           `yaml:"serviceGroup"`
-	RolloutName      string           `yaml:"rolloutName"`
-	ResourceGroups   []*ResourceGroup `yaml:"resourceGroups"`
+	pipelineFilePath      string
+	ServiceGroup          string           `yaml:"serviceGroup"`
+	RolloutName           string           `yaml:"rolloutName"`
+	ResourceGroups        []*ResourceGroup `yaml:"resourceGroups"`
+	subsciptionLookupFunc subsciptionLookup
 }
 
 type ResourceGroup struct {