Refactor terraform CLI tests with mock component

tests/cli_terraform_test.go

@@ -25,6 +25,8 @@ func TestCLITerraformClean(t *testing.T) {
 		t.Fatalf("Failed to apply updated PATH: %v", err)
 	}
 	fmt.Printf("Updated PATH: %s\n", pathManager.GetPath())
+
+	// Setup cleanup function to run after test completion
 	defer func() {
 		// Change back to the original working directory after the test
 		if err := os.Chdir(startingDir); err != nil {
@@ -33,7 +35,7 @@ func TestCLITerraformClean(t *testing.T) {
 	}()
 
 	// Define the work directory and change to it
-	workDir := "../examples/quick-start-simple"
+	workDir := "fixtures/scenarios/mock-terraform"
 	if err := os.Chdir(workDir); err != nil {
 		t.Fatalf("Failed to change directory to %q: %v", workDir, err)
 	}
@@ -44,29 +46,32 @@ func TestCLITerraformClean(t *testing.T) {
 		t.Fatalf("Binary not found: %s. Current PATH: %s", "atmos", pathManager.GetPath())
 	}
 
-	// Force clean everything
-	runTerraformCleanCommand(t, binaryPath, "--force")
-	// Clean everything
-	runTerraformCleanCommand(t, binaryPath)
-	// Clean specific component
-	runTerraformCleanCommand(t, binaryPath, "station")
-	// Clean component with stack
-	runTerraformCleanCommand(t, binaryPath, "station", "-s", "dev")
+	// Clean up any existing Terraform state before starting tests
+	cleanupTerraformState(t)
+
+	// Initialize terraform for both environments
+	runTerraformInit(t, binaryPath, "prod")
+	runTerraformInit(t, binaryPath, "dev")
 
 	// Run terraform apply for prod environment
 	runTerraformApply(t, binaryPath, "prod")
-	verifyStateFilesExist(t, []string{"./components/terraform/weather/terraform.tfstate.d/prod-station"})
+	verifyStateFilesExist(t, []string{
+		"terraform/components/mock/.terraform",
+		"terraform/components/mock/.terraform.lock.hcl",
+	})
 	runCLITerraformCleanComponent(t, binaryPath, "prod")
-	verifyStateFilesDeleted(t, []string{"./components/terraform/weather/terraform.tfstate.d/prod-station"})
+	verifyStateFilesDeleted(t, []string{
+		"terraform/components/mock/.terraform",
+		"terraform/components/mock/.terraform.lock.hcl",
+	})
 
 	// Run terraform apply for dev environment
 	runTerraformApply(t, binaryPath, "dev")
 
 	// Verify if state files exist before cleaning
 	stateFiles := []string{
-		"./components/terraform/weather/.terraform",
-		"./components/terraform/weather/terraform.tfstate.d",
-		"./components/terraform/weather/.terraform.lock.hcl",
+		"terraform/components/mock/.terraform",
+		"terraform/components/mock/.terraform.lock.hcl",
 	}
 	verifyStateFilesExist(t, stateFiles)
 
@@ -75,12 +80,11 @@ func TestCLITerraformClean(t *testing.T) {
 
 	// Verify if state files have been deleted after clean
 	verifyStateFilesDeleted(t, stateFiles)
-
 }
 
 // runTerraformApply runs the terraform apply command for a given environment.
 func runTerraformApply(t *testing.T, binaryPath, environment string) {
-	cmd := exec.Command(binaryPath, "terraform", "apply", "station", "-s", environment)
+	cmd := exec.Command(binaryPath, "terraform", "apply", "mock", "-s", environment)
 	envVars := os.Environ()
 	envVars = append(envVars, "ATMOS_COMPONENTS_TERRAFORM_APPLY_AUTO_APPROVE=true")
 	cmd.Env = envVars
@@ -91,7 +95,7 @@ func runTerraformApply(t *testing.T, binaryPath, environment string) {
 	err := cmd.Run()
 	t.Log(stdout.String())
 	if err != nil {
-		t.Fatalf("Failed to run terraform apply station -s %s: %v", environment, stderr.String())
+		t.Fatalf("Failed to run terraform apply mock -s %s: %v", environment, stderr.String())
 	}
 }
 
@@ -138,7 +142,7 @@ func verifyStateFilesDeleted(t *testing.T, stateFiles []string) {
 }
 
 func runCLITerraformCleanComponent(t *testing.T, binaryPath, environment string) {
-	cmd := exec.Command(binaryPath, "terraform", "clean", "station", "-s", environment, "--force")
+	cmd := exec.Command(binaryPath, "terraform", "clean", "mock", "-s", environment, "--force")
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
@@ -148,6 +152,7 @@ func runCLITerraformCleanComponent(t *testing.T, binaryPath, environment string)
 		t.Fatalf("Failed to run terraform clean: %v", stderr.String())
 	}
 }
+
 func runCLITerraformClean(t *testing.T, binaryPath string) {
 	cmd := exec.Command(binaryPath, "terraform", "clean")
 	var stdout, stderr bytes.Buffer
@@ -158,7 +163,46 @@ func runCLITerraformClean(t *testing.T, binaryPath string) {
 	if err != nil {
 		t.Fatalf("Failed to run terraform clean: %v", stderr.String())
 	}
+}
+
+// runTerraformInit initializes terraform for a given environment
+func runTerraformInit(t *testing.T, binaryPath, environment string) {
+	cmd := exec.Command(binaryPath, "terraform", "init", "mock", "-s", environment)
+
+	// Set environment variables
+	envVars := os.Environ()
+	envVars = append(envVars,
+		"ATMOS_COMPONENTS_TERRAFORM_DEPLOY_RUN_INIT=true",
+		"ATMOS_COMPONENTS_TERRAFORM_INIT_RUN_RECONFIGURE=true",
+		"ATMOS_LOGS_LEVEL=Debug",
+		"ATMOS_LOGS_FILE=/dev/stderr")
+	cmd.Env = envVars
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	// Log the command being executed
+	t.Logf("Running terraform init for environment %s: %s %v", environment, binaryPath, cmd.Args)
+
+	err := cmd.Run()
+	// Always log both stdout and stderr
+	t.Logf("Init command stdout:\n%s", stdout.String())
+	t.Logf("Init command stderr:\n%s", stderr.String())
+
+	if err != nil {
+		t.Fatalf("Failed to run terraform init mock -s %s: %v\nStdout: %s\nStderr: %s",
+			environment, err, stdout.String(), stderr.String())
+	}
 
+	// Verify that terraform was properly initialized
+	terraformDir := filepath.Join("terraform", "components", "mock")
+	if _, err := os.Stat(filepath.Join(terraformDir, ".terraform")); os.IsNotExist(err) {
+		t.Fatalf("Terraform was not properly initialized: .terraform directory not found in %s", terraformDir)
+	}
+	if _, err := os.Stat(filepath.Join(terraformDir, ".terraform.lock.hcl")); os.IsNotExist(err) {
+		t.Fatalf("Terraform was not properly initialized: .terraform.lock.hcl not found in %s", terraformDir)
+	}
 }
 
 func runTerraformCleanCommand(t *testing.T, binaryPath string, args ...string) {
@@ -173,3 +217,33 @@ func runTerraformCleanCommand(t *testing.T, binaryPath string, args ...string) {
 		t.Fatalf("Failed to run terraform clean: %v", stderr.String())
 	}
 }
+
+func cleanupTerraformState(t *testing.T) {
+	t.Helper()
+
+	// Define paths to clean
+	terraformDir := filepath.Join("terraform", "components", "mock")
+	pathsToClean := []string{
+		filepath.Join(terraformDir, ".terraform"),
+		filepath.Join(terraformDir, ".terraform.lock.hcl"),
+		filepath.Join(terraformDir, "terraform.tfstate"),
+		filepath.Join(terraformDir, "terraform.tfstate.backup"),
+		filepath.Join(terraformDir, ".terraform.tfstate.lock.info"),
+		filepath.Join(terraformDir, "terraform.tfstate.d"),
+	}
+
+	// Remove each path
+	for _, path := range pathsToClean {
+		err := os.RemoveAll(path)
+		if err != nil && !os.IsNotExist(err) {
+			t.Fatalf("Failed to clean up Terraform state at %s: %v", path, err)
+		}
+	}
+
+	// Ensure the terraform directory exists
+	if err := os.MkdirAll(terraformDir, 0o755); err != nil {
+		t.Fatalf("Failed to create terraform directory at %s: %v", terraformDir, err)
+	}
+
+	t.Logf("Successfully cleaned up Terraform state in %s", terraformDir)
+}

tests/fixtures/components/terraform/random/backend.tf

@@ -0,0 +1,6 @@
+terraform {
+  # Using local backend for testing
+  backend "local" {
+    path = "terraform.tfstate"
+  }
+}

tests/fixtures/components/terraform/random/main.tf

@@ -0,0 +1,97 @@
+# 🎲 Random Component for Testing
+# This component is designed to be simple, reusable, and perfect for testing Atmos functionality
+
+terraform {
+  required_providers {
+    local = {
+      source  = "hashicorp/local"
+      version = ">= 2.0"
+    }
+  }
+}
+
+# Common variables used across test scenarios
+variable "stage" {
+  type        = string
+  description = "Stage (e.g., dev, staging, prod)"
+}
+
+variable "environment" {
+  type        = string
+  description = "Environment (e.g., ue2, uw2)"
+}
+
+variable "tenant" {
+  type        = string
+  description = "Tenant name"
+}
+
+# Test-specific variables with defaults
+variable "foo" {
+  type        = string
+  default     = "foo"
+  description = "Test variable foo"
+}
+
+variable "bar" {
+  type        = string
+  default     = "bar"
+  description = "Test variable bar"
+}
+
+variable "baz" {
+  type        = string
+  default     = "baz"
+  description = "Test variable baz"
+}
+
+# Simple local file resource for testing
+resource "local_file" "test" {
+  content = jsonencode({
+    metadata = {
+      stage       = var.stage
+      environment = var.environment
+      tenant      = var.tenant
+      timestamp   = timestamp()
+    }
+    config = {
+      foo = var.foo
+      bar = var.bar
+      baz = var.baz
+    }
+  })
+  filename = "${path.module}/test-${var.environment}-${var.stage}.json"
+}
+
+# Outputs for testing
+output "stage" {
+  value = var.stage
+}
+
+output "environment" {
+  value = var.environment
+}
+
+output "tenant" {
+  value = var.tenant
+}
+
+output "foo" {
+  value = var.foo
+}
+
+output "bar" {
+  value = var.bar
+}
+
+output "baz" {
+  value = var.baz
+}
+
+output "file_path" {
+  value = local_file.test.filename
+}
+
+output "file_content" {
+  value = local_file.test.content
+}

tests/fixtures/components/terraform/random/versions.tf

@@ -0,0 +1,10 @@
+terraform {
+  required_version = ">= 1.0.0"
+
+  required_providers {
+    local = {
+      source  = "hashicorp/local"
+      version = ">= 2.0"
+    }
+  }
+}

tests/fixtures/scenarios/mock-terraform/atmos.yaml

@@ -0,0 +1,22 @@
+components:
+  terraform:
+    base_path: "terraform/components"
+    apply:
+      auto_approve: true
+    clean:
+      auto_approve: true
+    deploy_run_init: true
+    init_run_reconfigure: true
+    command: terraform
+
+stacks:
+  base_path: "stacks"
+  included_paths:
+    - "**/*"
+  excluded_paths:
+    - "**/templates/**/*"
+  name_pattern: "{environment}-{component}"
+
+logs:
+  file: "/dev/stderr"
+  level: "Info" 

tests/fixtures/scenarios/mock-terraform/components/terraform/mock/backend.tf

@@ -0,0 +1,5 @@
+terraform {
+  backend "local" {
+    path = "terraform.tfstate"
+  }
+}

tests/fixtures/scenarios/mock-terraform/components/terraform/mock/main.tf

@@ -0,0 +1,63 @@
+variable "stage" {
+  type = string
+}
+
+variable "environment" {
+  type = string
+}
+
+variable "tenant" {
+  type = string
+}
+
+variable "foo" {
+  type = string
+  default = "foo"
+}
+
+variable "bar" {
+  type = string
+  default = "bar"
+}
+
+variable "baz" {
+  type = string
+  default = "baz"
+}
+
+# Mock resource for testing
+resource "local_file" "mock" {
+  content  = jsonencode({
+    foo = var.foo
+    bar = var.bar
+    baz = var.baz
+    stage = var.stage
+    environment = var.environment
+    tenant = var.tenant
+  })
+  filename = "${path.module}/mock.json"
+}
+
+output "foo" {
+  value = var.foo
+}
+
+output "bar" {
+  value = var.bar
+}
+
+output "baz" {
+  value = var.baz
+}
+
+output "stage" {
+  value = var.stage
+}
+
+output "environment" {
+  value = var.environment
+}
+
+output "tenant" {
+  value = var.tenant
+}

tests/fixtures/scenarios/mock-terraform/components/terraform/mock/mock.json

@@ -0,0 +1 @@
+{"bar":"dev-bar","baz":"dev-baz","environment":"dev","foo":"dev-foo","stage":"dev","tenant":"test"}