refactor upload to use codacyclient, use domain types and run lizard like other tools

Author: franciscoovazevedo

cmd/analyze.go

@@ -2,20 +2,21 @@ package cmd
 
 import (
 	"codacy/cli-v2/config"
+	"codacy/cli-v2/domain"
 	"codacy/cli-v2/plugins"
 	"codacy/cli-v2/tools"
 	"codacy/cli-v2/tools/lizard"
 	"encoding/json"
 	"fmt"
-	"io"
 	"log"
-	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
 
 	"codacy/cli-v2/utils"
 
+	codacyclient "codacy/cli-v2/codacy-client"
+
 	"github.com/spf13/cobra"
 	"gopkg.in/yaml.v3"
 )
@@ -210,21 +211,6 @@ type CodacyIssue struct {
 	Category string `json:"category"`
 }
 
-type Tool struct {
-	UUID      string `json:"uuid"`
-	ShortName string `json:"shortName"`
-	Prefix    string `json:"prefix"`
-}
-
-type Pattern struct {
-	UUID        string `json:"uuid"`
-	ID          string `json:"id"`
-	Name        string `json:"name"`
-	Category    string `json:"category"`
-	Description string `json:"description"`
-	Level       string `json:"level"`
-}
-
 func init() {
 	analyzeCmd.Flags().StringVarP(&outputFile, "output", "o", "", "Output file for analysis results")
 	analyzeCmd.Flags().StringVarP(&toolsToAnalyzeParam, "tool", "t", "", "Which tool to run analysis with. If not specified, all configured tools will be run")
@@ -233,66 +219,24 @@ func init() {
 	rootCmd.AddCommand(analyzeCmd)
 }
 
-func loadsToolAndPatterns(toolName string) (Tool, []Pattern) {
-	var toolsURL = "https://app.codacy.com/api/v3/tools"
-
-	req, err := http.NewRequest("GET", toolsURL, nil)
+func loadsToolAndPatterns(toolName string) (domain.Tool, []domain.PatternConfiguration) {
+	var toolsResponse, err = codacyclient.GetToolsVersions()
 	if err != nil {
-		fmt.Printf("Error creating request: %v\n", err)
-		panic("panic")
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		fmt.Printf("Error fetching patterns: %v\n", err)
-		panic("panic")
-	}
-	defer resp.Body.Close()
-
-	body, _ := io.ReadAll(resp.Body)
-
-	var toolsResponse struct {
-		Data []Tool `json:"data"`
+		fmt.Println("Error:", err)
+		return domain.Tool{}, []domain.PatternConfiguration{}
 	}
-	json.Unmarshal(body, &toolsResponse)
-	var tool Tool
-	for _, t := range toolsResponse.Data {
-		if t.ShortName == toolName {
+	var tool domain.Tool
+	for _, t := range toolsResponse {
+		if t.Name == toolName {
 			tool = t
 			break
 		}
 	}
-	var patterns []Pattern
-	var hasNext bool = true
-	cursor := ""
-	client := &http.Client{}
-
-	for hasNext {
-		baseURL := fmt.Sprintf("https://app.codacy.com/api/v3/tools/%s/patterns?limit=1000%s", tool.UUID, cursor)
-		req, _ := http.NewRequest("GET", baseURL, nil)
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := client.Do(req)
-		if err != nil {
-			fmt.Println("Error:", err)
-			break
-		}
-		defer resp.Body.Close()
-		body, _ := io.ReadAll(resp.Body)
-
-		var patternsResponse struct {
-			Data       []Pattern `json:"data"`
-			Pagination struct {
-				Cursor string `json:"cursor"`
-			} `json:"pagination"`
-		}
-		json.Unmarshal(body, &patternsResponse)
-		patterns = append(patterns, patternsResponse.Data...)
-		hasNext = patternsResponse.Pagination.Cursor != ""
-		if hasNext {
-			cursor = "&cursor=" + patternsResponse.Pagination.Cursor
-		}
+	var patterns []domain.PatternConfiguration
+	patterns, err = codacyclient.GetDefaultToolPatternsConfig(domain.InitFlags{}, tool.Uuid)
+	if err != nil {
+		fmt.Println("Error:", err)
+		return domain.Tool{}, []domain.PatternConfiguration{}
 	}
 	return tool, patterns
 }

cmd/upload.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"bytes"
+	"codacy/cli-v2/domain"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -206,8 +207,18 @@ func resultsFinalWithAPIToken(commitUUID string, apiToken string, provider strin
 	fmt.Println("Response Body:", string(body))
 }
 
-func getPatternByID(patterns []Pattern, patternID string) *Pattern {
+func getPatternByID(patterns []domain.PatternConfiguration, patternID string) *domain.SarifPatternConfiguration {
+	var sarifPatterns []domain.SarifPatternConfiguration
 	for _, p := range patterns {
+		sarifPatterns = append(sarifPatterns, domain.SarifPatternConfiguration{
+			UUID:        p.PatternDefinition.Id,
+			ID:          p.PatternDefinition.Id,
+			Category:    p.PatternDefinition.Category,
+			Description: p.PatternDefinition.Description,
+			Level:       p.PatternDefinition.Level,
+		})
+	}
+	for _, p := range sarifPatterns {
 		if strings.EqualFold(p.ID, patternID) {
 			return &p
 		}

domain/patternConfiguration.go

@@ -36,3 +36,12 @@ type PatternResponse struct {
 	IsCustom          bool                     `json:"isCustom"`
 	Parameters        []ParameterConfiguration `json:"parameters"`
 }
+
+type SarifPatternConfiguration struct {
+	UUID        string `json:"uuid"`
+	ID          string `json:"id"`
+	Name        string `json:"name"`
+	Category    string `json:"category"`
+	Description string `json:"description"`
+	Level       string `json:"level"`
+}

domain/tool.go

@@ -7,10 +7,12 @@ type ToolsResponse struct {
 
 // Tool represents a tool in the Codacy API
 type Tool struct {
-	Uuid     string `json:"uuid"`
-	Name     string `json:"name"`
-	Version  string `json:"version"`
-	Settings struct {
+	Uuid      string `json:"uuid"`
+	Name      string `json:"name"`
+	Version   string `json:"version"`
+	ShortName string `json:"shortName"`
+	Prefix    string `json:"prefix"`
+	Settings  struct {
 		Enabled               bool `json:"isEnabled"`
 		HasConfigurationFile  bool `json:"hasConfigurationFile"`
 		UsesConfigurationFile bool `json:"usesConfigurationFile"`

tools/lizard/test/expected.sarif

@@ -10,46 +10,46 @@
           "informationUri": "https://github.com/terryyin/lizard",
           "rules": [
             {
-              "id": "Lizard_ccn-critical",
+              "id": "Lizard_ccn-medium",
               "shortDescription": {
-                "text": "Method has extremely high cyclomatic complexity"
+                "text": "Checks if the cyclomatic complexity of a function or logic block exceeds the medium threshold (default is 8)."
               },
               "properties": {
                 "tags": [
-                  "critical"
+                  "warning"
                 ]
               }
             },
             {
-              "id": "Lizard_ccn-minor",
+              "id": "Lizard_file-nloc-medium",
               "shortDescription": {
-                "text": "Method has high cyclomatic complexity"
+                "text": "This rule checks if the number of lines of code (excluding comments) in a file exceeds a medium threshold, typically 500 lines."
               },
               "properties": {
                 "tags": [
-                  "minor"
+                  "warning"
                 ]
               }
             },
             {
               "id": "Lizard_nloc-medium",
               "shortDescription": {
-                "text": "Method has too many lines of code"
+                "text": "Checks if the number of lines of code (excluding comments) in a function exceeds a medium threshold (default 50 lines)."
               },
               "properties": {
                 "tags": [
-                  "medium"
+                  "warning"
                 ]
               }
             },
             {
-              "id": "Lizard_nloc-minor",
+              "id": "Lizard_parameter-count-medium",
               "shortDescription": {
-                "text": "Method has too many lines of code"
+                "text": "This rule checks the number of parameters passed to a function and raises an issue if it exceeds a medium threshold, which by default is 8 parameters."
               },
               "properties": {
                 "tags": [
-                  "minor"
+                  "warning"
                 ]
               }
             }
@@ -59,9 +59,9 @@
       "results": [
         {
           "ruleId": "Lizard_nloc-medium",
-          "level": "medium",
+          "level": "warning",
           "message": {
-            "text": "Method complex_analysis has 65 lines of code (limit is 25)"
+            "text": "Method complex_analysis has 65 lines of code (limit is 50)"
           },
           "locations": [
             {
@@ -78,10 +78,10 @@
           ]
         },
         {
-          "ruleId": "Lizard_ccn-critical",
-          "level": "critical",
+          "ruleId": "Lizard_ccn-medium",
+          "level": "warning",
           "message": {
-            "text": "Method complex_analysis has a cyclomatic complexity of 31 (limit is 30)"
+            "text": "Method complex_analysis has a cyclomatic complexity of 31 (limit is 8)"
           },
           "locations": [
             {

tools/lizard/test/lizardRunner_test.go

@@ -1,7 +1,6 @@
 package test
 
 import (
-	"codacy/cli-v2/domain"
 	"codacy/cli-v2/tools/lizard"
 	"os"
 	"path/filepath"
@@ -31,70 +30,6 @@ func TestRunLizardWithSarifOutput(t *testing.T) {
 	// Construct the path to the test file
 	complexPyPath := filepath.Join(currentDir, "complex.py")
 
-	// Create test patterns
-	patterns := []domain.PatternDefinition{
-		{
-			Id:            "Lizard_nloc-minor",
-			Category:      "CodeStyle",
-			Level:         "Code",
-			SeverityLevel: "Minor",
-			Title:         "Method Too Long (Minor)",
-			Description:   "Method has too many lines of code",
-			Parameters: []domain.ParameterConfiguration{
-				{
-					Name:    "threshold",
-					Value:   "15",
-					Default: "15",
-				},
-			},
-		},
-		{
-			Id:            "Lizard_nloc-medium",
-			Category:      "CodeStyle",
-			Level:         "Code",
-			SeverityLevel: "Medium",
-			Title:         "Method Too Long (Medium)",
-			Description:   "Method has too many lines of code",
-			Parameters: []domain.ParameterConfiguration{
-				{
-					Name:    "threshold",
-					Value:   "25",
-					Default: "25",
-				},
-			},
-		},
-		{
-			Id:            "Lizard_ccn-minor",
-			Category:      "CodeStyle",
-			Level:         "Code",
-			SeverityLevel: "Minor",
-			Title:         "Cyclomatic Complexity (Minor)",
-			Description:   "Method has high cyclomatic complexity",
-			Parameters: []domain.ParameterConfiguration{
-				{
-					Name:    "threshold",
-					Value:   "3",
-					Default: "3",
-				},
-			},
-		},
-		{
-			Id:            "Lizard_ccn-critical",
-			Category:      "CodeStyle",
-			Level:         "Code",
-			SeverityLevel: "Critical",
-			Title:         "Cyclomatic Complexity (Critical)",
-			Description:   "Method has extremely high cyclomatic complexity",
-			Parameters: []domain.ParameterConfiguration{
-				{
-					Name:    "threshold",
-					Value:   "30",
-					Default: "30",
-				},
-			},
-		},
-	}
-
 	// Create a temporary output file
 	outputFile := filepath.Join(currentDir, "output.sarif")
 	defer os.Remove(outputFile)
@@ -107,7 +42,7 @@ func TestRunLizardWithSarifOutput(t *testing.T) {
 	expectedOutput := strings.TrimSpace(string(expectedData))
 
 	// Run Lizard with SARIF output
-	err = lizard.RunLizard(currentDir, lizardBinary, []string{complexPyPath}, outputFile, "sarif", patterns)
+	err = lizard.RunLizard(currentDir, lizardBinary, []string{complexPyPath}, outputFile, "sarif")
 	if err != nil {
 		t.Fatalf("RunLizard failed: %v", err)
 	}