added tests and fixed log

Author: franciscoovazevedo

cmd/init.go

@@ -54,7 +54,7 @@ var initCmd = &cobra.Command{
 
 		if cliLocalMode {
 			fmt.Println()
-			fmt.Println("ℹ️  No project token was specified, skipping fetch configurations")
+			fmt.Println("ℹ️  No project token was specified, fetching codacy default configurations")
 			noTools := []tools.Tool{}
 			err := createConfigurationFiles(noTools, cliLocalMode)
 			if err != nil {
@@ -555,7 +555,6 @@ func createLizardConfigFile(toolsConfigDir string, patternConfiguration []domain
 			patterns[i] = pattern.PatternDefinition
 		}
 
-		fmt.Println("Lizard configuration created based on Codacy settings")
 	}
 
 	content, err := lizard.CreateLizardConfig(patterns)
@@ -588,37 +587,30 @@ func buildDefaultConfigurationFiles(toolsConfigDir string) error {
 			if err != nil {
 				return fmt.Errorf("failed to write eslint config: %v", err)
 			}
-			fmt.Println("ESLint configuration created. Ignoring plugin rules. ESLint plugins are not supported yet.")
 		case Trivy:
 			if err := createTrivyConfigFile(patternsConfig, toolsConfigDir); err != nil {
 				return fmt.Errorf("failed to create default Trivy configuration: %w", err)
 			}
-			fmt.Println("Trivy configuration created")
 		case PMD:
 			if err := createPMDConfigFile(patternsConfig, toolsConfigDir); err != nil {
 				return fmt.Errorf("failed to create default PMD configuration: %w", err)
 			}
-			fmt.Println("PMD configuration created")
 		case PyLint:
 			if err := createPylintConfigFile(patternsConfig, toolsConfigDir); err != nil {
 				return fmt.Errorf("failed to create default Pylint configuration: %w", err)
 			}
-			fmt.Println("Pylint configuration created")
 		case DartAnalyzer:
 			if err := createDartAnalyzerConfigFile(patternsConfig, toolsConfigDir); err != nil {
 				return fmt.Errorf("failed to create default Dart Analyzer configuration: %w", err)
 			}
-			fmt.Println("Dart Analyzer configuration created")
 		case Semgrep:
 			if err := createSemgrepConfigFile(patternsConfig, toolsConfigDir); err != nil {
 				return fmt.Errorf("failed to create default Semgrep configuration: %w", err)
 			}
-			fmt.Println("Semgrep configuration created")
 		case Lizard:
 			if err := createLizardConfigFile(toolsConfigDir, patternsConfig); err != nil {
 				return fmt.Errorf("failed to create default Lizard configuration: %w", err)
 			}
-			fmt.Println("Lizard configuration created")
 		}
 	}
 
@@ -635,6 +627,7 @@ const (
 	Lizard       string = "76348462-84b3-409a-90d3-955e90abfb87"
 )
 
+// AvailableTools lists all tool UUIDs supported by Codacy CLI.
 var AvailableTools = []string{
 	ESLint,
 	Trivy,

cmd/init_test.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"codacy/cli-v2/config"
 	"codacy/cli-v2/tools"
 	"os"
 	"path/filepath"
@@ -179,3 +180,66 @@ func TestCleanConfigDirectory(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, 0, len(files), "Expected 0 files after cleaning, got %d", len(files))
 }
+
+func TestInitCommand_NoToken(t *testing.T) {
+	tempDir := t.TempDir()
+	originalWD, err := os.Getwd()
+	assert.NoError(t, err, "Failed to get current working directory")
+	defer os.Chdir(originalWD)
+
+	// Use the real plugins/tools/semgrep/rules.yaml file
+	rulesPath := filepath.Join("plugins", "tools", "semgrep", "rules.yaml")
+	if _, err := os.Stat(rulesPath); os.IsNotExist(err) {
+		t.Skip("plugins/tools/semgrep/rules.yaml not found; skipping test")
+	}
+
+	// Change to the temp directory to simulate a new project
+	err = os.Chdir(tempDir)
+	assert.NoError(t, err, "Failed to change working directory to tempDir")
+
+	// Simulate running init with no token
+	initFlags.ApiToken = ""
+	initFlags.Provider = ""
+	initFlags.Organization = ""
+	initFlags.Repository = ""
+
+	// Call the Run logic from initCmd
+	if err := config.Config.CreateLocalCodacyDir(); err != nil {
+		t.Fatalf("Failed to create local codacy directory: %v", err)
+	}
+
+	toolsConfigDir := config.Config.ToolsConfigDirectory()
+	if err := os.MkdirAll(toolsConfigDir, 0777); err != nil {
+		t.Fatalf("Failed to create tools-configs directory: %v", err)
+	}
+
+	cliLocalMode := len(initFlags.ApiToken) == 0
+	if cliLocalMode {
+		noTools := []tools.Tool{}
+		err := createConfigurationFiles(noTools, cliLocalMode)
+		assert.NoError(t, err, "createConfigurationFiles should not return an error")
+		if err := buildDefaultConfigurationFiles(toolsConfigDir); err != nil {
+			t.Fatalf("Failed to build default configuration files: %v", err)
+		}
+	}
+
+	// Assert that the expected config files are created
+	codacyDir := config.Config.LocalCodacyDirectory()
+	expectedFiles := []string{
+		"tools-configs/eslint.config.mjs",
+		"tools-configs/trivy.yaml",
+		"tools-configs/ruleset.xml",
+		"tools-configs/pylint.rc",
+		"tools-configs/analysis_options.yaml",
+		"tools-configs/semgrep.yaml",
+		"tools-configs/lizard.yaml",
+		"codacy.yaml",
+		"cli-config.yaml",
+	}
+
+	for _, file := range expectedFiles {
+		filePath := filepath.Join(codacyDir, file)
+		_, err := os.Stat(filePath)
+		assert.NoError(t, err, "Expected config file %s to be created", file)
+	}
+}

codacy-client/client.go

@@ -3,10 +3,10 @@ package codacyclient
 import (
 	"codacy/cli-v2/domain"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"time"
 )
 
@@ -20,23 +20,21 @@ func getRequest(url string, initFlags domain.InitFlags) ([]byte, error) {
 
 	req, err := http.NewRequest("GET", url, nil)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
 	req.Header.Set("api-token", initFlags.ApiToken)
 
 	resp, err := client.Do(req)
 
 	if err != nil {
-		fmt.Printf("Error sending request: %v\n", err)
-		return nil, err
+		return nil, fmt.Errorf("error sending request: %w", err)
 	}
 
 	defer resp.Body.Close()
 
 	if resp.StatusCode != 200 {
-		fmt.Println("Error:", url)
-		return nil, errors.New("Failed in request to " + url)
+		return nil, fmt.Errorf("request to %s failed with status %d", url, resp.StatusCode)
 	}
 
 	// Read the response body
@@ -66,11 +64,14 @@ func handlePaginationGeneric[T any](
 	for {
 		pageURL := baseURL
 		if !firstRequest && cursor != "" {
-			if pageURL[len(pageURL)-1] == '?' || pageURL[len(pageURL)-1] == '&' {
-				pageURL += fmt.Sprintf("cursor=%s", cursor)
-			} else {
-				pageURL += fmt.Sprintf("&cursor=%s", cursor)
+			u, err := url.Parse(pageURL)
+			if err != nil {
+				return nil, err
 			}
+			q := u.Query()
+			q.Set("cursor", cursor)
+			u.RawQuery = q.Encode()
+			pageURL = u.String()
 		}
 		firstRequest = false
 

codacy-client/client_test.go

@@ -0,0 +1,82 @@
+package codacyclient
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"codacy/cli-v2/domain"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetRequest_Success(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(`{"data": "ok"}`))
+	}))
+	defer ts.Close()
+
+	initFlags := domain.InitFlags{ApiToken: "dummy"}
+	resp, err := getRequest(ts.URL, initFlags)
+	assert.NoError(t, err)
+	assert.Contains(t, string(resp), "ok")
+}
+
+func TestGetRequest_Failure(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer ts.Close()
+
+	initFlags := domain.InitFlags{ApiToken: "dummy"}
+	_, err := getRequest(ts.URL, initFlags)
+	assert.Error(t, err)
+}
+
+func TestHandlePaginationGeneric(t *testing.T) {
+	type testItem struct{ Value int }
+	pages := [][]testItem{
+		{{Value: 1}, {Value: 2}},
+		{{Value: 3}},
+	}
+	calls := 0
+	fetchPage := func(url string) ([]testItem, string, error) {
+		if calls < len(pages) {
+			page := pages[calls]
+			calls++
+			if calls < len(pages) {
+				return page, "next", nil
+			}
+			return page, "", nil
+		}
+		return nil, "", nil
+	}
+	results, err := handlePaginationGeneric[testItem]("base", "", fetchPage)
+	assert.NoError(t, err)
+	assert.Len(t, results, 3)
+}
+
+func TestGetDefaultToolPatternsConfig_Empty(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		resp := map[string]interface{}{
+			"data":       []interface{}{},
+			"pagination": map[string]interface{}{"cursor": ""},
+		}
+		json.NewEncoder(w).Encode(resp)
+	}))
+	defer ts.Close()
+
+	// TODO: Refactor GetDefaultToolPatternsConfig to accept a baseURL for easier testing
+	// oldBase := CodacyApiBase
+	// CodacyApiBase = ts.URL
+	// defer func() { CodacyApiBase = oldBase }()
+
+	// Placeholder: test cannot be run until function is refactored for testability
+	_ = ts // avoid unused warning
+	// initFlags := domain.InitFlags{ApiToken: "dummy"}
+	// patterns, err := GetDefaultToolPatternsConfig(initFlags, "tool-uuid")
+	// assert.NoError(t, err)
+	// assert.Empty(t, patterns)
+}