jmeterUtils_test.go

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os/exec"
	"strings"
	"testing"

	apimodels "github.com/keptn/go-utils/pkg/api/models"
	keptncommon "github.com/keptn/go-utils/pkg/lib/keptn"
	keptnv2 "github.com/keptn/go-utils/pkg/lib/v0_2_0"
)

func Test_executeJMeter(t *testing.T) {

	localTmpDir := t.TempDir()
	var returnedStatus int
	var returnedResources apimodels.Resources
	myurl, _ := url.Parse("http://keptn.sh/test/")

	ts := httptest.NewServer(
		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.Header().Add("Content-Type", "application/json")
			if strings.HasSuffix(r.URL.Path, "/resource") || strings.HasSuffix(r.URL.Path, "/resource/") {
				marshal, _ := json.Marshal(returnedResources)
				w.Write(marshal)
				return
			}

			w.WriteHeader(returnedStatus)
			w.Write([]byte(`{
	"code": ` + fmt.Sprintf("%d", returnedStatus) + `,
	"message": ""
}`))
		}),
	)
	defer ts.Close()
	checkJmeter()
	t.Setenv("RESOURCE_SERVICE", ts.URL)
	t.Setenv("env", "production")

	type args struct {
		testInfo       TestInfo
		workload       *Workload
		resultsDir     string
		url            *url.URL
		LTN            string
		funcValidation bool
		logger         *keptncommon.Logger
	}
	tests := []struct {
		name              string
		args              args
		returnedStatus    int
		returnedResources []string
		want              bool
		wantErr           bool
	}{
		{
			name: "Skip tests if 404 is returned by configuration service and mark as success",
			args: args{
				testInfo: TestInfo{
					Project:      "sockshop",
					Stage:        "dev",
					Service:      "carts",
					TestStrategy: "functional",
					Context:      localTmpDir,
				},
				workload: &Workload{
					Script: "test.jmx",
				},
			},
			want:           true,
			wantErr:        false,
			returnedStatus: 404,
		},
		{
			name: "Skip tests if error code is returned by configuration service and return error",
			args: args{
				testInfo: TestInfo{
					Project:      "sockshop",
					Stage:        "dev",
					Service:      "carts",
					TestStrategy: "functional",
					Context:      localTmpDir,
				},
				workload: &Workload{
					Script: "test.jmx",
				},
			},
			want:           false,
			wantErr:        true,
			returnedStatus: 500,
		},
		{
			name: "Jmeter returns unparsable result",
			args: args{
				testInfo: TestInfo{
					Project:           "sockshop",
					Stage:             "dev",
					Service:           "carts",
					TestStrategy:      "functional",
					Context:           localTmpDir,
					TriggeredID:       "",
					CommitID:          "",
					TestTriggeredData: keptnv2.TestTriggeredEventData{},
					ServiceURL:        nil,
				},
				workload: &Workload{
					Script:    "test.jmx",
					VUser:     1,
					LoopCount: 1,
					ThinkTime: 10,
				},
				resultsDir:     localTmpDir,
				url:            myurl,
				LTN:            "",
				funcValidation: false,
				logger:         nil,
			},
			want:    false,
			wantErr: checkJmeter(),
			returnedResources: []string{`{
				"metadata": {
					"branch": "dev",
					"version": "de2037b85919406ea949bdfc3aa4bbbe6b0e1e61"
				},
				"resourceContent": "cHJvamVjdG5hbWU6IHBvdGF0bwpjcmVhdGlvbnRpbWVzdGFtcDogMjAyMi0wMy0zMCAxNToyMjo0MS4zMTIzNDE2NzYgKzAwMDAgVVRDIG09KzcxOTIuNDk5OTkxODIxCg==",
				"resourceURI": "test.jmx"
			}`,
			},
			returnedStatus: 200,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			returnedStatus = tt.returnedStatus

			returnedResources = apimodels.Resources{
				Resources: []*apimodels.Resource{},
			}

			for _, res := range tt.returnedResources {
				returnedResources.Resources = append(returnedResources.Resources, &apimodels.Resource{
					ResourceURI: &res,
				})
			}
			tmpDir := t.TempDir()
			got, err := executeJMeter(tt.args.testInfo, tt.args.workload, tmpDir, tt.args.url, tt.args.LTN, tt.args.funcValidation)
			if (err != nil) != tt.wantErr {
				t.Errorf("executeJMeter() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("executeJMeter() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func checkJmeter() bool {
	//check if jmeter command exists
	cmd := exec.Command("jmeter")
	_, err := cmd.CombinedOutput()
	if err != nil {
		return true
	}
	return false
}

func Test_derivePort(t *testing.T) {
	tests := []struct {
		name string
		url  string
		want string
	}{
		{"HTTP Address without port", "http://1.2.3.4", "80"},
		{"HTTP Address with port", "http://1.2.3.4:80", "80"},
		{"HTTP Address with different port", "http://1.2.3.4:1234", "1234"},
		{"HTTPS Address without port", "https://1.2.3.4", "443"},
		{"HTTPS Address with port", "https://1.2.3.4:443", "443"},
		{"HTTPS Address with different port", "http://1.2.3.4:1234", "1234"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			parsedURL, _ := url.Parse(tt.url)
			got := derivePort(parsedURL)
			if got != tt.want {
				t.Errorf("derivePort(%v) got = %v, want %v", tt.url, got, tt.want)
			}
		})
	}
}