chore: Creates mock generation infrastructure

.github/workflows/code-health.yml

@@ -16,22 +16,34 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
-    - name: Set up Go
-      uses: actions/setup-go@v5
+    - uses: actions/setup-go@v5
       with:
         go-version-file: 'go.mod'
+    - name: Install tools for mocks and linter
+      run: make tools
+    - name: Mock generation
+      run: mockery
+    - name: Check for uncommited files
+      run: |
+        export FILES=$(git ls-files -o -m --directory --exclude-standard --no-empty-directory)
+        export LINES=$(echo "$FILES" | awk 'NF' | wc -l)
+        if [ $LINES -ne 0 ]; then
+          echo "Detected files that need to be committed:"
+          echo "$FILES" | sed -e "s/^/  /"
+          echo ""
+          echo "Try running: mockery"
+          exit 1
+        fi
     - name: Build
       run: make build
+    - name: Linter
+      run: make lint
   unit-test:
     needs: build
     runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up Go
-        uses: actions/setup-go@v5
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
         with:
           go-version-file: 'go.mod'
       - name: Unit Test
@@ -56,28 +68,11 @@ jobs:
         with:
           recreate: true
           path: code-coverage-results.md
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Install Go
-        uses: actions/setup-go@v5
-        with:
-          go-version-file: 'go.mod'
-          cache: false # see https://github.com/golangci/golangci-lint-action/issues/807
-      - name: golangci-lint
-        uses: golangci/[email protected]
-        with:
-          version: v1.55.0
-          args: --timeout 10m
   website-lint:
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Install Go
-        uses: actions/setup-go@v5
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
         with:
           go-version-file: 'go.mod'
       - name: website lint
@@ -89,11 +84,11 @@ jobs:
       - name: Run ShellCheck
         uses: bewuethr/shellcheck-action@v2
   call-acceptance-tests-workflow:
-    needs: [build, lint, shellcheck, unit-test, website-lint]
+    needs: [build, shellcheck, unit-test, website-lint]
     secrets: inherit
     uses: ./.github/workflows/acceptance-tests.yml
   call-migration-tests-workflow:
-    needs: [build, lint, shellcheck, unit-test, website-lint]
+    needs: [build, shellcheck, unit-test, website-lint]
     secrets: inherit
     uses: ./.github/workflows/migration-tests.yml
 

.mockery.yaml

@@ -0,0 +1,11 @@
+with-expecter: false
+disable-version-string: true
+dir: internal/testutil/mocksvc
+outpkg: mocksvc
+filename: "{{ .InterfaceName | snakecase }}.go"
+mockname: "{{.InterfaceName}}"
+
+packages:
+  ? github.com/mongodb/terraform-provider-mongodbatlas/internal/service/searchdeployment
+  : interfaces:
+      DeploymentService:

GNUmakefile

@@ -14,6 +14,7 @@ VERSION=$(GITTAG:v%=%)
 LINKER_FLAGS=-s -w -X 'github.com/mongodb/terraform-provider-mongodbatlas/version.ProviderVersion=${VERSION}'
 
 GOLANGCI_VERSION=v1.55.0
+MOCKERY_VERSION=v2.38.0
 
 export PATH := $(shell go env GOPATH)/bin:$(PATH)
 export SHELL := env PATH=$(PATH) /bin/bash
@@ -64,7 +65,7 @@ lint-fix:
 .PHONY: lint
 lint:
 	@echo "==> Checking source code against linters..."
-	golangci-lint run
+	golangci-lint run --timeout 10m
 
 .PHONY: tools
 tools:  ## Install dev tools
@@ -74,7 +75,9 @@ tools:  ## Install dev tools
 	go install github.com/terraform-linters/[email protected]
 	go install github.com/rhysd/actionlint/cmd/actionlint@latest
 	go install golang.org/x/tools/go/analysis/passes/fieldalignment/cmd/fieldalignment@latest
+	go install github.com/vektra/mockery/v2@$(MOCKERY_VERSION)
 	curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(shell go env GOPATH)/bin $(GOLANGCI_VERSION)
+	@echo "==> Note for asdf users: you may want to run: asdf reshim golang"
 
 .PHONY: check
 check: test lint

internal/service/searchdeployment/state_transition_search_deployment_test.go

