Refactor: rename resolvedStack variables to stack

Rename all variables of type model.Stack from 'resolvedStack' to 'stack'
for improved code readability and consistency. This change affects:

- Interface method parameters in Deployer and Differ
- Method implementations in AWSDeployer and DefaultDiffer
- Test files with mock expectations and variable declarations
- Internal helper methods and local variables

No functional changes - purely a refactoring to use cleaner,
more concise variable names throughout the codebase.

Author: orien

cmd/deploy.go

@@ -44,7 +44,7 @@ Examples:
 
 The preview shows the same detailed diff information as 'stackaroo diff' but 
 automatically proceeds with deployment after displaying the changes.`,
-	Args:  cobra.ExactArgs(1),
+	Args: cobra.ExactArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		stackName := args[0]
 		ctx := context.Background()

cmd/deploy_test.go

@@ -26,8 +26,8 @@ type MockDeployer struct {
 	mock.Mock
 }
 
-func (m *MockDeployer) DeployStack(ctx context.Context, resolvedStack *model.Stack) error {
-	args := m.Called(ctx, resolvedStack)
+func (m *MockDeployer) DeployStack(ctx context.Context, stack *model.Stack) error {
+	args := m.Called(ctx, stack)
 	return args.Error(0)
 }
 
@@ -110,8 +110,8 @@ stacks:
 
 	// Set up mock deployer that returns an error
 	mockDeployer := &MockDeployer{}
-	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(resolvedStack *model.Stack) bool {
-		return resolvedStack.Name == "test-stack"
+	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(stack *model.Stack) bool {
+		return stack.Name == "test-stack"
 	})).Return(errors.New("deployment failed"))
 
 	oldDeployer := deployer
@@ -201,12 +201,12 @@ stacks:
 	mockDeployer := &MockDeployer{}
 
 	// Expect specific calls with exact argument matching
-	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(resolvedStack *model.Stack) bool {
-		return resolvedStack.Name == "stack-1"
+	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(stack *model.Stack) bool {
+		return stack.Name == "stack-1"
 	})).Return(nil).Once()
 
-	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(resolvedStack *model.Stack) bool {
-		return resolvedStack.Name == "stack-2"
+	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(stack *model.Stack) bool {
+		return stack.Name == "stack-2"
 	})).Return(errors.New("second deployment failed")).Once()
 
 	oldDeployer := deployer
@@ -295,11 +295,11 @@ stacks:
 	// Set up mock deployer that expects config-resolved values
 	mockDeployer := &MockDeployer{}
 	// Expect Stack with resolved parameters from dev environment
-	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(resolvedStack *model.Stack) bool {
-		return resolvedStack.Name == "vpc" &&
-			resolvedStack.Parameters["VpcCidr"] == "10.1.0.0/16" &&
-			strings.Contains(resolvedStack.TemplateBody, "AWSTemplateFormatVersion") &&
-			strings.Contains(resolvedStack.TemplateBody, "AWS::EC2::VPC")
+	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(stack *model.Stack) bool {
+		return stack.Name == "vpc" &&
+			stack.Parameters["VpcCidr"] == "10.1.0.0/16" &&
+			strings.Contains(stack.TemplateBody, "AWSTemplateFormatVersion") &&
+			strings.Contains(stack.TemplateBody, "AWS::EC2::VPC")
 	})).Return(nil)
 
 	oldDeployer := deployer
@@ -382,8 +382,8 @@ stacks:
 	// This test will fail because current implementation doesn't resolve dependencies
 	// We expect the resolver to be called and handle the dependency ordering
 	// For now, just expect app deployment (what current implementation does)
-	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(resolvedStack *model.Stack) bool {
-		return resolvedStack.Name == "app" // Current implementation only deploys single stack
+	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(stack *model.Stack) bool {
+		return stack.Name == "app" // Current implementation only deploys single stack
 	})).Return(nil)
 
 	oldDeployer := deployer
@@ -459,8 +459,8 @@ stacks:
 
 	// Current implementation only deploys the directly requested stack
 	// Transitive dependency resolution is not yet implemented
-	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(resolvedStack *model.Stack) bool {
-		return resolvedStack.Name == "app"
+	mockDeployer.On("DeployStack", mock.Anything, mock.MatchedBy(func(stack *model.Stack) bool {
+		return stack.Name == "app"
 	})).Return(nil).Once()
 
 	oldDeployer := deployer

cmd/diff_test.go

@@ -21,8 +21,8 @@ type MockDiffer struct {
 	mock.Mock
 }
 
-func (m *MockDiffer) DiffStack(ctx context.Context, resolvedStack *model.Stack, options diff.Options) (*diff.Result, error) {
-	args := m.Called(ctx, resolvedStack, options)
+func (m *MockDiffer) DiffStack(ctx context.Context, stack *model.Stack, options diff.Options) (*diff.Result, error) {
+	args := m.Called(ctx, stack, options)
 	return args.Get(0).(*diff.Result), args.Error(1)
 }
 

internal/config/file/provider.go

@@ -50,7 +50,7 @@ func (fp *Provider) LoadConfig(ctx context.Context, context string) (*config.Con
 	resolvedContext := fp.resolveContext(context, rawContext)
 
 	// Resolve all stacks for this context
-	resolvedStacks, err := fp.resolveStacks(context)
+	stacks, err := fp.resolveStacks(context)
 	if err != nil {
 		return nil, fmt.Errorf("failed to resolve stacks for context '%s': %w", context, err)
 	}
@@ -61,7 +61,7 @@ func (fp *Provider) LoadConfig(ctx context.Context, context string) (*config.Con
 		Region:  fp.rawConfig.Region, // Global default
 		Tags:    fp.copyStringMap(fp.rawConfig.Tags),
 		Context: resolvedContext,
-		Stacks:  resolvedStacks,
+		Stacks:  stacks,
 	}
 
 	return cfg, nil
@@ -101,12 +101,12 @@ func (fp *Provider) GetStack(stackName, context string) (*config.StackConfig, er
 	}
 
 	// Resolve the stack for the given context
-	resolvedStack, err := fp.resolveStack(rawStack, context)
+	stack, err := fp.resolveStack(rawStack, context)
 	if err != nil {
 		return nil, fmt.Errorf("failed to resolve stack '%s' for context '%s': %w", stackName, context, err)
 	}
 
-	return resolvedStack, nil
+	return stack, nil
 }
 
 // Validate checks the configuration for consistency and errors
@@ -194,11 +194,11 @@ func (fp *Provider) resolveStacks(context string) ([]*config.StackConfig, error)
 	resolved := make([]*config.StackConfig, 0, len(fp.rawConfig.Stacks))
 
 	for _, rawStack := range fp.rawConfig.Stacks {
-		resolvedStack, err := fp.resolveStack(rawStack, context)
+		stack, err := fp.resolveStack(rawStack, context)
 		if err != nil {
 			return nil, err
 		}
-		resolved = append(resolved, resolvedStack)
+		resolved = append(resolved, stack)
 	}
 
 	return resolved, nil

internal/deploy/deployer.go

@@ -18,7 +18,7 @@ import (
 
 // Deployer defines the interface for stack deployment operations
 type Deployer interface {
-	DeployStack(ctx context.Context, resolvedStack *model.Stack) error
+	DeployStack(ctx context.Context, stack *model.Stack) error
 	ValidateTemplate(ctx context.Context, templateFile string) error
 }
 
@@ -45,40 +45,40 @@ func NewDefaultDeployer(ctx context.Context) (*AWSDeployer, error) {
 }
 
 // DeployStack deploys a CloudFormation stack using changesets for preview and deployment
-func (d *AWSDeployer) DeployStack(ctx context.Context, resolvedStack *model.Stack) error {
+func (d *AWSDeployer) DeployStack(ctx context.Context, stack *model.Stack) error {
 	// Get CloudFormation operations
 	cfnOps := d.awsClient.NewCloudFormationOperations()
 
 	// Check if stack exists to determine deployment approach
-	exists, err := cfnOps.StackExists(ctx, resolvedStack.Name)
+	exists, err := cfnOps.StackExists(ctx, stack.Name)
 	if err != nil {
 		return fmt.Errorf("failed to check if stack exists: %w", err)
 	}
 
 	if !exists {
 		// For new stacks, use direct creation (changesets are less useful)
-		return d.deployNewStack(ctx, resolvedStack)
+		return d.deployNewStack(ctx, stack)
 	}
 
 	// For existing stacks, use changeset approach for preview + deployment
-	return d.deployWithChangeSet(ctx, resolvedStack)
+	return d.deployWithChangeSet(ctx, stack)
 }
 
 // deployNewStack handles deployment of new stacks using direct creation
-func (d *AWSDeployer) deployNewStack(ctx context.Context, resolvedStack *model.Stack) error {
-	fmt.Printf("=== Creating new stack %s ===\n", resolvedStack.Name)
+func (d *AWSDeployer) deployNewStack(ctx context.Context, stack *model.Stack) error {
+	fmt.Printf("=== Creating new stack %s ===\n", stack.Name)
 
 	// Convert parameters to AWS format
-	awsParams := make([]awsinternal.Parameter, 0, len(resolvedStack.Parameters))
-	for key, value := range resolvedStack.Parameters {
+	awsParams := make([]awsinternal.Parameter, 0, len(stack.Parameters))
+	for key, value := range stack.Parameters {
 		awsParams = append(awsParams, awsinternal.Parameter{
 			Key:   key,
 			Value: value,
 		})
 	}
 
 	// Use capabilities from resolved stack, with default fallback
-	capabilities := resolvedStack.Capabilities
+	capabilities := stack.Capabilities
 	if len(capabilities) == 0 {
 		capabilities = []string{"CAPABILITY_IAM"} // Default capability
 	}
@@ -96,10 +96,10 @@ func (d *AWSDeployer) deployNewStack(ctx context.Context, resolvedStack *model.S
 	}
 
 	deployInput := awsinternal.DeployStackInput{
-		StackName:    resolvedStack.Name,
-		TemplateBody: resolvedStack.TemplateBody,
+		StackName:    stack.Name,
+		TemplateBody: stack.TemplateBody,
 		Parameters:   awsParams,
-		Tags:         resolvedStack.Tags,
+		Tags:         stack.Tags,
 		Capabilities: capabilities,
 	}
 
@@ -112,58 +112,58 @@ func (d *AWSDeployer) deployNewStack(ctx context.Context, resolvedStack *model.S
 		return fmt.Errorf("failed to create stack: %w", err)
 	}
 
-	fmt.Printf("Stack %s create completed successfully\n", resolvedStack.Name)
+	fmt.Printf("Stack %s create completed successfully\n", stack.Name)
 	return nil
 }
 
 // deployWithChangeSet handles deployment using changeset preview + execution
-func (d *AWSDeployer) deployWithChangeSet(ctx context.Context, resolvedStack *model.Stack) error {
+func (d *AWSDeployer) deployWithChangeSet(ctx context.Context, stack *model.Stack) error {
 	// Create differ for consistent change display
-	fmt.Printf("=== Calculating changes for stack %s ===\n", resolvedStack.Name)
+	fmt.Printf("=== Calculating changes for stack %s ===\n", stack.Name)
 
 	cfnOps := d.awsClient.NewCloudFormationOperations()
 	differ := diff.NewDiffer(cfnOps)
 
 	// Generate diff result using the same system as 'stackaroo diff'
 	diffOptions := diff.Options{Format: "text"}
-	diffResult, err := differ.DiffStack(ctx, resolvedStack, diffOptions)
+	diffResult, err := differ.DiffStack(ctx, stack, diffOptions)
 	if err != nil {
 		return fmt.Errorf("failed to calculate changes: %w", err)
 	}
 
 	// Show preview using consistent formatting
 	if diffResult.HasChanges() {
-		fmt.Printf("Changes to be applied to stack %s:\n\n", resolvedStack.Name)
+		fmt.Printf("Changes to be applied to stack %s:\n\n", stack.Name)
 		fmt.Print(diffResult.String())
 		fmt.Println()
 	} else {
-		fmt.Printf("No changes detected for stack %s\n", resolvedStack.Name)
+		fmt.Printf("No changes detected for stack %s\n", stack.Name)
 		return nil
 	}
 
 	// Create separate changeset for execution (since differ deletes its changesets)
 	changeSetMgr := diff.NewChangeSetManager(cfnOps)
 
 	// Use capabilities from resolved stack, with default fallback
-	capabilities := resolvedStack.Capabilities
+	capabilities := stack.Capabilities
 	if len(capabilities) == 0 {
 		capabilities = []string{"CAPABILITY_IAM"} // Default capability
 	}
 
 	changeSetInfo, err := changeSetMgr.CreateChangeSetForDeployment(
 		ctx,
-		resolvedStack.Name,
-		resolvedStack.TemplateBody,
-		resolvedStack.Parameters,
+		stack.Name,
+		stack.TemplateBody,
+		stack.Parameters,
 		capabilities,
-		resolvedStack.Tags,
+		stack.Tags,
 	)
 	if err != nil {
 		return fmt.Errorf("failed to create changeset for execution: %w", err)
 	}
 
 	// Execute the changeset
-	fmt.Printf("=== Deploying stack %s ===\n", resolvedStack.Name)
+	fmt.Printf("=== Deploying stack %s ===\n", stack.Name)
 
 	executeInput := &cloudformation.ExecuteChangeSetInput{
 		ChangeSetName: aws.String(changeSetInfo.ChangeSetID),
@@ -187,15 +187,15 @@ func (d *AWSDeployer) deployWithChangeSet(ctx context.Context, resolvedStack *mo
 		)
 	}
 
-	err = cfnOps.WaitForStackOperation(ctx, resolvedStack.Name, eventCallback)
+	err = cfnOps.WaitForStackOperation(ctx, stack.Name, eventCallback)
 	if err != nil {
 		return fmt.Errorf("stack deployment failed: %w", err)
 	}
 
 	// Clean up changeset after successful deployment
 	_ = changeSetMgr.DeleteChangeSet(ctx, changeSetInfo.ChangeSetID)
 
-	fmt.Printf("Stack %s update completed successfully\n", resolvedStack.Name)
+	fmt.Printf("Stack %s update completed successfully\n", stack.Name)
 	return nil
 }