Added tests

Author: alenon

Makefile

@@ -63,7 +63,7 @@ build-install:: build
 .PHONY: clean-mock
 clean-mock:
 	@echo Cleaning generated mock files
-	find . -path "*/mocks/*.go" -delete
+	@find . -name "*_mock.go" -delete
 
 .PHONY: generate-mock
 generate-mock: clean-mock

application/app/auth/app_details.go

@@ -0,0 +1,36 @@
+package app
+
+import (
+	mockservice "github.com/jfrog/jfrog-cli-application/application/service/mocks"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewAppContext(t *testing.T) {
+	ctx := NewAppContext()
+	assert.NotNil(t, ctx)
+	assert.NotNil(t, ctx.GetVersionService())
+	assert.NotNil(t, ctx.GetSystemService())
+}
+
+func TestGetVersionService(t *testing.T) {
+	mockVersionService := &mockservice.MockVersionService{}
+	ctx := &context{
+		versionService: mockVersionService,
+	}
+	assert.Equal(t, mockVersionService, ctx.GetVersionService())
+}
+
+func TestGetSystemService(t *testing.T) {
+	mockSystemService := &mockservice.MockSystemService{}
+	ctx := &context{
+		systemService: mockSystemService,
+	}
+	assert.Equal(t, mockSystemService, ctx.GetSystemService())
+}
+
+func TestGetConfig(t *testing.T) {
+	ctx := &context{}
+	assert.Nil(t, ctx.GetConfig())
+}

application/app/context_test.go

@@ -17,7 +17,11 @@ type pingCommand struct {
 }
 
 func (pc *pingCommand) Run() error {
-	ctx := &service.Context{ServerDetails: pc.serverDetails}
+	ctx, err := service.NewContext(*pc.serverDetails)
+	if err != nil {
+		return err
+	}
+
 	return pc.systemService.Ping(ctx)
 }
 

application/commands/system/ping_cmd.go

@@ -29,7 +29,11 @@ type createVersionSpec struct {
 }
 
 func (cv *createAppVersionCommand) Run() error {
-	ctx := &service.Context{ServerDetails: cv.serverDetails}
+	ctx, err := service.NewContext(*cv.serverDetails)
+	if err != nil {
+		return err
+	}
+
 	return cv.versionService.CreateAppVersion(ctx, cv.requestPayload)
 }
 

application/commands/version/create_app_version_cmd.go

@@ -21,7 +21,11 @@ type promoteAppVersionCommand struct {
 }
 
 func (pv *promoteAppVersionCommand) Run() error {
-	ctx := &service.Context{ServerDetails: pv.serverDetails}
+	ctx, err := service.NewContext(*pv.serverDetails)
+	if err != nil {
+		return err
+	}
+
 	return pv.versionService.PromoteAppVersion(ctx, pv.requestPayload)
 }
 

application/commands/version/promote_app_version_cmd.go

@@ -1,5 +1,7 @@
 package http
 
+//go:generate ${PROJECT_DIR}/scripts/mockgen.sh ${GOFILE}
+
 import (
 	"encoding/json"
 	"fmt"

application/http/http_client.go

@@ -1,7 +1,33 @@
 package service
 
-import coreConfig "github.com/jfrog/jfrog-cli-core/v2/utils/config"
+import (
+	"github.com/jfrog/jfrog-cli-application/application/http"
+	coreConfig "github.com/jfrog/jfrog-cli-core/v2/utils/config"
+)
 
-type Context struct {
-	ServerDetails *coreConfig.ServerDetails
+type Context interface {
+	GetServerDetails() coreConfig.ServerDetails
+	GetHttpClient() http.AppHttpClient
+}
+
+type context struct {
+	ServerDetails coreConfig.ServerDetails
+	HttpClient    http.AppHttpClient
+}
+
+func (c *context) GetServerDetails() coreConfig.ServerDetails {
+	return c.ServerDetails
+}
+
+func (c *context) GetHttpClient() http.AppHttpClient {
+	return c.HttpClient
+}
+
+func NewContext(serverDetails coreConfig.ServerDetails) (Context, error) {
+	httpClient, err := http.NewAppHttpClient(&serverDetails)
+	if err != nil {
+		return nil, err
+	}
+
+	return &context{ServerDetails: serverDetails, HttpClient: httpClient}, nil
 }

application/service/context.go

@@ -1,13 +1,13 @@
 package service
 
+//go:generate ${PROJECT_DIR}/scripts/mockgen.sh ${GOFILE}
+
 import (
 	"fmt"
-
-	"github.com/jfrog/jfrog-cli-application/application/http"
 )
 
 type SystemService interface {
-	Ping(ctx *Context) error
+	Ping(ctx Context) error
 }
 
 type systemService struct{}
@@ -16,13 +16,8 @@ func NewSystemService() SystemService {
 	return &systemService{}
 }
 
-func (ss *systemService) Ping(ctx *Context) error {
-	httpClient, err := http.NewAppHttpClient(ctx.ServerDetails)
-	if err != nil {
-		return err
-	}
-
-	response, body, err := httpClient.Get("/v1/system/ping")
+func (ss *systemService) Ping(ctx Context) error {
+	response, body, err := ctx.GetHttpClient().Get("/v1/system/ping")
 	if err != nil {
 		return err
 	}

application/service/system_service.go

@@ -0,0 +1,72 @@
+package service
+
+import (
+	"errors"
+	"github.com/jfrog/jfrog-cli-core/v2/utils/config"
+	"go.uber.org/mock/gomock"
+	"net/http"
+	"testing"
+
+	"github.com/jfrog/jfrog-cli-application/application/http/mocks"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSystemService_Ping(t *testing.T) {
+	tests := []struct {
+		name          string
+		mockResponse  *http.Response
+		mockBody      []byte
+		mockError     error
+		expectedError error
+	}{
+		{
+			name: "Ping successful",
+			mockResponse: &http.Response{
+				StatusCode: 200,
+			},
+			mockBody:      []byte("pong"),
+			mockError:     nil,
+			expectedError: nil,
+		},
+		{
+			name: "Ping failed with non-200 status code",
+			mockResponse: &http.Response{
+				StatusCode: 500,
+			},
+			mockBody:      []byte(""),
+			mockError:     nil,
+			expectedError: errors.New("failed to create app version. Status code: 500"),
+		},
+		{
+			name:          "Ping failed with error",
+			mockResponse:  nil,
+			mockBody:      nil,
+			mockError:     errors.New("http error"),
+			expectedError: errors.New("http error"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+
+			mockHttpClient := mock_http.NewMockAppHttpClient(ctrl)
+			mockHttpClient.EXPECT().Get("/v1/system/ping").
+				Return(tt.mockResponse, tt.mockBody, tt.mockError)
+
+			ctx := &Context{
+				ServerDetails: &config.ServerDetails{},
+			}
+
+			ss := NewSystemService()
+			err := ss.Ping(ctx)
+
+			if tt.expectedError != nil {
+				assert.EqualError(t, err, tt.expectedError.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}