refactor to use codacyclient to make all api requests

Author: franciscoovazevedo

cmd/init.go

@@ -8,22 +8,15 @@ import (
 	"codacy/cli-v2/tools/lizard"
 	"codacy/cli-v2/tools/pylint"
 	"codacy/cli-v2/utils"
-	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"log"
-	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
-	"time"
 
 	"github.com/spf13/cobra"
 )
 
-const CodacyApiBase = "https://app.codacy.com"
-
 var initFlags domain.InitFlags
 
 func init() {
@@ -55,7 +48,7 @@ var initCmd = &cobra.Command{
 		if cliLocalMode {
 			fmt.Println()
 			fmt.Println("ℹ️  No project token was specified, fetching codacy default configurations")
-			noTools := []tools.Tool{}
+			noTools := []domain.Tool{}
 			err := createConfigurationFiles(noTools, cliLocalMode)
 			if err != nil {
 				log.Fatal(err)
@@ -97,7 +90,7 @@ func createGitIgnoreFile() error {
 	return nil
 }
 
-func createConfigurationFiles(tools []tools.Tool, cliLocalMode bool) error {
+func createConfigurationFiles(tools []domain.Tool, cliLocalMode bool) error {
 	configFile, err := os.Create(config.Config.ProjectConfigFile())
 	if err != nil {
 		return fmt.Errorf("failed to create project config file: %w", err)
@@ -125,7 +118,7 @@ func createConfigurationFiles(tools []tools.Tool, cliLocalMode bool) error {
 	return nil
 }
 
-func configFileTemplate(tools []tools.Tool) string {
+func configFileTemplate(tools []domain.Tool) string {
 	// Maps to track which tools are enabled
 	toolsMap := make(map[string]bool)
 	toolVersions := make(map[string]string)
@@ -255,11 +248,7 @@ func buildRepositoryConfigurationFiles(token string) error {
 		return fmt.Errorf("failed to clean configuration directory: %w", err)
 	}
 
-	client := &http.Client{
-		Timeout: 10 * time.Second,
-	}
-
-	apiTools, err := tools.GetRepositoryTools(CodacyApiBase, token, initFlags.Provider, initFlags.Organization, initFlags.Repository)
+	apiTools, err := tools.GetRepositoryTools(initFlags)
 	if err != nil {
 		return err
 	}
@@ -276,7 +265,7 @@ func buildRepositoryConfigurationFiles(token string) error {
 	}
 
 	// Generate languages configuration based on API tools response
-	if err := tools.CreateLanguagesConfigFile(apiTools, toolsConfigDir, uuidToName, token, initFlags.Provider, initFlags.Organization, initFlags.Repository); err != nil {
+	if err := tools.CreateLanguagesConfigFile(apiTools, toolsConfigDir, uuidToName, initFlags); err != nil {
 		return fmt.Errorf("failed to create languages configuration file: %w", err)
 	}
 
@@ -292,52 +281,7 @@ func buildRepositoryConfigurationFiles(token string) error {
 	// 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&limit=1000",
-			CodacyApiBase,
-			initFlags.Provider,
-			initFlags.Organization,
-			initFlags.Repository,
-			tool.Uuid)
-
-		// Create a new GET request
-		req, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			fmt.Println("Error:", err)
-			return err
-		}
-
-		// Set the headers
-		req.Header.Set("api-token", token)
-
-		// Send the request
-		resp, err := client.Do(req)
-		if err != nil {
-			fmt.Println("Error:", err)
-			return err
-		}
-		defer resp.Body.Close()
-
-		if resp.StatusCode >= 400 {
-			return errors.New("failed to get repository's configuration from Codacy API")
-		}
-
-		// Read the response body
-		body, err := io.ReadAll(resp.Body)
-		if err != nil {
-			fmt.Println("Error:", err)
-			return err
-		}
-
-		var objmap map[string]json.RawMessage
-		err = json.Unmarshal(body, &objmap)
-
-		if err != nil {
-			fmt.Println("Error unmarshaling response:", err)
-			return err
-		}
-
-		var apiToolConfigurations []domain.PatternConfiguration
-		err = json.Unmarshal(objmap["data"], &apiToolConfigurations)
+		apiToolConfigurations, err := codacyclient.GetRepositoryToolPatterns(initFlags, tool.Uuid)
 
 		if err != nil {
 			fmt.Println("Error unmarshaling tool configurations:", err)
@@ -351,7 +295,7 @@ func buildRepositoryConfigurationFiles(token string) error {
 }
 
 // map tool uuid to tool name
-func createToolFileConfigurations(tool tools.Tool, patternConfiguration []domain.PatternConfiguration) error {
+func createToolFileConfigurations(tool domain.Tool, patternConfiguration []domain.PatternConfiguration) error {
 	toolsConfigDir := config.Config.ToolsConfigDirectory()
 	switch tool.Uuid {
 	case ESLint:
@@ -544,17 +488,19 @@ func createLizardConfigFile(toolsConfigDir string, patternConfiguration []domain
 	var patterns []domain.PatternDefinition
 
 	if len(patternConfiguration) == 0 {
-		var err error
-		patterns, err = tools.FetchDefaultEnabledPatterns(Lizard)
+		patternsConfig, err := codacyclient.GetDefaultToolPatternsConfig(initFlags, Lizard)
 		if err != nil {
 			return err
 		}
+		patterns = make([]domain.PatternDefinition, len(patternsConfig))
+		for i, pattern := range patternsConfig {
+			patterns[i] = pattern.PatternDefinition
+		}
 	} else {
 		patterns = make([]domain.PatternDefinition, len(patternConfiguration))
 		for i, pattern := range patternConfiguration {
 			patterns[i] = pattern.PatternDefinition
 		}
-
 	}
 
 	content, err := lizard.CreateLizardConfig(patterns)

cmd/init_test.go

@@ -2,7 +2,7 @@ package cmd
 
 import (
 	"codacy/cli-v2/config"
-	"codacy/cli-v2/tools"
+	"codacy/cli-v2/domain"
 	"codacy/cli-v2/utils"
 	"os"
 	"path/filepath"
@@ -14,13 +14,13 @@ import (
 func TestConfigFileTemplate(t *testing.T) {
 	tests := []struct {
 		name        string
-		tools       []tools.Tool
+		tools       []domain.Tool
 		expected    []string
 		notExpected []string
 	}{
 		{
 			name:  "empty tools list uses defaults",
-			tools: []tools.Tool{},
+			tools: []domain.Tool{},
 			expected: []string{
 				"[email protected]",
 				"[email protected]",
@@ -33,7 +33,7 @@ func TestConfigFileTemplate(t *testing.T) {
 		},
 		{
 			name: "only eslint enabled",
-			tools: []tools.Tool{
+			tools: []domain.Tool{
 				{
 					Uuid:    ESLint,
 					Name:    "eslint",
@@ -53,7 +53,7 @@ func TestConfigFileTemplate(t *testing.T) {
 		},
 		{
 			name: "only pylint enabled",
-			tools: []tools.Tool{
+			tools: []domain.Tool{
 				{
 					Uuid:    PyLint,
 					Name:    "pylint",
@@ -73,7 +73,7 @@ func TestConfigFileTemplate(t *testing.T) {
 		},
 		{
 			name: "eslint and trivy enabled",
-			tools: []tools.Tool{
+			tools: []domain.Tool{
 				{
 					Uuid:    ESLint,
 					Name:    "eslint",
@@ -98,7 +98,7 @@ func TestConfigFileTemplate(t *testing.T) {
 		},
 		{
 			name: "all tools enabled",
-			tools: []tools.Tool{
+			tools: []domain.Tool{
 				{
 					Uuid:    ESLint,
 					Name:    "eslint",
@@ -216,7 +216,7 @@ func TestInitCommand_NoToken(t *testing.T) {
 
 	cliLocalMode := len(initFlags.ApiToken) == 0
 	if cliLocalMode {
-		noTools := []tools.Tool{}
+		noTools := []domain.Tool{}
 		err := createConfigurationFiles(noTools, cliLocalMode)
 		assert.NoError(t, err, "createConfigurationFiles should not return an error")
 		if err := buildDefaultConfigurationFiles(toolsConfigDir); err != nil {

codacy-client/client.go

@@ -13,7 +13,7 @@ import (
 const timeout = 10 * time.Second
 const CodacyApiBase = "https://app.codacy.com"
 
-func getRequest(url string, initFlags domain.InitFlags) ([]byte, error) {
+func getRequest(url string, apiToken string) ([]byte, error) {
 	client := &http.Client{
 		Timeout: timeout,
 	}
@@ -23,7 +23,9 @@ func getRequest(url string, initFlags domain.InitFlags) ([]byte, error) {
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
-	req.Header.Set("api-token", initFlags.ApiToken)
+	if apiToken != "" {
+		req.Header.Set("api-token", apiToken)
+	}
 
 	resp, err := client.Do(req)
 
@@ -52,7 +54,7 @@ func GetPage[T any](
 	initFlags domain.InitFlags,
 	parser func([]byte) ([]T, string, error),
 ) ([]T, string, error) {
-	response, err := getRequest(url, initFlags)
+	response, err := getRequest(url, initFlags.ApiToken)
 	if err != nil {
 		return nil, "", fmt.Errorf("failed to get page: %w", err)
 	}
@@ -148,3 +150,64 @@ func GetRepositoryToolPatterns(initFlags domain.InitFlags, toolUUID string) ([]d
 		toolUUID)
 	return getAllPages(baseURL, initFlags, parsePatternConfigurations)
 }
+
+func GetRepositoryTools(initFlags domain.InitFlags) ([]domain.Tool, error) {
+	baseURL := fmt.Sprintf("%s/api/v3/analysis/organizations/%s/%s/repositories/%s/tools",
+		CodacyApiBase,
+		initFlags.Provider,
+		initFlags.Organization,
+		initFlags.Repository)
+
+	bodyResponse, err := getRequest(baseURL, initFlags.ApiToken)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get repository tools: %w", err)
+	}
+
+	var toolsResponse domain.ToolsResponse
+
+	err = json.Unmarshal(bodyResponse, &toolsResponse)
+	if err != nil {
+		fmt.Println("Error unmarshaling response:", err)
+		return nil, err
+	}
+
+	return toolsResponse.Data, nil
+}
+
+func GetToolsVersions() ([]domain.Tool, error) {
+	baseURL := fmt.Sprintf("%s/api/v3/tools", CodacyApiBase)
+
+	bodyResponse, err := getRequest(baseURL, "")
+	if err != nil {
+		return nil, fmt.Errorf("failed to get tool versions: %w", err)
+	}
+
+	var toolsResponse domain.ToolsResponse
+	err = json.Unmarshal(bodyResponse, &toolsResponse)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal response: %w", err)
+	}
+
+	return toolsResponse.Data, nil
+}
+
+func GetRepositoryLanguages(initFlags domain.InitFlags) ([]domain.Language, error) {
+	baseURL := fmt.Sprintf("%s/api/v3/analysis/organizations/%s/%s/repositories/%s/settings/languages",
+		CodacyApiBase,
+		initFlags.Provider,
+		initFlags.Organization,
+		initFlags.Repository)
+
+	bodyResponse, err := getRequest(baseURL, initFlags.ApiToken)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get repository languages: %w", err)
+	}
+
+	var languagesResponse domain.LanguagesResponse
+	err = json.Unmarshal(bodyResponse, &languagesResponse)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal response: %w", err)
+	}
+
+	return languagesResponse.Languages, nil
+}

codacy-client/client_test.go

@@ -19,7 +19,7 @@ func TestGetRequest_Success(t *testing.T) {
 	defer ts.Close()
 
 	initFlags := domain.InitFlags{ApiToken: "dummy"}
-	resp, err := getRequest(ts.URL, initFlags)
+	resp, err := getRequest(ts.URL, initFlags.ApiToken)
 	assert.NoError(t, err)
 	assert.Contains(t, string(resp), "ok")
 }
@@ -31,7 +31,7 @@ func TestGetRequest_Failure(t *testing.T) {
 	defer ts.Close()
 
 	initFlags := domain.InitFlags{ApiToken: "dummy"}
-	_, err := getRequest(ts.URL, initFlags)
+	_, err := getRequest(ts.URL, initFlags.ApiToken)
 	assert.Error(t, err)
 }
 

domain/language.go

@@ -0,0 +1,25 @@
+package domain
+
+type Language struct {
+	Name           string   `json:"name"`
+	CodacyDefaults []string `json:"codacyDefaults"`
+	Extensions     []string `json:"extensions"`
+	Enabled        bool     `json:"enabled"`
+	Detected       bool     `json:"detected"`
+}
+
+type LanguagesResponse struct {
+	Languages []Language `json:"languages"`
+}
+
+// ToolLanguageInfo contains language and extension information for a tool
+type ToolLanguageInfo struct {
+	Name       string   `yaml:"name"`
+	Languages  []string `yaml:"languages,flow"`
+	Extensions []string `yaml:"extensions,flow"`
+}
+
+// LanguagesConfig represents the structure of the languages configuration file
+type LanguagesConfig struct {
+	Tools []ToolLanguageInfo `yaml:"tools"`
+}

domain/tool.go

@@ -0,0 +1,16 @@
+package domain
+
+type ToolsResponse struct {
+	Data []Tool `json:"data"`
+}
+
+type Tool struct {
+	Uuid     string `json:"uuid"`
+	Name     string `json:"name"`
+	Version  string `json:"version"`
+	Settings struct {
+		Enabled               bool `json:"isEnabled"`
+		HasConfigurationFile  bool `json:"hasConfigurationFile"`
+		UsesConfigurationFile bool `json:"usesConfigurationFile"`
+	} `json:"settings"`
+}