@@ -3,155 +3,126 @@ package searchdeployment_test
 import (
 	"context"
 	"errors"
-	"log"
 	"net/http"
-	"reflect"
 	"testing"
 	"time"
 
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/conversion"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/retrystrategy"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/searchdeployment"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/testutil/mocksvc"
+	"github.com/stretchr/testify/assert"
 	"go.mongodb.org/atlas-sdk/v20231115002/admin"
 )
 
-type stateTransitionTestCase struct {
-	expectedResult *admin.ApiSearchDeploymentResponse
-	name           string
-	mockResponses  []SearchDeploymentResponse
-	expectedError  bool
+var (
+	updating = "UPDATING"
+	idle     = "IDLE"
+	unknown  = ""
+	sc400    = conversion.IntPtr(400)
+	sc500    = conversion.IntPtr(500)
+	sc503    = conversion.IntPtr(503)
+)
+
+type testCase struct {
+	expectedState *string
+	name          string
+	mockResponses []response
+	expectedError bool
 }
 
 func TestSearchDeploymentStateTransition(t *testing.T) {
-	testCases := []stateTransitionTestCase{
+	testCases := []testCase{
 		{
 			name: "Successful transition to IDLE",
-			mockResponses: []SearchDeploymentResponse{
-				{
-					DeploymentResp: responseWithState("UPDATING"),
-				},
-				{
-					DeploymentResp: responseWithState("IDLE"),
-				},
+			mockResponses: []response{
+				{state: &updating},
+				{state: &idle},
 			},
-			expectedResult: responseWithState("IDLE"),
-			expectedError:  false,
+			expectedState: &idle,
+			expectedError: false,
 		},
 		{
 			name: "Successful transition to IDLE with 503 error in between",
-			mockResponses: []SearchDeploymentResponse{
-				{
-					DeploymentResp: responseWithState("UPDATING"),
-				},
-				{
-					DeploymentResp: nil,
-					HTTPResponse:   &http.Response{StatusCode: 503},
-					Err:            errors.New("Service Unavailable"),
-				},
-				{
-					DeploymentResp: responseWithState("IDLE"),
-				},
+			mockResponses: []response{
+				{state: &updating},
+				{statusCode: sc503, Err: errors.New("Service Unavailable")},
+				{state: &idle},
 			},
-			expectedResult: responseWithState("IDLE"),
-			expectedError:  false,
+			expectedState: &idle,
+			expectedError: false,
 		},
 		{
 			name: "Error when transitioning to an unknown state",
-			mockResponses: []SearchDeploymentResponse{
-				{
-					DeploymentResp: responseWithState("UPDATING"),
-				},
-				{
-					DeploymentResp: responseWithState(""),
-				},
+			mockResponses: []response{
+				{state: &updating},
+				{state: &unknown},
 			},
-			expectedResult: nil,
-			expectedError:  true,
+			expectedState: nil,
+			expectedError: true,
 		},
 		{
 			name: "Error when API responds with error",
-			mockResponses: []SearchDeploymentResponse{
-				{
-					DeploymentResp: nil,
-					HTTPResponse:   &http.Response{StatusCode: 500},
-					Err:            errors.New("Internal server error"),
-				},
+			mockResponses: []response{
+				{statusCode: sc500, Err: errors.New("Internal server error")},
 			},
-			expectedResult: nil,
-			expectedError:  true,
+			expectedState: nil,
+			expectedError: true,
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			mockService := MockSearchDeploymentService{
-				MockResponses: tc.mockResponses,
-			}
-
-			resp, err := searchdeployment.WaitSearchNodeStateTransition(context.Background(), dummyProjectID, "Cluster0", &mockService, testTimeoutConfig)
-
-			if (err != nil) != tc.expectedError {
-				t.Errorf("Case %s: Received unexpected error: %v", tc.name, err)
-			}
-
-			if !reflect.DeepEqual(tc.expectedResult, resp) {
-				t.Errorf("Case %s: Response did not match expected output", tc.name)
+			svc := mocksvc.NewDeploymentService(t)
+			ctx := context.Background()
+			for _, resp := range tc.mockResponses {
+				svc.On("GetAtlasSearchDeployment", ctx, dummyProjectID, clusterName).Return(resp.get()...).Once()
 			}
+			resp, err := searchdeployment.WaitSearchNodeStateTransition(ctx, dummyProjectID, "Cluster0", svc, testTimeoutConfig)
+			assert.Equal(t, tc.expectedError, err != nil)
+			assert.Equal(t, responseWithState(tc.expectedState), resp)
+			svc.AssertExpectations(t)
 		})
 	}
 }
 
 func TestSearchDeploymentStateTransitionForDelete(t *testing.T) {
-	testCases := []stateTransitionTestCase{
+	testCases := []testCase{
 		{
 			name: "Regular transition to DELETED",
-			mockResponses: []SearchDeploymentResponse{
-				{
-					DeploymentResp: responseWithState("UPDATING"),
-				},
-				{
-					DeploymentResp: nil,
-					HTTPResponse:   &http.Response{StatusCode: 400},
-					Err:            errors.New(searchdeployment.SearchDeploymentDoesNotExistsError),
-				},
+			mockResponses: []response{
+				{state: &updating},
+				{statusCode: sc400, Err: errors.New(searchdeployment.SearchDeploymentDoesNotExistsError)},
 			},
 			expectedError: false,
 		},
 		{
 			name: "Error when API responds with error",
-			mockResponses: []SearchDeploymentResponse{
-				{
-					DeploymentResp: nil,
-					HTTPResponse:   &http.Response{StatusCode: 500},
-					Err:            errors.New("Internal server error"),
-				},
+			mockResponses: []response{
+				{statusCode: sc500, Err: errors.New("Internal server error")},
 			},
 			expectedError: true,
 		},
 		{
 			name: "Failed delete when responding with unknown state",
-			mockResponses: []SearchDeploymentResponse{
-				{
-					DeploymentResp: responseWithState("UPDATING"),
-				},
-				{
-					DeploymentResp: responseWithState(""),
-				},
+			mockResponses: []response{
+				{state: &updating},
+				{state: &unknown},
 			},
 			expectedError: true,
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			mockService := MockSearchDeploymentService{
-				MockResponses: tc.mockResponses,
-			}
-
-			err := searchdeployment.WaitSearchNodeDelete(context.Background(), dummyProjectID, clusterName, &mockService, testTimeoutConfig)
-
-			if (err != nil) != tc.expectedError {
-				t.Errorf("Case %s: Received unexpected error: %v", tc.name, err)
+			svc := mocksvc.NewDeploymentService(t)
+			ctx := context.Background()
+			for _, resp := range tc.mockResponses {
+				svc.On("GetAtlasSearchDeployment", ctx, dummyProjectID, clusterName).Return(resp.get()...).Once()
 			}
+			err := searchdeployment.WaitSearchNodeDelete(ctx, dummyProjectID, clusterName, svc, testTimeoutConfig)
+			assert.Equal(t, tc.expectedError, err != nil)
+			svc.AssertExpectations(t)
 		})
 	}
 }
@@ -162,7 +133,10 @@ var testTimeoutConfig = retrystrategy.TimeConfig{
 	Delay:      0,
 }
 
-func responseWithState(state string) *admin.ApiSearchDeploymentResponse {
+func responseWithState(state *string) *admin.ApiSearchDeploymentResponse {
+	if state == nil {
+		return nil
+	}
 	return &admin.ApiSearchDeploymentResponse{
 		GroupId: admin.PtrString(dummyProjectID),
 		Id:      admin.PtrString(dummyDeploymentID),
@@ -172,26 +146,20 @@ func responseWithState(state string) *admin.ApiSearchDeploymentResponse {
 				NodeCount:    nodeCount,
 			},
 		},
-		StateName: admin.PtrString(state),
+		StateName: state,
 	}
 }
 
-type MockSearchDeploymentService struct {
-	MockResponses []SearchDeploymentResponse
-	index         int
+type response struct {
+	state      *string
+	statusCode *int
+	Err        error
 }
 
-func (a *MockSearchDeploymentService) GetAtlasSearchDeployment(ctx context.Context, groupID, clusterName string) (*admin.ApiSearchDeploymentResponse, *http.Response, error) {
-	if a.index >= len(a.MockResponses) {
-		log.Fatal(errors.New("no more mocked responses available"))
+func (r *response) get() []interface{} {
+	var httpResp *http.Response
+	if r.statusCode != nil {
+		httpResp = &http.Response{StatusCode: *r.statusCode}
 	}
-	resp := a.MockResponses[a.index]
-	a.index++
-	return resp.DeploymentResp, resp.HTTPResponse, resp.Err
-}
-
-type SearchDeploymentResponse struct {
-	DeploymentResp *admin.ApiSearchDeploymentResponse
-	HTTPResponse   *http.Response
-	Err            error
+	return []interface{}{responseWithState(r.state), httpResp, r.Err}
 }