From 15fbdd58cab291d6c928422c8ee6a4c50234fbd9 Mon Sep 17 00:00:00 2001 From: Ryan VanGundy Date: Mon, 23 Dec 2024 18:45:27 -0500 Subject: [PATCH 1/7] internal => pkg From ff78cdf01d1331c7f4bf4ab13daccf96d7f80c4c Mon Sep 17 00:00:00 2001 From: Ryan VanGundy Date: Mon, 23 Dec 2024 21:16:22 -0500 Subject: [PATCH 2/7] Working gitignore generator --- cmd/init.go | 5 + cmd/init_test.go | 23 +++ cmd/up.go | 5 + cmd/up_test.go | 15 ++ pkg/controller/controller.go | 7 + pkg/controller/controller_test.go | 16 ++ pkg/controller/mock_controller.go | 30 +++- pkg/controller/mock_controller_test.go | 28 ++++ pkg/controller/real_controller.go | 25 ++- pkg/controller/real_controller_test.go | 29 ++++ pkg/generators/generator.go | 9 ++ pkg/generators/generator_test.go | 18 +++ pkg/generators/git_generator.go | 97 ++++++++++++ pkg/generators/git_generator_test.go | 207 +++++++++++++++++++++++++ 14 files changed, 498 insertions(+), 16 deletions(-) create mode 100644 pkg/generators/git_generator.go create mode 100644 pkg/generators/git_generator_test.go diff --git a/cmd/init.go b/cmd/init.go index 741e6ede..8315c6be 100644 --- a/cmd/init.go +++ b/cmd/init.go @@ -88,6 +88,11 @@ var initCmd = &cobra.Command{ return fmt.Errorf("Error saving config file: %w", err) } + // Create project components + if err := controller.CreateProjectComponents(); err != nil { + return fmt.Errorf("Error creating project components: %w", err) + } + // Create service components if err := controller.CreateServiceComponents(); err != nil { return fmt.Errorf("Error creating service components: %w", err) diff --git a/cmd/init_test.go b/cmd/init_test.go index 1420d4df..ea9c8013 100644 --- a/cmd/init_test.go +++ b/cmd/init_test.go @@ -418,6 +418,29 @@ func TestInitCmd(t *testing.T) { } }) + t.Run("ErrorCreatingProjectComponents", func(t *testing.T) { + // Given a mock controller with CreateProjectComponents set to fail + injector := di.NewInjector() + controller := ctrl.NewMockController(injector) + setupSafeInitCmdMocks(controller) + controller.CreateProjectComponentsFunc = func() error { return fmt.Errorf("create project components error") } + + // When the init command is executed + output := captureStderr(func() { + rootCmd.SetArgs([]string{"init", "test-context"}) + err := Execute(controller) + if err == nil { + t.Fatalf("Expected error, got nil") + } + }) + + // Then the output should indicate the error + expectedOutput := "Error creating project components: create project components error" + if !strings.Contains(output, expectedOutput) { + t.Errorf("Expected output to contain %q, got %q", expectedOutput, output) + } + }) + t.Run("ErrorCreatingServiceComponents", func(t *testing.T) { // Given a mock controller with CreateServiceComponents set to fail injector := di.NewInjector() diff --git a/cmd/up.go b/cmd/up.go index 529e822a..4181fc9b 100644 --- a/cmd/up.go +++ b/cmd/up.go @@ -13,6 +13,11 @@ var upCmd = &cobra.Command{ SilenceUsage: true, PreRunE: preRunEInitializeCommonComponents, RunE: func(cmd *cobra.Command, args []string) error { + // Create project components + if err := controller.CreateProjectComponents(); err != nil { + return fmt.Errorf("Error creating project components: %w", err) + } + // Create environment components if err := controller.CreateEnvComponents(); err != nil { return fmt.Errorf("Error creating environment components: %w", err) diff --git a/cmd/up_test.go b/cmd/up_test.go index 562d3aba..2c517f31 100644 --- a/cmd/up_test.go +++ b/cmd/up_test.go @@ -115,6 +115,21 @@ func TestUpCmd(t *testing.T) { } }) + t.Run("ErrorCreatingProjectComponents", func(t *testing.T) { + mocks := setupSafeUpCmdMocks() + mocks.MockController.CreateProjectComponentsFunc = func() error { + return fmt.Errorf("error creating project components") + } + + // Given a mock controller that returns an error when creating project components + rootCmd.SetArgs([]string{"up"}) + err := Execute(mocks.MockController) + // Then the error should contain the expected message + if err == nil || !strings.Contains(err.Error(), "error creating project components") { + t.Fatalf("Expected error containing 'error creating project components', got %v", err) + } + }) + t.Run("ErrorCreatingEnvComponents", func(t *testing.T) { mocks := setupSafeUpCmdMocks() mocks.MockController.CreateEnvComponentsFunc = func() error { diff --git a/pkg/controller/controller.go b/pkg/controller/controller.go index 821e35bc..c87bb72b 100644 --- a/pkg/controller/controller.go +++ b/pkg/controller/controller.go @@ -23,6 +23,7 @@ type Controller interface { Initialize() error InitializeComponents() error CreateCommonComponents() error + CreateProjectComponents() error CreateEnvComponents() error CreateServiceComponents() error CreateVirtualizationComponents() error @@ -164,6 +165,12 @@ func (c *BaseController) CreateCommonComponents() error { return nil } +// CreateProjectComponents creates the project components. +func (c *BaseController) CreateProjectComponents() error { + // no-op + return nil +} + // CreateEnvComponents creates the env components. func (c *BaseController) CreateEnvComponents() error { // no-op diff --git a/pkg/controller/controller_test.go b/pkg/controller/controller_test.go index 40217306..86b2b7ca 100644 --- a/pkg/controller/controller_test.go +++ b/pkg/controller/controller_test.go @@ -410,6 +410,22 @@ func TestController_CreateCommonComponents(t *testing.T) { }) } +func TestController_CreateProjectComponents(t *testing.T) { + t.Run("Success", func(t *testing.T) { + // Given a new controller + mocks := setSafeControllerMocks() + controller := NewController(mocks.Injector) + + // When creating project components + err := controller.CreateProjectComponents() + + // Then there should be no error + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + }) +} + func TestController_CreateEnvComponents(t *testing.T) { t.Run("Success", func(t *testing.T) { // Given a new controller diff --git a/pkg/controller/mock_controller.go b/pkg/controller/mock_controller.go index c3f04fde..12b1911c 100644 --- a/pkg/controller/mock_controller.go +++ b/pkg/controller/mock_controller.go @@ -23,6 +23,7 @@ type MockController struct { InitializeFunc func() error InitializeComponentsFunc func() error CreateCommonComponentsFunc func() error + CreateProjectComponentsFunc func() error CreateEnvComponentsFunc func() error CreateServiceComponentsFunc func() error CreateVirtualizationComponentsFunc func() error @@ -109,6 +110,27 @@ func (m *MockController) CreateCommonComponents() error { return nil } +// CreateProjectComponents calls the mock CreateProjectComponentsFunc if set, otherwise creates mock components +func (m *MockController) CreateProjectComponents() error { + if m.CreateProjectComponentsFunc != nil { + return m.CreateProjectComponentsFunc() + } + + // Create a new mock blueprint handler + blueprintHandler := blueprint.NewMockBlueprintHandler(m.injector) + m.injector.Register("blueprintHandler", blueprintHandler) + + // Create a new git generator + gitGenerator := generators.NewMockGenerator() + m.injector.Register("gitGenerator", gitGenerator) + + // Create a new mock terraform generator + terraformGenerator := generators.NewMockGenerator() + m.injector.Register("terraformGenerator", terraformGenerator) + + return nil +} + // CreateEnvComponents calls the mock CreateEnvComponentsFunc if set, otherwise creates mock components func (m *MockController) CreateEnvComponents() error { if m.CreateEnvComponentsFunc != nil { @@ -267,14 +289,6 @@ func (c *MockController) CreateStackComponents() error { return c.CreateStackComponentsFunc() } - // Create a new blueprint handler - blueprintHandler := blueprint.NewMockBlueprintHandler(c.injector) - c.injector.Register("blueprintHandler", blueprintHandler) - - // Create a new terraform generator - terraformGenerator := generators.NewMockGenerator() - c.injector.Register("terraformGenerator", terraformGenerator) - // Create a new stack stackInstance := stack.NewMockStack(c.injector) c.injector.Register("stack", stackInstance) diff --git a/pkg/controller/mock_controller_test.go b/pkg/controller/mock_controller_test.go index c1cd4bc6..a757f4b2 100644 --- a/pkg/controller/mock_controller_test.go +++ b/pkg/controller/mock_controller_test.go @@ -99,6 +99,34 @@ func TestMockController_CreateCommonComponents(t *testing.T) { }) } +func TestMockController_CreateProjectComponents(t *testing.T) { + t.Run("Success", func(t *testing.T) { + // Given a new injector and mock controller + injector := di.NewInjector() + mockCtrl := NewMockController(injector) + // And the CreateProjectComponentsFunc is set to return nil + mockCtrl.CreateProjectComponentsFunc = func() error { + return nil + } + // When CreateProjectComponents is called + if err := mockCtrl.CreateProjectComponents(); err != nil { + // Then no error should be returned + t.Fatalf("expected no error, got %v", err) + } + }) + + t.Run("DefaultCreateProjectComponents", func(t *testing.T) { + // Given a new injector and a mock controller + injector := di.NewInjector() + mockCtrl := NewMockController(injector) + // When CreateProjectComponents is invoked without setting CreateProjectComponentsFunc + if err := mockCtrl.CreateProjectComponents(); err != nil { + // Then no error should be returned + t.Fatalf("expected no error, got %v", err) + } + }) +} + func TestMockController_CreateEnvComponents(t *testing.T) { t.Run("CreateEnvComponents", func(t *testing.T) { // Given a new injector and mock controller diff --git a/pkg/controller/real_controller.go b/pkg/controller/real_controller.go index 6cdc9712..05a8f0cf 100644 --- a/pkg/controller/real_controller.go +++ b/pkg/controller/real_controller.go @@ -65,6 +65,23 @@ func (c *RealController) CreateCommonComponents() error { return nil } +// CreateProjectComponents creates components required for project initialization +func (c *RealController) CreateProjectComponents() error { + // Create a new git generator + gitGenerator := generators.NewGitGenerator(c.injector) + c.injector.Register("gitGenerator", gitGenerator) + + // Create a new blueprint handler + blueprintHandler := blueprint.NewBlueprintHandler(c.injector) + c.injector.Register("blueprintHandler", blueprintHandler) + + // Create a new terraform generator + terraformGenerator := generators.NewTerraformGenerator(c.injector) + c.injector.Register("terraformGenerator", terraformGenerator) + + return nil +} + // CreateEnvComponents creates components required for env and exec commands func (c *RealController) CreateEnvComponents() error { // Create aws env printer @@ -213,14 +230,6 @@ func (c *RealController) CreateVirtualizationComponents() error { // CreateStackComponents creates stack components func (c *RealController) CreateStackComponents() error { - // Create a new blueprint handler - blueprintHandler := blueprint.NewBlueprintHandler(c.injector) - c.injector.Register("blueprintHandler", blueprintHandler) - - // Create a new terraform generator - terraformGenerator := generators.NewTerraformGenerator(c.injector) - c.injector.Register("terraformGenerator", terraformGenerator) - // Create a new stack stackInstance := stack.NewWindsorStack(c.injector) c.injector.Register("stack", stackInstance) diff --git a/pkg/controller/real_controller_test.go b/pkg/controller/real_controller_test.go index 00a59cef..b43f1a8d 100644 --- a/pkg/controller/real_controller_test.go +++ b/pkg/controller/real_controller_test.go @@ -54,6 +54,35 @@ func TestRealController_CreateCommonComponents(t *testing.T) { }) } +func TestRealController_CreateProjectComponents(t *testing.T) { + t.Run("Success", func(t *testing.T) { + // Given a new injector and a new real controller + injector := di.NewInjector() + controller := NewRealController(injector) + + // When creating project components + err := controller.CreateProjectComponents() + + // Then there should be no error + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + // And the components should be registered in the injector + if injector.Resolve("gitGenerator") == nil { + t.Fatalf("expected gitGenerator to be registered, got error") + } + if injector.Resolve("blueprintHandler") == nil { + t.Fatalf("expected blueprintHandler to be registered, got error") + } + if injector.Resolve("terraformGenerator") == nil { + t.Fatalf("expected terraformGenerator to be registered, got error") + } + + t.Logf("Success: project components created and registered") + }) +} + func TestRealController_CreateEnvComponents(t *testing.T) { t.Run("Success", func(t *testing.T) { // Given a new injector and a new real controller diff --git a/pkg/generators/generator.go b/pkg/generators/generator.go index 18450f2e..34fb4122 100644 --- a/pkg/generators/generator.go +++ b/pkg/generators/generator.go @@ -6,6 +6,7 @@ import ( "github.com/windsorcli/cli/pkg/blueprint" "github.com/windsorcli/cli/pkg/context" "github.com/windsorcli/cli/pkg/di" + "github.com/windsorcli/cli/pkg/shell" ) // Generator is the interface that wraps the Write method @@ -19,6 +20,7 @@ type BaseGenerator struct { injector di.Injector contextHandler context.ContextHandler blueprintHandler blueprint.BlueprintHandler + shell shell.Shell } // NewGenerator creates a new BaseGenerator @@ -44,6 +46,13 @@ func (g *BaseGenerator) Initialize() error { } g.blueprintHandler = blueprintHandler + // Resolve the shell instance + shellInstance, ok := g.injector.Resolve("shell").(shell.Shell) + if !ok { + return fmt.Errorf("failed to resolve shell instance") + } + g.shell = shellInstance + return nil } diff --git a/pkg/generators/generator_test.go b/pkg/generators/generator_test.go index 84203da7..c770f6e0 100644 --- a/pkg/generators/generator_test.go +++ b/pkg/generators/generator_test.go @@ -152,6 +152,24 @@ func TestGenerator_Initialize(t *testing.T) { t.Errorf("Expected Initialize to fail, but it succeeded") } }) + + t.Run("ErrorResolvingShell", func(t *testing.T) { + mocks := setupSafeMocks() + + // Given a mock injector with a nil shell + mocks.Injector.Register("shell", nil) + + // When a new BaseGenerator is created + generator := NewGenerator(mocks.Injector) + + // And the BaseGenerator is initialized + err := generator.Initialize() + + // Then the initialization should fail + if err == nil { + t.Errorf("Expected Initialize to fail, but it succeeded") + } + }) } func TestGenerator_Write(t *testing.T) { diff --git a/pkg/generators/git_generator.go b/pkg/generators/git_generator.go new file mode 100644 index 00000000..6ed16772 --- /dev/null +++ b/pkg/generators/git_generator.go @@ -0,0 +1,97 @@ +package generators + +import ( + "fmt" + "os" + "path/filepath" + "strings" + + "github.com/windsorcli/cli/pkg/di" +) + +// GitGenerator is a generator that writes Git configuration files +type GitGenerator struct { + BaseGenerator +} + +// NewGitGenerator creates a new GitGenerator +func NewGitGenerator(injector di.Injector) *GitGenerator { + return &GitGenerator{ + BaseGenerator: BaseGenerator{injector: injector}, + } +} + +// Write generates the Git configuration files +func (g *GitGenerator) Write() error { + // Get the project root + projectRoot, err := g.shell.GetProjectRoot() + if err != nil { + return fmt.Errorf("failed to get project root: %w", err) + } + + // Define the path to the .gitignore file + gitignorePath := filepath.Join(projectRoot, ".gitignore") + + // Read the existing .gitignore file, or create it if it doesn't exist + content, err := osReadFile(gitignorePath) + if err != nil && !os.IsNotExist(err) { + return fmt.Errorf("failed to read .gitignore: %w", err) + } + + // If the file does not exist, initialize content as an empty byte slice + if os.IsNotExist(err) { + content = []byte{} + } + + // Convert the content to a set for idempotency + existingLines := make(map[string]struct{}) + var unmanagedLines []string + lines := strings.Split(string(content), "\n") + for i, line := range lines { + existingLines[line] = struct{}{} + if i == len(lines)-1 && line == "" { + continue // Skip appending the last line if it's empty + } + unmanagedLines = append(unmanagedLines, line) + } + + // Define the lines to add + linesToAdd := []string{ + "# managed by windsor cli", + ".volumes/", + ".tf_modules/", + "terraform/**/backend_override.tf", + "contexts/**/.terraform/", + "contexts/**/.kube/", + "contexts/**/.talos/", + "contexts/**/.aws/", + } + + // Add only the lines that are not already present + for _, line := range linesToAdd { + if _, exists := existingLines[line]; !exists { + if line == "# managed by windsor cli" { + unmanagedLines = append(unmanagedLines, "") + } + unmanagedLines = append(unmanagedLines, line) + } + } + + // Join all lines into the final content + finalContent := strings.Join(unmanagedLines, "\n") + + // Ensure the final content ends with a single newline + if !strings.HasSuffix(finalContent, "\n") { + finalContent += "\n" + } + + // Write the final content to the .gitignore file + if err := osWriteFile(gitignorePath, []byte(finalContent), 0644); err != nil { + return fmt.Errorf("failed to write to .gitignore: %w", err) + } + + return nil +} + +// Ensure GitGenerator implements Generator +var _ Generator = (*GitGenerator)(nil) diff --git a/pkg/generators/git_generator_test.go b/pkg/generators/git_generator_test.go new file mode 100644 index 00000000..c5fb5ce1 --- /dev/null +++ b/pkg/generators/git_generator_test.go @@ -0,0 +1,207 @@ +package generators + +import ( + "fmt" + "io/fs" + "os" + "path/filepath" + "testing" +) + +const ( + gitGenTestMockGitignorePath = "/mock/project/root/.gitignore" + gitGenTestExistingContent = "existing content\n" + gitGenTestExpectedContent = "existing content\n\n# managed by windsor cli\n.volumes/\n.tf_modules/\nterraform/**/backend_override.tf\ncontexts/**/.terraform/\ncontexts/**/.kube/\ncontexts/**/.talos/\ncontexts/**/.aws/\n" + gitGenTestExpectedPerm = fs.FileMode(0644) +) + +func TestGitGenerator_NewGitGenerator(t *testing.T) { + t.Run("NewGitGenerator", func(t *testing.T) { + // Use setupSafeMocks to create mock components + mocks := setupSafeMocks() + + // Create a new GitGenerator using the mock injector + gitGenerator := NewGitGenerator(mocks.Injector) + + // Check if the GitGenerator is not nil + if gitGenerator == nil { + t.Fatalf("expected GitGenerator to be created, got nil") + } + + // Check if the GitGenerator has the correct injector + if gitGenerator.injector != mocks.Injector { + t.Errorf("expected GitGenerator to have the correct injector") + } + }) +} + +func TestGitGenerator_Write(t *testing.T) { + t.Run("Success", func(t *testing.T) { + mocks := setupSafeMocks() + + // Mock osReadFile to return predefined content or an empty file if not exists + originalOsReadFile := osReadFile + defer func() { osReadFile = originalOsReadFile }() + osReadFile = func(filename string) ([]byte, error) { + if filepath.ToSlash(filename) == gitGenTestMockGitignorePath { + return []byte(gitGenTestExistingContent), nil + } + return []byte{}, nil // Return empty content instead of an error + } + + // Capture the call to osWriteFile + var capturedFilename string + var capturedContent []byte + var capturedPerm fs.FileMode + originalOsWriteFile := osWriteFile + defer func() { osWriteFile = originalOsWriteFile }() + osWriteFile = func(filename string, content []byte, perm fs.FileMode) error { + capturedFilename = filename + capturedContent = content + capturedPerm = perm + return nil + } + + gitGenerator := NewGitGenerator(mocks.Injector) + + // Initialize the GitGenerator + if err := gitGenerator.Initialize(); err != nil { + t.Fatalf("failed to initialize GitGenerator: %v", err) + } + + // Call the Write method + err := gitGenerator.Write() + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + // Check if osWriteFile was called with the correct parameters + if filepath.ToSlash(capturedFilename) != gitGenTestMockGitignorePath { + t.Errorf("expected filename %s, got %s", gitGenTestMockGitignorePath, capturedFilename) + } + + if string(capturedContent) != gitGenTestExpectedContent { + t.Errorf("expected content %s, got %s", gitGenTestExpectedContent, string(capturedContent)) + } + + if capturedPerm != gitGenTestExpectedPerm { + t.Errorf("expected permission %v, got %v", gitGenTestExpectedPerm, capturedPerm) + } + }) + + t.Run("ErrorGettingProjectRoot", func(t *testing.T) { + mocks := setupSafeMocks() + + // Mock the GetProjectRootFunc to return an error + mocks.MockShell.GetProjectRootFunc = func() (string, error) { + return "", fmt.Errorf("mock error getting project root") + } + + gitGenerator := NewGitGenerator(mocks.Injector) + + // Initialize the GitGenerator + if err := gitGenerator.Initialize(); err != nil { + t.Fatalf("failed to initialize GitGenerator: %v", err) + } + + // Call the Write method and expect an error + err := gitGenerator.Write() + if err == nil { + t.Fatalf("expected an error, got nil") + } + + expectedError := "failed to get project root: mock error getting project root" + if err.Error() != expectedError { + t.Errorf("expected error %s, got %s", expectedError, err.Error()) + } + }) + + t.Run("ErrorReadingGitignore", func(t *testing.T) { + mocks := setupSafeMocks() + + // Mock the osReadFile function to return an error + originalOsReadFile := osReadFile + defer func() { osReadFile = originalOsReadFile }() + osReadFile = func(_ string) ([]byte, error) { + return nil, fmt.Errorf("mock error reading .gitignore") + } + + gitGenerator := NewGitGenerator(mocks.Injector) + + // Initialize the GitGenerator + if err := gitGenerator.Initialize(); err != nil { + t.Fatalf("failed to initialize GitGenerator: %v", err) + } + + // Call the Write method and expect an error + err := gitGenerator.Write() + if err == nil { + t.Fatalf("expected an error, got nil") + } + + expectedError := "failed to read .gitignore: mock error reading .gitignore" + if err.Error() != expectedError { + t.Errorf("expected error %s, got %s", expectedError, err.Error()) + } + }) + + t.Run("GitignoreDoesNotExist", func(t *testing.T) { + mocks := setupSafeMocks() + + gitGenerator := NewGitGenerator(mocks.Injector) + + // Initialize the GitGenerator + if err := gitGenerator.Initialize(); err != nil { + t.Fatalf("failed to initialize GitGenerator: %v", err) + } + + // Mock the osReadFile function to simulate .gitignore does not exist + originalOsReadFile := osReadFile + defer func() { osReadFile = originalOsReadFile }() + osReadFile = func(_ string) ([]byte, error) { + return nil, os.ErrNotExist + } + + // Mock the osWriteFile function to simulate successful file creation + originalOsWriteFile := osWriteFile + defer func() { osWriteFile = originalOsWriteFile }() + osWriteFile = func(_ string, _ []byte, _ fs.FileMode) error { + return nil + } + + // Call the Write method and expect no error + err := gitGenerator.Write() + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + }) + + t.Run("ErrorWritingGitignore", func(t *testing.T) { + mocks := setupSafeMocks() + + // Mock the osWriteFile function to simulate an error during file writing + originalOsWriteFile := osWriteFile + defer func() { osWriteFile = originalOsWriteFile }() + osWriteFile = func(_ string, _ []byte, _ fs.FileMode) error { + return fmt.Errorf("mock error writing .gitignore") + } + + gitGenerator := NewGitGenerator(mocks.Injector) + + // Initialize the GitGenerator + if err := gitGenerator.Initialize(); err != nil { + t.Fatalf("failed to initialize GitGenerator: %v", err) + } + + // Call the Write method and expect an error + err := gitGenerator.Write() + if err == nil { + t.Fatalf("expected an error, got nil") + } + + expectedError := "failed to write to .gitignore: mock error writing .gitignore" + if err.Error() != expectedError { + t.Errorf("expected error %s, got %s", expectedError, err.Error()) + } + }) +} From c6e977f08c8c0e5586391e086192a22db14d7117 Mon Sep 17 00:00:00 2001 From: Ryan VanGundy Date: Mon, 23 Dec 2024 22:59:36 -0500 Subject: [PATCH 3/7] fix gosec vuln From 5478be009ad0d758bbd7d18d106f332979084eb9 Mon Sep 17 00:00:00 2001 From: Ryan VanGundy Date: Mon, 23 Dec 2024 23:16:25 -0500 Subject: [PATCH 4/7] Fix default local blueprint --- pkg/blueprint/blueprint_handler.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/blueprint/blueprint_handler.go b/pkg/blueprint/blueprint_handler.go index f14e3b4a..7f191930 100644 --- a/pkg/blueprint/blueprint_handler.go +++ b/pkg/blueprint/blueprint_handler.go @@ -136,7 +136,7 @@ func (b *BaseBlueprintHandler) LoadConfig(path ...string) error { } else { // Check context and load appropriate blueprint context := b.contextHandler.GetContext() - if strings.HasPrefix(context, "local") && len(yamlData) == 0 { + if strings.HasPrefix(context, "local") { // Load local.jsonnet as blueprint evaluatedJsonnet, err := generateBlueprintFromJsonnet(b.configHandler.GetConfig(), localJsonnetTemplate) if err != nil { From 5ac094b19944061b29a19f9b6b66068a4e148c65 Mon Sep 17 00:00:00 2001 From: Ryan VanGundy Date: Mon, 23 Dec 2024 23:20:32 -0500 Subject: [PATCH 5/7] Normalize line endings --- pkg/generators/git_generator_test.go | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/pkg/generators/git_generator_test.go b/pkg/generators/git_generator_test.go index c5fb5ce1..ee651872 100644 --- a/pkg/generators/git_generator_test.go +++ b/pkg/generators/git_generator_test.go @@ -5,6 +5,7 @@ import ( "io/fs" "os" "path/filepath" + "strings" "testing" ) @@ -75,12 +76,17 @@ func TestGitGenerator_Write(t *testing.T) { t.Fatalf("expected no error, got %v", err) } + // Normalize line endings for cross-platform compatibility + normalizeLineEndings := func(content string) string { + return strings.ReplaceAll(content, "\r\n", "\n") + } + // Check if osWriteFile was called with the correct parameters if filepath.ToSlash(capturedFilename) != gitGenTestMockGitignorePath { t.Errorf("expected filename %s, got %s", gitGenTestMockGitignorePath, capturedFilename) } - if string(capturedContent) != gitGenTestExpectedContent { + if normalizeLineEndings(string(capturedContent)) != normalizeLineEndings(gitGenTestExpectedContent) { t.Errorf("expected content %s, got %s", gitGenTestExpectedContent, string(capturedContent)) } From 3926b7346edb9a0d782581fd6ea720998a0bd200 Mon Sep 17 00:00:00 2001 From: Ryan VanGundy Date: Mon, 23 Dec 2024 23:25:23 -0500 Subject: [PATCH 6/7] Fix test --- pkg/generators/git_generator.go | 1 + 1 file changed, 1 insertion(+) diff --git a/pkg/generators/git_generator.go b/pkg/generators/git_generator.go index 6ed16772..b5aa5082 100644 --- a/pkg/generators/git_generator.go +++ b/pkg/generators/git_generator.go @@ -62,6 +62,7 @@ func (g *GitGenerator) Write() error { ".tf_modules/", "terraform/**/backend_override.tf", "contexts/**/.terraform/", + "contexts/**/.tfstate/", "contexts/**/.kube/", "contexts/**/.talos/", "contexts/**/.aws/", From 19934702ce871ba8de53bcddb9da9be65cb11929 Mon Sep 17 00:00:00 2001 From: Ryan VanGundy Date: Mon, 23 Dec 2024 23:30:39 -0500 Subject: [PATCH 7/7] Make multi-line --- pkg/generators/git_generator_test.go | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/pkg/generators/git_generator_test.go b/pkg/generators/git_generator_test.go index ee651872..479fcf51 100644 --- a/pkg/generators/git_generator_test.go +++ b/pkg/generators/git_generator_test.go @@ -12,8 +12,19 @@ import ( const ( gitGenTestMockGitignorePath = "/mock/project/root/.gitignore" gitGenTestExistingContent = "existing content\n" - gitGenTestExpectedContent = "existing content\n\n# managed by windsor cli\n.volumes/\n.tf_modules/\nterraform/**/backend_override.tf\ncontexts/**/.terraform/\ncontexts/**/.kube/\ncontexts/**/.talos/\ncontexts/**/.aws/\n" - gitGenTestExpectedPerm = fs.FileMode(0644) + gitGenTestExpectedContent = `existing content + +# managed by windsor cli +.volumes/ +.tf_modules/ +terraform/**/backend_override.tf +contexts/**/.terraform/ +contexts/**/.tfstate/ +contexts/**/.kube/ +contexts/**/.talos/ +contexts/**/.aws/ +` + gitGenTestExpectedPerm = fs.FileMode(0644) ) func TestGitGenerator_NewGitGenerator(t *testing.T) {