Merge pull request #68 from codacy/init-behaviour-PLUTO-1384

machadoit · web-flow · commit ce36811619fc · 2025-04-10T13:29:33.000+02:00
Init behaviour PLUTO-1384
diff --git a/.gitignore b/.gitignore
@@ -25,4 +25,5 @@ go.work.sum
 .vscode/
 
 # Codacy CLI 
-cli-v2
+cli-v2
+codacy-cli
diff --git a/cmd/init.go b/cmd/init.go
@@ -14,6 +14,7 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"github.com/spf13/cobra"
@@ -130,35 +131,83 @@ func createConfigurationFiles(tools []tools.Tool, cliLocalMode bool) error {
 }
 
 func configFileTemplate(tools []tools.Tool) string {
+	// Maps to track which tools are enabled
+	toolsMap := make(map[string]bool)
+	toolVersions := make(map[string]string)
+
+	// Track needed runtimes
+	needsNode := false
+	needsPython := false
 
 	// Default versions
-	eslintVersion := "9.3.0"
-	trivyVersion := "0.59.1" // Latest stable version
-	pylintVersion := "3.3.6"
-	pmdVersion := "6.55.0"
+	defaultVersions := map[string]string{
+		ESLint: "9.3.0",
+		Trivy:  "0.59.1",
+		PyLint: "3.3.6",
+		PMD:    "6.55.0",
+	}
 
+	// Build map of enabled tools with their versions
 	for _, tool := range tools {
-		switch tool.Uuid {
-		case ESLint:
-			eslintVersion = tool.Version
-		case Trivy:
-			trivyVersion = tool.Version
-		case PyLint:
-			pylintVersion = tool.Version
-		case PMD:
-			pmdVersion = tool.Version
+		toolsMap[tool.Uuid] = true
+		if tool.Version != "" {
+			toolVersions[tool.Uuid] = tool.Version
+		} else {
+			toolVersions[tool.Uuid] = defaultVersions[tool.Uuid]
+		}
+
+		// Check if tool needs a runtime
+		if tool.Uuid == ESLint {
+			needsNode = true
+		} else if tool.Uuid == PyLint {
+			needsPython = true
+		}
+	}
+
+	// Start building the YAML content
+	var sb strings.Builder
+	sb.WriteString("runtimes:\n")
+
+	// Only include runtimes needed by the enabled tools
+	if len(tools) > 0 {
+		if needsNode {
+			sb.WriteString("    - node@22.2.0\n")
+		}
+		if needsPython {
+			sb.WriteString("    - python@3.11.11\n")
+		}
+	} else {
+		// In local mode with no tools specified, include all runtimes
+		sb.WriteString("    - node@22.2.0\n")
+		sb.WriteString("    - python@3.11.11\n")
+	}
+
+	sb.WriteString("tools:\n")
+
+	// If we have tools from the API (enabled tools), use only those
+	if len(tools) > 0 {
+		// Add only the tools that are in the API response (enabled tools)
+		uuidToName := map[string]string{
+			ESLint: "eslint",
+			Trivy:  "trivy",
+			PyLint: "pylint",
+			PMD:    "pmd",
+		}
+
+		for uuid, name := range uuidToName {
+			if toolsMap[uuid] {
+				sb.WriteString(fmt.Sprintf("    - %s@%s\n", name, toolVersions[uuid]))
+			}
 		}
+	} else {
+		// If no tools were specified (local mode), include all defaults
+		sb.WriteString(fmt.Sprintf("    - eslint@%s\n", defaultVersions[ESLint]))
+		sb.WriteString(fmt.Sprintf("    - trivy@%s\n", defaultVersions[Trivy]))
+		sb.WriteString(fmt.Sprintf("    - pylint@%s\n", defaultVersions[PyLint]))
+		sb.WriteString(fmt.Sprintf("    - pmd@%s\n", defaultVersions[PMD]))
 	}
 
-	return fmt.Sprintf(`runtimes:
-    - node@22.2.0
-    - python@3.11.11
-tools:
-    - eslint@%s
-    - trivy@%s
-    - pylint@%s
-    - pmd@%s
-`, eslintVersion, trivyVersion, pylintVersion, pmdVersion)
+	return sb.String()
 }
 
 func cliConfigFileTemplate(cliLocalMode bool) string {
@@ -183,6 +232,11 @@ func buildRepositoryConfigurationFiles(token string) error {
 		return fmt.Errorf("failed to create tools-configs directory: %w", err)
 	}
 
+	// Clear any previous configuration files
+	if err := cleanConfigDirectory(toolsConfigDir); err != nil {
+		return fmt.Errorf("failed to clean configuration directory: %w", err)
+	}
+
 	client := &http.Client{
 		Timeout: 10 * time.Second,
 	}
@@ -192,12 +246,17 @@ func buildRepositoryConfigurationFiles(token string) error {
 		return err
 	}
 
-	err = createConfigurationFiles(apiTools, true)
+	// Filter out any tools that use configuration file
+	configuredToolsWithUI := tools.FilterToolsByConfigUsage(apiTools)
+
+	// Create main config files with all enabled API tools
+	err = createConfigurationFiles(apiTools, false)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	for _, tool := range apiTools {
+	// Only generate config files for tools not using their own config file
+	for _, tool := range configuredToolsWithUI {
 		url := fmt.Sprintf("%s/api/v3/analysis/organizations/%s/%s/repositories/%s/tools/%s/patterns?enabled=true",
 			CodacyApiBase,
 			initFlags.provider,
@@ -375,6 +434,33 @@ func createDefaultEslintConfigFile(toolsConfigDir string) error {
 	return os.WriteFile(filepath.Join(toolsConfigDir, "eslint.config.mjs"), []byte(content), utils.DefaultFilePerms)
 }
 
+// cleanConfigDirectory removes all previous configuration files in the tools-configs directory
+func cleanConfigDirectory(toolsConfigDir string) error {
+	// Check if directory exists
+	if _, err := os.Stat(toolsConfigDir); os.IsNotExist(err) {
+		return nil // Directory doesn't exist, nothing to clean
+	}
+
+	// Read directory contents
+	entries, err := os.ReadDir(toolsConfigDir)
+	if err != nil {
+		return fmt.Errorf("failed to read config directory: %w", err)
+	}
+
+	// Remove all files
+	for _, entry := range entries {
+		if !entry.IsDir() { // Only remove files, not subdirectories
+			filePath := filepath.Join(toolsConfigDir, entry.Name())
+			if err := os.Remove(filePath); err != nil {
+				return fmt.Errorf("failed to remove file %s: %w", filePath, err)
+			}
+		}
+	}
+
+	fmt.Println("Cleaned previous configuration files")
+	return nil
+}
+
 const (
 	ESLint string = "f8b29663-2cb2-498d-b923-a10c6a8c05cd"
 	Trivy  string = "2fd7fbe0-33f9-4ab3-ab73-e9b62404e2cb"
diff --git a/cmd/init_test.go b/cmd/init_test.go
@@ -0,0 +1,181 @@
+package cmd
+
+import (
+	"codacy/cli-v2/tools"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConfigFileTemplate(t *testing.T) {
+	tests := []struct {
+		name        string
+		tools       []tools.Tool
+		expected    []string
+		notExpected []string
+	}{
+		{
+			name:  "empty tools list uses defaults",
+			tools: []tools.Tool{},
+			expected: []string{
+				"node@22.2.0",
+				"python@3.11.11",
+				"eslint@9.3.0",
+				"trivy@0.59.1",
+				"pylint@3.3.6",
+				"pmd@6.55.0",
+			},
+			notExpected: []string{},
+		},
+		{
+			name: "only eslint enabled",
+			tools: []tools.Tool{
+				{
+					Uuid:    ESLint,
+					Name:    "eslint",
+					Version: "9.4.0",
+				},
+			},
+			expected: []string{
+				"node@22.2.0",
+				"eslint@9.4.0",
+			},
+			notExpected: []string{
+				"python@3.11.11",
+				"pylint",
+				"pmd",
+				"trivy",
+			},
+		},
+		{
+			name: "only pylint enabled",
+			tools: []tools.Tool{
+				{
+					Uuid:    PyLint,
+					Name:    "pylint",
+					Version: "3.4.0",
+				},
+			},
+			expected: []string{
+				"python@3.11.11",
+				"pylint@3.4.0",
+			},
+			notExpected: []string{
+				"node@22.2.0",
+				"eslint",
+				"pmd",
+				"trivy",
+			},
+		},
+		{
+			name: "eslint and trivy enabled",
+			tools: []tools.Tool{
+				{
+					Uuid:    ESLint,
+					Name:    "eslint",
+					Version: "9.4.0",
+				},
+				{
+					Uuid:    Trivy,
+					Name:    "trivy",
+					Version: "0.60.0",
+				},
+			},
+			expected: []string{
+				"node@22.2.0",
+				"eslint@9.4.0",
+				"trivy@0.60.0",
+			},
+			notExpected: []string{
+				"python@3.11.11",
+				"pylint",
+				"pmd",
+			},
+		},
+		{
+			name: "all tools enabled",
+			tools: []tools.Tool{
+				{
+					Uuid:    ESLint,
+					Name:    "eslint",
+					Version: "9.4.0",
+				},
+				{
+					Uuid:    Trivy,
+					Name:    "trivy",
+					Version: "0.60.0",
+				},
+				{
+					Uuid:    PyLint,
+					Name:    "pylint",
+					Version: "3.4.0",
+				},
+				{
+					Uuid:    PMD,
+					Name:    "pmd",
+					Version: "6.56.0",
+				},
+			},
+			expected: []string{
+				"node@22.2.0",
+				"python@3.11.11",
+				"eslint@9.4.0",
+				"trivy@0.60.0",
+				"pylint@3.4.0",
+				"pmd@6.56.0",
+			},
+			notExpected: []string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := configFileTemplate(tt.tools)
+
+			// Check that expected strings are present
+			for _, exp := range tt.expected {
+				assert.Contains(t, result, exp, "Config file should contain %s", exp)
+			}
+
+			// Check that not-expected strings are absent
+			for _, notExp := range tt.notExpected {
+				assert.NotContains(t, result, notExp, "Config file should not contain %s", notExp)
+			}
+		})
+	}
+}
+
+func TestCleanConfigDirectory(t *testing.T) {
+	// Create a temporary directory for testing
+	tempDir := t.TempDir()
+
+	// Create some test files in the temp dir
+	testFiles := []string{
+		"eslint.config.mjs",
+		"pylint.rc",
+		"ruleset.xml",
+		"trivy.yaml",
+	}
+
+	for _, file := range testFiles {
+		filePath := filepath.Join(tempDir, file)
+		err := os.WriteFile(filePath, []byte("test content"), 0644)
+		assert.NoError(t, err, "Failed to create test file: %s", filePath)
+	}
+
+	// Verify files exist
+	files, err := os.ReadDir(tempDir)
+	assert.NoError(t, err)
+	assert.Equal(t, len(testFiles), len(files), "Expected %d files before cleaning", len(testFiles))
+
+	// Run the clean function
+	err = cleanConfigDirectory(tempDir)
+	assert.NoError(t, err, "cleanConfigDirectory should not return an error")
+
+	// Verify all files are gone
+	files, err = os.ReadDir(tempDir)
+	assert.NoError(t, err)
+	assert.Equal(t, 0, len(files), "Expected 0 files after cleaning, got %d", len(files))
+}
diff --git a/tools/getTools.go b/tools/getTools.go
@@ -138,3 +138,17 @@ type Tool struct {
 		UsesConfigFile bool `json:"hasConfigurationFile"`
 	} `json:"settings"`
 }
+
+// FilterToolsByConfigUsage filters out tools that use their own configuration files
+// Returns only tools that need configuration to be generated for them (UsesConfigFile = false)
+func FilterToolsByConfigUsage(tools []Tool) []Tool {
+	var filtered []Tool
+	for _, tool := range tools {
+		if !tool.Settings.UsesConfigFile {
+			filtered = append(filtered, tool)
+		} else {
+			fmt.Printf("Skipping config generation for %s - configured to use repo's config file\n", tool.Name)
+		}
+	}
+	return filtered
+}
diff --git a/tools/getTools_test.go b/tools/getTools_test.go
