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

franciscoovazevedo · franciscoovazevedo · commit 1b285eacb91e · 2025-06-11T10:57:19.000+01:00
diff --git a/cmd/analyze.go b/cmd/analyze.go
@@ -2,21 +2,22 @@ package cmd
 
 import (
 	"codacy/cli-v2/config"
+	"codacy/cli-v2/domain"
 	"codacy/cli-v2/plugins"
 	"codacy/cli-v2/tools"
 	"codacy/cli-v2/tools/lizard"
 	reviveTool "codacy/cli-v2/tools/revive"
 	"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"
 )
@@ -211,21 +212,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")
@@ -234,66 +220,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
 }
diff --git a/cmd/upload.go b/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
 		}
diff --git a/domain/patternConfiguration.go b/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"`
+}
diff --git a/domain/tool.go b/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"`
diff --git a/tools/lizard/test/expected.sarif b/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": [
             {
diff --git a/tools/lizard/test/lizardRunner_test.go b/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)
 	}

Original file line number	Diff line number	Diff line change
`@@ -10,46 +10,46 @@`
`10`	`10`	`"informationUri": "https://github.com/terryyin/lizard",`
`11`	`11`	`"rules": [`
`12`	`12`	`{`
`13`		`- "id": "Lizard_ccn-critical",`
	`13`	`+ "id": "Lizard_ccn-medium",`
`14`	`14`	`"shortDescription": {`
`15`		`- "text": "Method has extremely high cyclomatic complexity"`
	`15`	`+ "text": "Checks if the cyclomatic complexity of a function or logic block exceeds the medium threshold (default is 8)."`
`16`	`16`	`},`
`17`	`17`	`"properties": {`
`18`	`18`	`"tags": [`
`19`		`- "critical"`
	`19`	`+ "warning"`
`20`	`20`	`]`
`21`	`21`	`}`
`22`	`22`	`},`
`23`	`23`	`{`
`24`		`- "id": "Lizard_ccn-minor",`
	`24`	`+ "id": "Lizard_file-nloc-medium",`
`25`	`25`	`"shortDescription": {`
`26`		`- "text": "Method has high cyclomatic complexity"`
	`26`	`+ "text": "This rule checks if the number of lines of code (excluding comments) in a file exceeds a medium threshold, typically 500 lines."`
`27`	`27`	`},`
`28`	`28`	`"properties": {`
`29`	`29`	`"tags": [`
`30`		`- "minor"`
	`30`	`+ "warning"`
`31`	`31`	`]`
`32`	`32`	`}`
`33`	`33`	`},`
`34`	`34`	`{`
`35`	`35`	`"id": "Lizard_nloc-medium",`
`36`	`36`	`"shortDescription": {`
`37`		`- "text": "Method has too many lines of code"`
	`37`	`+ "text": "Checks if the number of lines of code (excluding comments) in a function exceeds a medium threshold (default 50 lines)."`
`38`	`38`	`},`
`39`	`39`	`"properties": {`
`40`	`40`	`"tags": [`
`41`		`- "medium"`
	`41`	`+ "warning"`
`42`	`42`	`]`
`43`	`43`	`}`
`44`	`44`	`},`
`45`	`45`	`{`
`46`		`- "id": "Lizard_nloc-minor",`
	`46`	`+ "id": "Lizard_parameter-count-medium",`
`47`	`47`	`"shortDescription": {`
`48`		`- "text": "Method has too many lines of code"`
	`48`	`+ "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."`
`49`	`49`	`},`
`50`	`50`	`"properties": {`
`51`	`51`	`"tags": [`
`52`		`- "minor"`
	`52`	`+ "warning"`
`53`	`53`	`]`
`54`	`54`	`}`
`55`	`55`	`}`
`@@ -59,9 +59,9 @@`
`59`	`59`	`"results": [`
`60`	`60`	`{`
`61`	`61`	`"ruleId": "Lizard_nloc-medium",`
`62`		`- "level": "medium",`
	`62`	`+ "level": "warning",`
`63`	`63`	`"message": {`
`64`		`- "text": "Method complex_analysis has 65 lines of code (limit is 25)"`
	`64`	`+ "text": "Method complex_analysis has 65 lines of code (limit is 50)"`
`65`	`65`	`},`
`66`	`66`	`"locations": [`
`67`	`67`	`{`
`@@ -78,10 +78,10 @@`
`78`	`78`	`]`
`79`	`79`	`},`
`80`	`80`	`{`
`81`		`- "ruleId": "Lizard_ccn-critical",`
`82`		`- "level": "critical",`
	`81`	`+ "ruleId": "Lizard_ccn-medium",`
	`82`	`+ "level": "warning",`
`83`	`83`	`"message": {`
`84`		`- "text": "Method complex_analysis has a cyclomatic complexity of 31 (limit is 30)"`
	`84`	`+ "text": "Method complex_analysis has a cyclomatic complexity of 31 (limit is 8)"`
`85`	`85`	`},`
`86`	`86`	`"locations": [`
`87`	`87`	`{`