Merge pull request #71 from diegopereiraeng/main

Job Status more verbose for timeout troubleshooting

Author: diegopereiraeng

.drone.yml

@@ -45,33 +45,13 @@ steps:
   #     ref:
   #       - refs/heads/main
   #       - refs/tags/**
-  - name: publish-2.0.3-java11
-    image: plugins/docker:20
-    settings:
-      # auto_tag: true
-      # auto_tag_suffix: v2.0.2-java11
-      tags:
-        - v2.0.3-java11
-        # - latest-java11
-        # - stable-java11
-      daemon_off: false
-      dockerfile: Dockerfile
-      password:
-        from_secret: docker_password
-      repo: plugins/sonarqube-scanner
-      username:
-        from_secret: docker_username
-    when:
-      ref:
-        - refs/heads/main
-        - refs/tags/**
-  - name: publish-2.0.3-java17
+  - name: publish-2.0.4-java17
     image: plugins/docker:20
     settings:
       # auto_tag: true
       # auto_tag_suffix: v2.0.2-java17
       tags:
-        - v2.0.3-java17
+        - v2.0.4-java17
         # - latest-java17
         # - stable-java17
       daemon_off: false

DockerfileJava17

@@ -23,7 +23,7 @@ ARG SONAR_SCANNER=sonar-scanner-${SONAR_VERSION}
 #     && apt-get install -y nodejs curl \
 #     && apt-get clean
 
-RUN apk --no-cache add nodejs curl unzip
+RUN apk --no-cache --update add nodejs curl unzip
 
 COPY --from=build /go/src/github.com/diegopereiraeng/harness-cie-sonarqube-scanner/harness-sonar /bin/
 WORKDIR /bin

plugin.go

@@ -7,6 +7,7 @@ import (
 	"encoding/xml"
 	"errors"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"net"
 	"net/http"
@@ -250,7 +251,7 @@ func displaySummary(total, passed, failed int, errors int, newErrors int, projec
 	}
 
 	// Write to the .env file
-	filePath := fmt.Sprintf("%s", droneOutputPath)
+	filePath := fmt.Sprintf(droneOutputPath)
 	err := writeEnvFile(vars, filePath)
 	if err != nil {
 		fmt.Println("Error writing to .env file:", err)
@@ -1034,34 +1035,59 @@ func GetLatestTaskID(sonarHost string, projectSlug string) (string, error) {
 }
 
 func getSonarJobStatus(report *SonarReport) *TaskResponse {
+	fmt.Printf("\n")
+	fmt.Printf("==> Job Status Request:\n")
+	fmt.Printf(report.ServerURL + "/api/ce/task?id=" + report.CeTaskID)
+	fmt.Printf("\n")
+	fmt.Printf("\n")
 
 	taskRequest, err := http.NewRequest("GET", report.CeTaskURL, nil)
+	if err != nil {
+		logrus.WithFields(logrus.Fields{
+			"error": err,
+		}).Fatal("Failed get sonar job status")
+	}
 	taskRequest.Header.Add("Authorization", basicAuth+os.Getenv("PLUGIN_SONAR_TOKEN"))
 	taskResponse, err := netClient.Do(taskRequest)
 	if err != nil {
 		logrus.WithFields(logrus.Fields{
 			"error": err,
 		}).Fatal("Failed get sonar job status")
 	}
-	buf, _ := ioutil.ReadAll(taskResponse.Body)
+	buf, err := io.ReadAll(taskResponse.Body)
+	if err != nil {
+		logrus.WithFields(logrus.Fields{
+			"error": err,
+		}).Fatal("Failed to read sonar job status response body")
+	}
 	task := TaskResponse{}
+	fmt.Println("|----------------------------------------------------------------|")
+	fmt.Println("|  Report Result:                                                 |")
+	fmt.Println("|----------------------------------------------------------------|")
+	fmt.Print(string(buf))
+	fmt.Println("|----------------------------------------------------------------|")
 	json.Unmarshal(buf, &task)
 	return &task
 }
 
 func waitForSonarJob(report *SonarReport) (*TaskResponse, error) {
 	timeout := time.After(300 * time.Second)
 	tick := time.Tick(500 * time.Millisecond)
+	fmt.Println("Waiting for sonar job to finish...")
 	for {
 		select {
 		case <-timeout:
+			fmt.Println("Timed out waiting for sonar job to finish")
 			return nil, errors.New("timed out")
 		case <-tick:
+			fmt.Println("Checking sonar job status...")
 			job := getSonarJobStatus(report)
 			if job.Task.Status == "SUCCESS" {
+				fmt.Println("\033[32mSonar job finished successfully\033[0m")
 				return job, nil
 			}
 			if job.Task.Status == "ERROR" {
+				fmt.Println("Sonar job failed")
 				return nil, errors.New("ERROR")
 			}
 		}

plugin_test.go

@@ -1,27 +1,68 @@
 package main
 
 import (
-	"reflect"
+	"bytes"
+	"io/ioutil"
+	"net/http"
 	"testing"
 )
 
-func TestParseJunit(t *testing.T) {
-	type args struct {
-		projectArray Project
-		projectName  string
+// Custom RoundTripper for mocking HTTP client
+type roundTripFunc func(req *http.Request) *http.Response
+
+func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return f(req), nil
+}
+
+func getTask(projectSlug string) (string, error) {
+	// Define your implementation for unit test
+	return "sampleKey", nil
+}
+
+func TestGetTask(t *testing.T) {
+	httpClient := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) *http.Response {
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       ioutil.NopCloser(bytes.NewBufferString(`{"analyses":[{"key":"sampleKey"}]}`)),
+			}
+		}),
+	}
+	netClient = httpClient
+
+	key, err := getTask("projectSlug")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
 	}
-	tests := []struct {
-		name string
-		args args
-		want Testsuites
-	}{
-		// TODO: Add test cases.
+	if key != "sampleKey" {
+		t.Errorf("Expected sampleKey, got %v", key)
 	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := ParseJunit(tt.args.projectArray, tt.args.projectName); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("ParseJunit() = %v, want %v", got, tt.want)
+}
+
+// func getTask(s string) {
+// 	panic("unimplemented")
+// }
+
+// Test for Sonar Job Status function
+func TestGetSonarJobStatus(t *testing.T) {
+	httpClient := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) *http.Response {
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       ioutil.NopCloser(bytes.NewBufferString(`{"task":{"status":"SUCCESS"}}`)),
 			}
-		})
+		}),
+	}
+	netClient = httpClient
+
+	report := &SonarReport{CeTaskURL: "someURL"}
+	taskResponse := getSonarJobStatus(report)
+	if taskResponse.Task.Status != "SUCCESS" {
+		t.Errorf("Expected SUCCESS, got %v", taskResponse.Task.Status)
 	}
 }
+
+// Test for Wait for Sonar Job function
+// func TestWaitForSonarJob(t *testing.T) {
+// 	// Define your test logic here
+// }