Merge branch 'main' into main

pkg/docker/docker_test.go

@@ -0,0 +1,144 @@
+package docker
+
+import (
+ "testing"
+)
+
+func TestIsValidEnvVarKey(t *testing.T) {
+ testCases := []struct {
+ name string
+ key string
+ expected bool
+ }{
+ {
+ name: "Empty string",
+ key: "",
+ expected: false,
+ },
+ {
+ name: "Single letter",
+ key: "A",
+ expected: true,
+ },
+ {
+ name: "Single underscore",
+ key: "_",
+ expected: true,
+ },
+ {
+ name: "Letter and digit",
+ key: "MY_VAR1",
+ expected: true,
+ },
+ {
+ name: "Letter, digit, and underscore",
+ key: "MY_VAR_123",
+ expected: true,
+ },
+ {
+ name: "Starting with digit",
+ key: "123_MY_VAR",
+ expected: false,
+ },
+ {
+ name: "Invalid character",
+ key: "MY_VAR@",
+ expected: false,
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ result := isValidEnvVarKey(tc.key)
+ if result != tc.expected {
+ t.Errorf("Expected %v for key %q, but got %v", tc.expected, tc.key, result)
+ }
+ })
+ }
+}
+
+func TestIsLetter(t *testing.T) {
+ testCases := []struct {
+ name string
+ r rune
+ expected bool
+ }{
+ {
+ name: "Uppercase letter",
+ r: 'A',
+ expected: true,
+ },
+ {
+ name: "Lowercase letter",
+ r: 'a',
+ expected: true,
+ },
+ {
+ name: "Underscore",
+ r: '_',
+ expected: true,
+ },
+ {
+ name: "Digit",
+ r: '1',
+ expected: false,
+ },
+ {
+ name: "Special character",
+ r: '@',
+ expected: false,
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ result := isLetter(tc.r)
+ if result != tc.expected {
+ t.Errorf("Expected %v for rune %q, but got %v", tc.expected, string(tc.r), result)
+ }
+ })
+ }
+}
+
+func TestIsLetterOrDigitOrUnderscore(t *testing.T) {
+ testCases := []struct {
+ name string
+ r rune
+ expected bool
+ }{
+ {
+ name: "Uppercase letter",
+ r: 'A',
+ expected: true,
+ },
+ {
+ name: "Lowercase letter",
+ r: 'a',
+ expected: true,
+ },
+ {
+ name: "Underscore",
+ r: '_',
+ expected: true,
+ },
+ {
+ name: "Digit",
+ r: '1',
+ expected: true,
+ },
+ {
+ name: "Special character",
+ r: '@',
+ expected: false,
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ result := isLetterOrDigitOrUnderscore(tc.r)
+ if result != tc.expected {
+ t.Errorf("Expected %v for rune %q, but got %v", tc.expected, string(tc.r), result)
+ }
+ })
+ }
+}

pkg/generate/generate_enigma_test.go

@@ -0,0 +1,63 @@
+package generate
+
+import (
+ "bufio"
+ "os"
+ "testing"
+)
+
+func TestGenerateEnigmaFile(t *testing.T) {
+ // Create a temporary file for testing
+ tempFile, err := os.CreateTemp("", "enigma_test_*.env")
+ if err != nil {
+ t.Fatalf("Failed to create temporary file: %v", err)
+ }
+ defer os.Remove(tempFile.Name())
+ tempFile.Close()
+
+ // Test case for DOCKER environment type
+ t.Run("DOCKER environment", func(t *testing.T) {
+ err := GenerateEnigmaFile(tempFile.Name(), DOCKER)
+ if err != nil {
+ t.Fatalf("GenerateEnigmaFile failed: %v", err)
+ }
+
+ // Read the content of the generated file
+ file, err := os.Open(tempFile.Name())
+ if err != nil {
+ t.Fatalf("Failed to open generated file: %v", err)
+ }
+ defer file.Close()
+
+ scanner := bufio.NewScanner(file)
+ lineCount := 0
+ for scanner.Scan() {
+ line := scanner.Text()
+ if lineCount >= len(DOCKER_ENV_VARIABLES) {
+ t.Errorf("Too many lines in the generated file")
+ break
+ }
+ expectedLine := DOCKER_ENV_VARIABLES[lineCount]
+ if line != expectedLine {
+ t.Errorf("Line %d: expected %q, got %q", lineCount+1, expectedLine, line)
+ }
+ lineCount++
+ }
+
+ if err := scanner.Err(); err != nil {
+ t.Fatalf("Error reading generated file: %v", err)
+ }
+
+ if lineCount != len(DOCKER_ENV_VARIABLES) {
+ t.Errorf("Expected %d lines, got %d", len(DOCKER_ENV_VARIABLES), lineCount)
+ }
+ })
+
+ // Test case for invalid file path
+ t.Run("Invalid file path", func(t *testing.T) {
+ err := GenerateEnigmaFile("/invalid/path/file.env", DOCKER)
+ if err == nil {
+ t.Error("Expected an error for invalid file path, but got nil")
+ }
+ })
+}