Add Filtering, HealthCheck, Better Tests (#350)

feat: add filtering when choosing merge requests (#346)
feat: Add healthcheck (#345)
refactor: Move to gomock (#349)
feat: Makes the remote of the plugin configurable (#348)

This is a #MINOR release.

cmd/approve.go

@@ -6,7 +6,7 @@ import (
 )
 
 /* approveHandler approves a merge request. */
-func (a *api) approveHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) approveHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodPost {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodPost)

cmd/approve_test.go

@@ -1,52 +1,59 @@
 package main
 
 import (
-	"errors"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
 )
 
-func approveMergeRequest(pid interface{}, mr int, opt *gitlab.ApproveMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error) {
-	return &gitlab.MergeRequestApprovals{}, makeResponse(http.StatusOK), nil
-}
-
-func approveMergeRequestNon200(pid interface{}, mr int, opt *gitlab.ApproveMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error) {
-	return &gitlab.MergeRequestApprovals{}, makeResponse(http.StatusSeeOther), nil
-}
-
-func approveMergeRequestErr(pid interface{}, mr int, opt *gitlab.ApproveMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error) {
-	return &gitlab.MergeRequestApprovals{}, nil, errors.New("Some error from Gitlab")
-}
-
 func TestApproveHandler(t *testing.T) {
 	t.Run("Approves merge request", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ApproveMergeRequest("", mock_main.MergeId, nil, nil).Return(&gitlab.MergeRequestApprovals{}, makeResponse(http.StatusOK), nil)
+
 		request := makeRequest(t, http.MethodPost, "/mr/approve", nil)
-		server, _ := createRouterAndApi(fakeClient{approveMergeRequest: approveMergeRequest})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, SuccessResponse{})
+
 		assert(t, data.Message, "Approved MR")
 		assert(t, data.Status, http.StatusOK)
 	})
 
 	t.Run("Disallows non-POST method", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ApproveMergeRequest("", mock_main.MergeId, nil, nil).Return(&gitlab.MergeRequestApprovals{}, makeResponse(http.StatusOK), nil)
+
 		request := makeRequest(t, http.MethodPut, "/mr/approve", nil)
-		server, _ := createRouterAndApi(fakeClient{approveMergeRequest: approveMergeRequest})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkBadMethod(t, *data, http.MethodPost)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ApproveMergeRequest("", mock_main.MergeId, nil, nil).Return(nil, nil, errorFromGitlab)
+
 		request := makeRequest(t, http.MethodPost, "/mr/approve", nil)
-		server, _ := createRouterAndApi(fakeClient{approveMergeRequest: approveMergeRequestErr})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkErrorFromGitlab(t, *data, "Could not approve merge request")
 	})
 
 	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ApproveMergeRequest("", mock_main.MergeId, nil, nil).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
 		request := makeRequest(t, http.MethodPost, "/mr/approve", nil)
-		server, _ := createRouterAndApi(fakeClient{approveMergeRequest: approveMergeRequestNon200})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkNon200(t, *data, "Could not approve merge request", "/mr/approve")
 	})
 }

cmd/assignee.go

@@ -23,7 +23,7 @@ type AssigneesRequestResponse struct {
 }
 
 /* assigneesHandler adds or removes assignees from a merge request. */
-func (a *api) assigneesHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) assigneesHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodPut {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodPut)

cmd/assignee_test.go

@@ -1,56 +1,67 @@
 package main
 
 import (
-	"errors"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
+	"go.uber.org/mock/gomock"
 )
 
-func updateAssignees(pid interface{}, mergeRequest int, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return &gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil
-}
-
-func updateAssigneesNon200(pid interface{}, mergeRequest int, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
-}
-
-func updateAssigneesErr(pid interface{}, mergeRequest int, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
+var updatePayload = AssigneeUpdateRequest{Ids: []int{1, 2}}
 
 func TestAssigneeHandler(t *testing.T) {
 	t.Run("Updates assignees", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPut, "/mr/assignee", AssigneeUpdateRequest{Ids: []int{1, 2}})
-		server, _ := createRouterAndApi(fakeClient{updateMergeRequest: updateAssignees})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().UpdateMergeRequest("", mock_main.MergeId, gomock.Any()).Return(&gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPut, "/mr/assignee", updatePayload)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, AssigneeUpdateResponse{})
+
 		assert(t, data.SuccessResponse.Message, "Assignees updated")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Disallows non-PUT method", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().UpdateMergeRequest("", mock_main.MergeId, gomock.Any()).Return(&gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil)
+
 		request := makeRequest(t, http.MethodPost, "/mr/assignee", nil)
-		server, _ := createRouterAndApi(fakeClient{updateMergeRequest: updateAssignees})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Status, http.StatusMethodNotAllowed)
 		assert(t, data.Details, "Invalid request type")
 		assert(t, data.Message, "Expected PUT")
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPut, "/mr/assignee", AssigneeUpdateRequest{Ids: []int{1, 2}})
-		server, _ := createRouterAndApi(fakeClient{updateMergeRequest: updateAssigneesErr})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().UpdateMergeRequest("", mock_main.MergeId, gomock.Any()).Return(nil, nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodPut, "/mr/assignee", updatePayload)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Status, http.StatusInternalServerError)
 		assert(t, data.Message, "Could not modify merge request assignees")
 		assert(t, data.Details, "Some error from Gitlab")
 	})
 
 	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPut, "/mr/assignee", AssigneeUpdateRequest{Ids: []int{1, 2}})
-		server, _ := createRouterAndApi(fakeClient{updateMergeRequest: updateAssigneesNon200})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().UpdateMergeRequest("", mock_main.MergeId, gomock.Any()).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodPut, "/mr/assignee", updatePayload)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Status, http.StatusSeeOther)
 		assert(t, data.Message, "Could not modify merge request assignees")
 		assert(t, data.Details, "An error occurred on the /mr/assignee endpoint")

cmd/attachment.go

@@ -46,7 +46,7 @@ func (ar attachmentReader) ReadFile(path string) (io.Reader, error) {
 }
 
 /* attachmentHandler uploads an attachment (file, image, etc) to Gitlab and returns metadata about the upload. */
-func (a *api) attachmentHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) attachmentHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodPost {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodPost)

cmd/attachment_test.go

@@ -2,64 +2,67 @@ package main
 
 import (
 	"bytes"
-	"errors"
-	"io"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
 )
 
-type MockAttachmentReader struct{}
-
-func (mf MockAttachmentReader) ReadFile(path string) (io.Reader, error) {
-	return bytes.NewReader([]byte{}), nil
-}
-
-func uploadFile(pid interface{}, content io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectFile, *gitlab.Response, error) {
-	return &gitlab.ProjectFile{}, makeResponse(http.StatusOK), nil
-}
-
-func uploadFileNon200(pid interface{}, content io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectFile, *gitlab.Response, error) {
-	return &gitlab.ProjectFile{}, makeResponse(http.StatusSeeOther), nil
-}
-
-func uploadFileErr(pid interface{}, content io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectFile, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
-func withMockFileReader(a *api) error {
-	reader := MockAttachmentReader{}
+func withMockFileReader(a *Api) error {
+	reader := mock_main.MockAttachmentReader{}
 	a.fileReader = reader
 	return nil
 }
 
+var reader = bytes.NewReader([]byte{})
+var attachmentTestRequestData = AttachmentRequest{
+	FileName: "some_file_name",
+	FilePath: "some_file_path",
+}
+
 func TestAttachmentHandler(t *testing.T) {
 	t.Run("Returns 200-status response after upload", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/attachment", AttachmentRequest{FilePath: "some_file_path", FileName: "some_file_name"})
-		router, _ := createRouterAndApi(fakeClient{uploadFile: uploadFile}, withMockFileReader)
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().UploadFile("", reader, attachmentTestRequestData.FileName).Return(&gitlab.ProjectFile{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, "/attachment", attachmentTestRequestData)
+		router, _ := CreateRouterAndApi(client, withMockFileReader)
 		data := serveRequest(t, router, request, AttachmentResponse{})
+
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 		assert(t, data.SuccessResponse.Message, "File uploaded successfully")
 	})
 
 	t.Run("Disallows non-POST method", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPut, "/attachment", AttachmentRequest{FilePath: "some_file_path", FileName: "some_file_name"})
-		router, _ := createRouterAndApi(fakeClient{uploadFile: uploadFile}, withMockFileReader)
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().UploadFile("", reader, attachmentTestRequestData.FileName).Return(&gitlab.ProjectFile{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPut, "/attachment", attachmentTestRequestData)
+		router, _ := CreateRouterAndApi(client, withMockFileReader)
 		data := serveRequest(t, router, request, ErrorResponse{})
+
 		checkBadMethod(t, *data, http.MethodPost)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/attachment", AttachmentRequest{FilePath: "some_file_path", FileName: "some_file_name"})
-		router, _ := createRouterAndApi(fakeClient{uploadFile: uploadFileErr}, withMockFileReader)
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().UploadFile("", reader, attachmentTestRequestData.FileName).Return(nil, nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodPost, "/attachment", attachmentTestRequestData)
+		router, _ := CreateRouterAndApi(client, withMockFileReader)
+
 		data := serveRequest(t, router, request, ErrorResponse{})
 		checkErrorFromGitlab(t, *data, "Could not upload some_file_name to Gitlab")
 	})
 
 	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/attachment", AttachmentRequest{FilePath: "some_file_path", FileName: "some_file_name"})
-		router, _ := createRouterAndApi(fakeClient{uploadFile: uploadFileNon200}, withMockFileReader)
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().UploadFile("", reader, attachmentTestRequestData.FileName).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodPost, "/attachment", attachmentTestRequestData)
+		router, _ := CreateRouterAndApi(client, withMockFileReader)
+
 		data := serveRequest(t, router, request, ErrorResponse{})
 		checkNon200(t, *data, "Could not upload some_file_name to Gitlab", "/attachment")
 	})

cmd/client.go

@@ -14,15 +14,6 @@ import (
 	"github.com/xanzy/go-gitlab"
 )
 
-type DebugSettings struct {
-	GoRequest  bool `json:"go_request"`
-	GoResponse bool `json:"go_response"`
-}
-
-type ConnectionOptions struct {
-	Insecure bool `json:"insecure"`
-}
-
 type ProjectInfo struct {
 	ProjectId string
 	MergeId   int
@@ -46,53 +37,27 @@ type Client struct {
 /* initGitlabClient parses and validates the project settings and initializes the Gitlab client. */
 func initGitlabClient() (error, *Client) {
 
-	if len(os.Args) < 7 {
-		return errors.New("Must provide gitlab url, port, auth token, debug settings, log path, and connection settings"), nil
-	}
-
-	gitlabInstance := os.Args[1]
-	if gitlabInstance == "" {
+	if pluginOptions.GitlabUrl == "" {
 		return errors.New("GitLab instance URL cannot be empty"), nil
 	}
 
-	authToken := os.Args[3]
-	if authToken == "" {
-		return errors.New("Auth token cannot be empty"), nil
-	}
-
-	/* Parse debug settings and initialize logger handlers */
-	debugSettings := os.Args[4]
-	var debugObject DebugSettings
-	err := json.Unmarshal([]byte(debugSettings), &debugObject)
-	if err != nil {
-		return fmt.Errorf("Could not parse debug settings: %w, %s", err, debugSettings), nil
-	}
-
-	/* Parse connection options */
-	connectionSettings := os.Args[6]
-	var connectionObject ConnectionOptions
-	err = json.Unmarshal([]byte(connectionSettings), &connectionObject)
-	if err != nil {
-		return fmt.Errorf("Could not parse connection settings: %w, %s", err, connectionSettings), nil
-	}
-
-	var apiCustUrl = fmt.Sprintf(gitlabInstance + "/api/v4")
+	var apiCustUrl = fmt.Sprintf(pluginOptions.GitlabUrl + "/api/v4")
 
 	gitlabOptions := []gitlab.ClientOptionFunc{
 		gitlab.WithBaseURL(apiCustUrl),
 	}
 
-	if debugObject.GoRequest {
+	if pluginOptions.Debug.Request {
 		gitlabOptions = append(gitlabOptions, gitlab.WithRequestLogHook(requestLogger))
 	}
 
-	if debugObject.GoResponse {
+	if pluginOptions.Debug.Response {
 		gitlabOptions = append(gitlabOptions, gitlab.WithResponseLogHook(responseLogger))
 	}
 
 	tr := &http.Transport{
 		TLSClientConfig: &tls.Config{
-			InsecureSkipVerify: connectionObject.Insecure,
+			InsecureSkipVerify: pluginOptions.ConnectionSettings.Insecure,
 		},
 	}
 
@@ -100,7 +65,7 @@ func initGitlabClient() (error, *Client) {
 	retryClient.HTTPClient.Transport = tr
 	gitlabOptions = append(gitlabOptions, gitlab.WithHTTPClient(retryClient.HTTPClient))
 
-	client, err := gitlab.NewClient(authToken, gitlabOptions...)
+	client, err := gitlab.NewClient(pluginOptions.AuthToken, gitlabOptions...)
 
 	if err != nil {
 		return fmt.Errorf("Failed to create client: %v", err), nil
@@ -130,12 +95,9 @@ func initProjectSettings(c *Client, gitInfo GitProjectInfo) (error, *ProjectInfo
 	if err != nil {
 		return fmt.Errorf(fmt.Sprintf("Error getting project at %s", gitInfo.RemoteUrl), err), nil
 	}
-	if project == nil {
-		return fmt.Errorf(fmt.Sprintf("Could not find project at %s", gitInfo.RemoteUrl), err), nil
-	}
 
 	if project == nil {
-		return fmt.Errorf("No projects you are a member of contained remote URL %s", gitInfo.RemoteUrl), nil
+		return fmt.Errorf(fmt.Sprintf("Could not find project at %s", gitInfo.RemoteUrl), err), nil
 	}
 
 	projectId := fmt.Sprint(project.ID)
@@ -195,15 +157,14 @@ var responseLogger retryablehttp.ResponseLogHook = func(l retryablehttp.Logger,
 }
 
 func openLogFile() *os.File {
-	logFile := os.Args[5]
-	file, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	file, err := os.OpenFile(pluginOptions.LogPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
 		if os.IsNotExist(err) {
-			log.Printf("Log file %s does not exist", logFile)
+			log.Printf("Log file %s does not exist", pluginOptions.LogPath)
 		} else if os.IsPermission(err) {
-			log.Printf("Permission denied for log file %s", logFile)
+			log.Printf("Permission denied for log file %s", pluginOptions.LogPath)
 		} else {
-			log.Printf("Error opening log file %s: %v", logFile, err)
+			log.Printf("Error opening log file %s: %v", pluginOptions.LogPath, err)
 		}
 
 		os.Exit(1)

cmd/comment.go

@@ -42,7 +42,7 @@ func (comment CommentWithPosition) GetPositionData() PositionData {
 }
 
 /* commentHandler creates, edits, and deletes discussions (comments, multi-line comments) */
-func (a *api) commentHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) commentHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	switch r.Method {
 	case http.MethodPost:
@@ -58,7 +58,7 @@ func (a *api) commentHandler(w http.ResponseWriter, r *http.Request) {
 }
 
 /* deleteComment deletes a note, multiline comment, or comment, which are all considered discussion notes. */
-func (a *api) deleteComment(w http.ResponseWriter, r *http.Request) {
+func (a *Api) deleteComment(w http.ResponseWriter, r *http.Request) {
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		handleError(w, err, "Could not read request body", http.StatusBadRequest)
@@ -99,7 +99,7 @@ func (a *api) deleteComment(w http.ResponseWriter, r *http.Request) {
 }
 
 /* postComment creates a note, multiline comment, or comment. */
-func (a *api) postComment(w http.ResponseWriter, r *http.Request) {
+func (a *Api) postComment(w http.ResponseWriter, r *http.Request) {
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		handleError(w, err, "Could not read request body", http.StatusBadRequest)
@@ -156,7 +156,7 @@ func (a *api) postComment(w http.ResponseWriter, r *http.Request) {
 }
 
 /* editComment changes the text of a comment or changes it's resolved status. */
-func (a *api) editComment(w http.ResponseWriter, r *http.Request) {
+func (a *Api) editComment(w http.ResponseWriter, r *http.Request) {
 	body, err := io.ReadAll(r.Body)
 
 	if err != nil {

cmd/comment_test.go

@@ -6,139 +6,176 @@ import (
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
+	"go.uber.org/mock/gomock"
 )
 
-func createMergeRequestDiscussion(pid interface{}, mergeRequest int, opt *gitlab.CreateMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
-	return &gitlab.Discussion{Notes: []*gitlab.Note{{}}}, makeResponse(http.StatusOK), nil
+var testCommentCreationData = PostCommentRequest{
+	Comment: "Some comment",
 }
 
-func createMergeRequestDiscussionNon200(pid interface{}, mergeRequest int, opt *gitlab.CreateMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
+var testCommentDeletionData = DeleteCommentRequest{
+	NoteId:       3,
+	DiscussionId: "abc123",
 }
 
-func createMergeRequestDiscussionErr(pid interface{}, mergeRequest int, opt *gitlab.CreateMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
+var testEditCommentData = EditCommentRequest{
+	Comment:      "Some comment",
+	NoteId:       3,
+	DiscussionId: "abc123",
 }
 
 func TestPostComment(t *testing.T) {
 	t.Run("Creates a new note (unlinked comment)", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/comment", PostCommentRequest{})
-		server, _ := createRouterAndApi(fakeClient{createMergeRequestDiscussion: createMergeRequestDiscussion})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().CreateMergeRequestDiscussion(
+			"",
+			mock_main.MergeId,
+			gomock.Any(),
+		).Return(&gitlab.Discussion{Notes: []*gitlab.Note{{}}}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, "/mr/comment", testCommentCreationData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, CommentResponse{})
+
 		assert(t, data.SuccessResponse.Message, "Comment created successfully")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Creates a new comment", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/comment", PostCommentRequest{
+		// Re-create comment creation data to avoid mutating this variable in other tests
+		testCommentCreationData := PostCommentRequest{
+			Comment: "Some comment",
 			PositionData: PositionData{
-				FileName: "some_file.txt",
+				FileName: "file.txt",
 			},
-		})
-		server, _ := createRouterAndApi(fakeClient{createMergeRequestDiscussion: createMergeRequestDiscussion})
-		data := serveRequest(t, server, request, CommentResponse{})
-		assert(t, data.SuccessResponse.Message, "Comment created successfully")
-		assert(t, data.SuccessResponse.Status, http.StatusOK)
-	})
+		}
 
-	t.Run("Creates a new multiline comment", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/comment", PostCommentRequest{
-			PositionData: PositionData{
-				FileName: "some_file.txt",
-				LineRange: &LineRange{
-					StartRange: &LinePosition{}, /* These would have real data */
-					EndRange:   &LinePosition{},
-				},
-			},
-		})
-		server, _ := createRouterAndApi(fakeClient{createMergeRequestDiscussion: createMergeRequestDiscussion})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().CreateMergeRequestDiscussion(
+			"",
+			mock_main.MergeId,
+			gomock.Any(),
+		).Return(&gitlab.Discussion{Notes: []*gitlab.Note{{}}}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, "/mr/comment", testCommentCreationData)
+
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, CommentResponse{})
 		assert(t, data.SuccessResponse.Message, "Comment created successfully")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/comment", PostCommentRequest{})
-		server, _ := createRouterAndApi(fakeClient{createMergeRequestDiscussion: createMergeRequestDiscussionErr})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().CreateMergeRequestDiscussion(
+			"",
+			mock_main.MergeId,
+			gomock.Any(),
+		).Return(nil, nil, errors.New("Some error from Gitlab"))
+
+		request := makeRequest(t, http.MethodPost, "/mr/comment", testCommentCreationData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkErrorFromGitlab(t, *data, "Could not create discussion")
 	})
 
 	t.Run("Handles non-200s from Gitlab", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/comment", PostCommentRequest{})
-		server, _ := createRouterAndApi(fakeClient{createMergeRequestDiscussion: createMergeRequestDiscussionNon200})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().CreateMergeRequestDiscussion(
+			"",
+			mock_main.MergeId,
+			gomock.Any(),
+		).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodPost, "/mr/comment", testCommentCreationData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkNon200(t, *data, "Could not create discussion", "/mr/comment")
 	})
 }
 
-func deleteMergeRequestDiscussionNote(pid interface{}, mergeRequest int, discussion string, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return makeResponse(http.StatusOK), nil
-}
-
-func deleteMergeRequestDiscussionNoteErr(pid interface{}, mergeRequest int, discussion string, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return nil, errors.New("Some error from Gitlab")
-}
-
-func deleteMergeRequestDiscussionNoteNon200(pid interface{}, mergeRequest int, discussion string, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return makeResponse(http.StatusSeeOther), nil
-}
-
 func TestDeleteComment(t *testing.T) {
 	t.Run("Deletes a comment", func(t *testing.T) {
-		request := makeRequest(t, http.MethodDelete, "/mr/comment", DeleteCommentRequest{})
-		server, _ := createRouterAndApi(fakeClient{deleteMergeRequestDiscussionNote: deleteMergeRequestDiscussionNote})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().DeleteMergeRequestDiscussionNote("", mock_main.MergeId, testCommentDeletionData.DiscussionId, testCommentDeletionData.NoteId).Return(makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodDelete, "/mr/comment", testCommentDeletionData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, CommentResponse{})
+
 		assert(t, data.SuccessResponse.Message, "Comment deleted successfully")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodDelete, "/mr/comment", DeleteCommentRequest{})
-		server, _ := createRouterAndApi(fakeClient{deleteMergeRequestDiscussionNote: deleteMergeRequestDiscussionNoteErr})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().DeleteMergeRequestDiscussionNote("", mock_main.MergeId, testCommentDeletionData.DiscussionId, testCommentDeletionData.NoteId).Return(nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodDelete, "/mr/comment", testCommentDeletionData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkErrorFromGitlab(t, *data, "Could not delete comment")
 	})
 
 	t.Run("Handles non-200s from Gitlab", func(t *testing.T) {
-		request := makeRequest(t, http.MethodDelete, "/mr/comment", DeleteCommentRequest{})
-		server, _ := createRouterAndApi(fakeClient{deleteMergeRequestDiscussionNote: deleteMergeRequestDiscussionNoteNon200})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().DeleteMergeRequestDiscussionNote("", mock_main.MergeId, testCommentDeletionData.DiscussionId, testCommentDeletionData.NoteId).Return(makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodDelete, "/mr/comment", testCommentDeletionData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkNon200(t, *data, "Could not delete comment", "/mr/comment")
 	})
 }
 
-func updateMergeRequestDiscussionNote(pid interface{}, mergeRequest int, discussion string, note int, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
-	return &gitlab.Note{}, makeResponse(http.StatusOK), nil
-}
-
-func updateMergeRequestDiscussionNoteErr(pid interface{}, mergeRequest int, discussion string, note int, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
-func updateMergeRequestDiscussionNoteNon200(pid interface{}, mergeRequest int, discussion string, note int, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
-}
-
 func TestEditComment(t *testing.T) {
 	t.Run("Edits a comment", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPatch, "/mr/comment", EditCommentRequest{})
-		server, _ := createRouterAndApi(fakeClient{updateMergeRequestDiscussionNote: updateMergeRequestDiscussionNote})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		opts := gitlab.UpdateMergeRequestDiscussionNoteOptions{
+			Body: gitlab.Ptr(testEditCommentData.Comment),
+		}
+		client.EXPECT().UpdateMergeRequestDiscussionNote("", mock_main.MergeId, testEditCommentData.DiscussionId, testEditCommentData.NoteId, &opts).Return(&gitlab.Note{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPatch, "/mr/comment", testEditCommentData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, CommentResponse{})
+
 		assert(t, data.SuccessResponse.Message, "Comment updated successfully")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPatch, "/mr/comment", EditCommentRequest{})
-		server, _ := createRouterAndApi(fakeClient{updateMergeRequestDiscussionNote: updateMergeRequestDiscussionNoteErr})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().UpdateMergeRequestDiscussionNote("", mock_main.MergeId, testEditCommentData.DiscussionId, testEditCommentData.NoteId, gomock.Any()).Return(nil, nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodPatch, "/mr/comment", testEditCommentData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkErrorFromGitlab(t, *data, "Could not update comment")
 	})
 
 	t.Run("Handles non-200s from Gitlab", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPatch, "/mr/comment", EditCommentRequest{})
-		server, _ := createRouterAndApi(fakeClient{updateMergeRequestDiscussionNote: updateMergeRequestDiscussionNoteNon200})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().UpdateMergeRequestDiscussionNote("", mock_main.MergeId, testEditCommentData.DiscussionId, testEditCommentData.NoteId, gomock.Any()).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodPatch, "/mr/comment", testEditCommentData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkNon200(t, *data, "Could not update comment", "/mr/comment")
 	})

cmd/create_mr.go

@@ -20,7 +20,7 @@ type CreateMrRequest struct {
 }
 
 /* createMr creates a merge request */
-func (a *api) createMr(w http.ResponseWriter, r *http.Request) {
+func (a *Api) createMr(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("Access-Control-Allow-Methods", http.MethodGet)
 	if r.Method != http.MethodPost {

cmd/create_mr_test.go

@@ -1,105 +1,97 @@
 package main
 
 import (
-	"errors"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
+	"go.uber.org/mock/gomock"
 )
 
-func createMrFn(pid interface{}, opt *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return &gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil
-}
-
-func createMrFnErr(pid interface{}, opt *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
-func createMrFnNon200(pid interface{}, opt *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
+var testCreateMrRequestData = CreateMrRequest{
+	Title:        "Some title",
+	Description:  "Some description",
+	TargetBranch: "main",
+	DeleteBranch: false,
+	Squash:       false,
 }
 
 func TestCreateMr(t *testing.T) {
 	t.Run("Creates an MR", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().CreateMergeRequest("", gomock.Any()).Return(&gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil)
 
-		body := CreateMrRequest{
-			Title:        "Some title",
-			Description:  "Some description",
-			TargetBranch: "main",
-			DeleteBranch: false,
-			Squash:       false,
-		}
+		request := makeRequest(t, http.MethodPost, "/create_mr", testCreateMrRequestData)
+		server, _ := CreateRouterAndApi(client)
 
-		request := makeRequest(t, http.MethodPost, "/create_mr", body)
-		server, _ := createRouterAndApi(fakeClient{createMrFn: createMrFn})
 		data := serveRequest(t, server, request, SuccessResponse{})
 		assert(t, data.Message, "MR 'Some title' created")
 		assert(t, data.Status, http.StatusOK)
 	})
 
 	t.Run("Disallows non-POST methods", func(t *testing.T) {
-		request := makeRequest(t, http.MethodGet, "/create_mr", CreateMrRequest{})
-		server, _ := createRouterAndApi(fakeClient{createMrFn: createMrFn})
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().CreateMergeRequest("", gomock.Any()).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodPatch, "/create_mr", testCreateMrRequestData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkBadMethod(t, *data, http.MethodPost)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
-		body := CreateMrRequest{
-			Title:        "Some title",
-			Description:  "Some description",
-			TargetBranch: "main",
-			DeleteBranch: false,
-			Squash:       false,
-		}
-		request := makeRequest(t, http.MethodPost, "/create_mr", body)
-		server, _ := createRouterAndApi(fakeClient{createMrFn: createMrFnErr})
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().CreateMergeRequest("", gomock.Any()).Return(nil, nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodPost, "/create_mr", testCreateMrRequestData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkErrorFromGitlab(t, *data, "Could not create MR")
 	})
 
 	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
-		body := CreateMrRequest{
-			Title:        "Some title",
-			Description:  "Some description",
-			TargetBranch: "main",
-			DeleteBranch: false,
-			Squash:       false,
-		}
-		request := makeRequest(t, http.MethodPost, "/create_mr", body)
-		server, _ := createRouterAndApi(fakeClient{createMrFn: createMrFnNon200})
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().CreateMergeRequest("", gomock.Any()).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodPost, "/create_mr", testCreateMrRequestData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkNon200(t, *data, "Could not create MR", "/create_mr")
 	})
 
 	t.Run("Handles missing titles", func(t *testing.T) {
-		body := CreateMrRequest{
-			Title:        "",
-			Description:  "Some description",
-			TargetBranch: "main",
-			DeleteBranch: false,
-			Squash:       false,
-		}
-		request := makeRequest(t, http.MethodPost, "/create_mr", body)
-		server, _ := createRouterAndApi(fakeClient{createMrFn: createMrFn})
+		client := mock_main.NewMockClient(t)
+
+		missingTitleRequest := testCreateMrRequestData
+		missingTitleRequest.Title = ""
+
+		client.EXPECT().CreateMergeRequest("", gomock.Any()).Return(&gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, "/create_mr", missingTitleRequest)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Status, http.StatusBadRequest)
 		assert(t, data.Message, "Could not create MR")
 		assert(t, data.Details, "Title cannot be empty")
 	})
 
 	t.Run("Handles missing target branch", func(t *testing.T) {
-		body := CreateMrRequest{
-			Title:        "Some title",
-			Description:  "Some description",
-			TargetBranch: "",
-			DeleteBranch: false,
-			Squash:       false,
-		}
-		request := makeRequest(t, http.MethodPost, "/create_mr", body)
-		server, _ := createRouterAndApi(fakeClient{createMrFn: createMrFn})
+		client := mock_main.NewMockClient(t)
+
+		missingTitleRequest := testCreateMrRequestData
+		missingTitleRequest.TargetBranch = ""
+
+		client.EXPECT().CreateMergeRequest("", gomock.Any()).Return(&gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, "/create_mr", missingTitleRequest)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Status, http.StatusBadRequest)
 		assert(t, data.Message, "Could not create MR")
 		assert(t, data.Details, "Target branch cannot be empty")

cmd/draft_notes.go

@@ -52,7 +52,7 @@ func (draftNote DraftNoteWithPosition) GetPositionData() PositionData {
 }
 
 /* draftNoteHandler creates, edits, and deletes draft notes */
-func (a *api) draftNoteHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) draftNoteHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	switch r.Method {
 	case http.MethodGet:
@@ -69,7 +69,7 @@ func (a *api) draftNoteHandler(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (a *api) draftNotePublisher(w http.ResponseWriter, r *http.Request) {
+func (a *Api) draftNotePublisher(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodPost {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodPost)
@@ -126,7 +126,7 @@ func (a *api) draftNotePublisher(w http.ResponseWriter, r *http.Request) {
 }
 
 /* postDraftNote creates a draft note */
-func (a *api) postDraftNote(w http.ResponseWriter, r *http.Request) {
+func (a *Api) postDraftNote(w http.ResponseWriter, r *http.Request) {
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		handleError(w, err, "Could not read request body", http.StatusBadRequest)
@@ -184,7 +184,7 @@ func (a *api) postDraftNote(w http.ResponseWriter, r *http.Request) {
 }
 
 /* deleteDraftNote deletes a draft note */
-func (a *api) deleteDraftNote(w http.ResponseWriter, r *http.Request) {
+func (a *Api) deleteDraftNote(w http.ResponseWriter, r *http.Request) {
 	suffix := strings.TrimPrefix(r.URL.Path, "/mr/draft_notes/")
 	id, err := strconv.Atoi(suffix)
 	if err != nil {
@@ -217,7 +217,7 @@ func (a *api) deleteDraftNote(w http.ResponseWriter, r *http.Request) {
 }
 
 /* updateDraftNote edits the text of a draft comment */
-func (a *api) updateDraftNote(w http.ResponseWriter, r *http.Request) {
+func (a *Api) updateDraftNote(w http.ResponseWriter, r *http.Request) {
 	suffix := strings.TrimPrefix(r.URL.Path, "/mr/draft_notes/")
 	id, err := strconv.Atoi(suffix)
 	if err != nil {
@@ -278,7 +278,7 @@ func (a *api) updateDraftNote(w http.ResponseWriter, r *http.Request) {
 }
 
 /* listDraftNotes lists all draft notes for the currently authenticated user */
-func (a *api) listDraftNotes(w http.ResponseWriter, r *http.Request) {
+func (a *Api) listDraftNotes(w http.ResponseWriter, _ *http.Request) {
 
 	opt := gitlab.ListDraftNotesOptions{}
 	draftNotes, res, err := a.client.ListDraftNotes(a.projectInfo.ProjectId, a.projectInfo.MergeId, &opt)

cmd/draft_notes_test.go

@@ -1,25 +1,36 @@
 package main
 
 import (
-	"errors"
+	"fmt"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
+	"go.uber.org/mock/gomock"
 )
 
-func listDraftNotes(pid interface{}, mergeRequest int, opt *gitlab.ListDraftNotesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.DraftNote, *gitlab.Response, error) {
-	return []*gitlab.DraftNote{}, makeResponse(http.StatusOK), nil
+var testPostDraftNoteRequestData = PostDraftNoteRequest{
+	Comment: "Some comment",
 }
 
-func listDraftNotesErr(pid interface{}, mergeRequest int, opt *gitlab.ListDraftNotesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.DraftNote, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusInternalServerError), errors.New("Some error")
+var testUpdateDraftNoteRequest = UpdateDraftNoteRequest{
+	Note: "Some new note",
+}
+
+var testDraftNotePublishRequest = DraftNotePublishRequest{
+	Note:       3,
+	PublishAll: false,
 }
 
 func TestListDraftNotes(t *testing.T) {
 	t.Run("Lists all draft notes", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListDraftNotes("", mock_main.MergeId, gomock.Any()).Return([]*gitlab.DraftNote{}, makeResponse(http.StatusOK), nil)
+
 		request := makeRequest(t, http.MethodGet, "/mr/draft_notes/", nil)
-		server, _ := createRouterAndApi(fakeClient{listDraftNotes: listDraftNotes})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ListDraftNotesResponse{})
 
 		assert(t, data.SuccessResponse.Message, "Draft notes fetched successfully")
@@ -27,29 +38,28 @@ func TestListDraftNotes(t *testing.T) {
 	})
 
 	t.Run("Handles error", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListDraftNotes("", mock_main.MergeId, gomock.Any()).Return(nil, nil, errorFromGitlab)
+
 		request := makeRequest(t, http.MethodGet, "/mr/draft_notes/", nil)
-		server, _ := createRouterAndApi(fakeClient{listDraftNotes: listDraftNotesErr})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
 
 		assert(t, data.Message, "Could not get draft notes")
 		assert(t, data.Status, http.StatusInternalServerError)
-		assert(t, data.Details, "Some error")
+		assert(t, data.Details, errorFromGitlab.Error())
 	})
 }
 
-func createDraftNote(pid interface{}, mergeRequestIID int, opt *gitlab.CreateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error) {
-	return &gitlab.DraftNote{}, makeResponse(http.StatusOK), nil
-}
-
-func createDraftNoteErr(pid interface{}, mergeRequestIID int, opt *gitlab.CreateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusInternalServerError), errors.New("Some error")
-}
-
 func TestPostDraftNote(t *testing.T) {
 	t.Run("Posts new draft note", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/", PostDraftNoteRequest{})
-		server, _ := createRouterAndApi(fakeClient{createDraftNote: createDraftNote})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().CreateDraftNote("", mock_main.MergeId, gomock.Any()).Return(&gitlab.DraftNote{}, makeResponse(http.StatusOK), nil)
 
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/", testPostDraftNoteRequestData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, DraftNoteResponse{})
 
 		assert(t, data.SuccessResponse.Message, "Draft note created successfully")
@@ -57,139 +67,179 @@ func TestPostDraftNote(t *testing.T) {
 	})
 
 	t.Run("Handles errors on draft note creation", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/", PostDraftNoteRequest{})
-		server, _ := createRouterAndApi(fakeClient{createDraftNote: createDraftNoteErr})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().CreateDraftNote("", mock_main.MergeId, gomock.Any()).Return(nil, nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/", testPostDraftNoteRequestData)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Message, "Could not create draft note")
 		assert(t, data.Status, http.StatusInternalServerError)
-		assert(t, data.Details, "Some error")
+		assert(t, data.Details, errorFromGitlab.Error())
 	})
 }
 
-func deleteDraftNote(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return makeResponse(http.StatusOK), nil
-}
-
-func deleteDraftNoteErr(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return makeResponse(http.StatusInternalServerError), errors.New("Something went wrong")
-}
-
 func TestDeleteDraftNote(t *testing.T) {
 	t.Run("Deletes draft note", func(t *testing.T) {
-		request := makeRequest(t, http.MethodDelete, "/mr/draft_notes/3", nil)
-		server, _ := createRouterAndApi(fakeClient{deleteDraftNote: deleteDraftNote})
-		data := serveRequest(t, server, request, SuccessResponse{})
-		assert(t, data.Message, "Draft note deleted")
-		assert(t, data.Status, http.StatusOK)
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		urlId := 10
+		client.EXPECT().DeleteDraftNote("", mock_main.MergeId, urlId).Return(makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodDelete, fmt.Sprintf("/mr/draft_notes/%d", urlId), nil)
+		server, _ := CreateRouterAndApi(client)
+		data := serveRequest(t, server, request, DraftNoteResponse{})
+
+		assert(t, data.SuccessResponse.Message, "Draft note deleted")
+		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Handles error", func(t *testing.T) {
-		request := makeRequest(t, http.MethodDelete, "/mr/draft_notes/3", nil)
-		server, _ := createRouterAndApi(fakeClient{deleteDraftNote: deleteDraftNoteErr})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		urlId := 10
+		client.EXPECT().DeleteDraftNote("", mock_main.MergeId, urlId).Return(nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodDelete, fmt.Sprintf("/mr/draft_notes/%d", urlId), nil)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Message, "Could not delete draft note")
 		assert(t, data.Status, http.StatusInternalServerError)
+		assert(t, data.Details, errorFromGitlab.Error())
 	})
 
 	t.Run("Handles bad ID", func(t *testing.T) {
-		request := makeRequest(t, http.MethodDelete, "/mr/draft_notes/abc", nil)
-		server, _ := createRouterAndApi(fakeClient{deleteDraftNote: deleteDraftNote})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		urlId := "abc"
+
+		request := makeRequest(t, http.MethodDelete, fmt.Sprintf("/mr/draft_notes/%s", urlId), nil)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Message, "Could not parse draft note ID")
 		assert(t, data.Status, http.StatusBadRequest)
 	})
 }
 
-func updateDraftNote(pid interface{}, mergeRequest int, note int, opt *gitlab.UpdateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error) {
-	return &gitlab.DraftNote{}, makeResponse(http.StatusOK), nil
-}
-
 func TestEditDraftNote(t *testing.T) {
 	t.Run("Edits draft note", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPatch, "/mr/draft_notes/3", UpdateDraftNoteRequest{Note: "Some new note", Position: gitlab.PositionOptions{}})
-		server, _ := createRouterAndApi(fakeClient{updateDraftNote: updateDraftNote})
-		data := serveRequest(t, server, request, SuccessResponse{})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		urlId := 10
+		client.EXPECT().UpdateDraftNote("", mock_main.MergeId, urlId, gomock.Any()).Return(&gitlab.DraftNote{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPatch, fmt.Sprintf("/mr/draft_notes/%d", urlId), testUpdateDraftNoteRequest)
+		server, _ := CreateRouterAndApi(client)
+		data := serveRequest(t, server, request, DraftNoteResponse{})
+
 		assert(t, data.Message, "Draft note updated")
 		assert(t, data.Status, http.StatusOK)
 	})
 
 	t.Run("Handles bad ID", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPatch, "/mr/draft_notes/abc", nil)
-		server, _ := createRouterAndApi(fakeClient{updateDraftNote: updateDraftNote})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		urlId := "abc"
+		client.EXPECT().UpdateDraftNote("", mock_main.MergeId, urlId, gomock.Any()).Return(&gitlab.DraftNote{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPatch, fmt.Sprintf("/mr/draft_notes/%s", urlId), testUpdateDraftNoteRequest)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Message, "Could not parse draft note ID")
 		assert(t, data.Status, http.StatusBadRequest)
 	})
 
 	t.Run("Handles empty note", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPatch, "/mr/draft_notes/3", UpdateDraftNoteRequest{Note: ""})
-		server, _ := createRouterAndApi(fakeClient{updateDraftNote: updateDraftNote})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		urlId := 10
+
+		testEmptyUpdateDraftNoteRequest := testUpdateDraftNoteRequest
+		testEmptyUpdateDraftNoteRequest.Note = ""
+
+		client.EXPECT().UpdateDraftNote("", mock_main.MergeId, urlId, gomock.Any()).Return(&gitlab.DraftNote{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPatch, fmt.Sprintf("/mr/draft_notes/%d", urlId), testEmptyUpdateDraftNoteRequest)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Message, "Must provide draft note text")
 		assert(t, data.Status, http.StatusBadRequest)
 	})
 }
 
-func publishDraftNote(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return makeResponse(http.StatusOK), nil
-}
-
-func publishDraftNoteErr(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return nil, errors.New("Some error")
-}
-
 func TestPublishDraftNote(t *testing.T) {
 	t.Run("Should publish a draft note", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", DraftNotePublishRequest{Note: 3, PublishAll: false})
-		server, _ := createRouterAndApi(fakeClient{
-			publishDraftNote: publishDraftNote,
-		})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().PublishDraftNote("", mock_main.MergeId, testDraftNotePublishRequest.Note).Return(makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", testDraftNotePublishRequest)
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, SuccessResponse{})
 		assert(t, data.Message, "Draft note(s) published")
 		assert(t, data.Status, http.StatusOK)
 	})
 
 	t.Run("Handles bad/missing ID", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", DraftNotePublishRequest{PublishAll: false})
-		server, _ := createRouterAndApi(fakeClient{publishDraftNote: publishDraftNote})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+
+		// Missing Note ID
+		testDraftNotePublishRequest := DraftNotePublishRequest{
+			PublishAll: false,
+		}
+
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", testDraftNotePublishRequest)
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		assert(t, data.Message, "Must provide Note ID")
 		assert(t, data.Status, http.StatusBadRequest)
 	})
 
 	t.Run("Handles error", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", DraftNotePublishRequest{PublishAll: false, Note: 3})
-		server, _ := createRouterAndApi(fakeClient{publishDraftNote: publishDraftNoteErr})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().PublishDraftNote("", mock_main.MergeId, testDraftNotePublishRequest.Note).Return(nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", testDraftNotePublishRequest)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Message, "Could not publish draft note(s)")
 		assert(t, data.Status, http.StatusInternalServerError)
 	})
 }
 
-func publishAllDraftNotes(pid interface{}, mergeRequest int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return makeResponse(http.StatusOK), nil
-}
-
-func publishAllDraftNotesErr(pid interface{}, mergeRequest int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return nil, errors.New("Some error")
-}
-
 func TestPublishAllDraftNotes(t *testing.T) {
 	t.Run("Should publish all draft notes", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().PublishAllDraftNotes("", mock_main.MergeId).Return(makeResponse(http.StatusOK), nil)
+
 		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", DraftNotePublishRequest{PublishAll: true})
-		server, _ := createRouterAndApi(fakeClient{
-			publishAllDraftNotes: publishAllDraftNotes,
-		})
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, SuccessResponse{})
 		assert(t, data.Message, "Draft note(s) published")
 		assert(t, data.Status, http.StatusOK)
 	})
 
 	t.Run("Should handle an error", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().PublishAllDraftNotes("", mock_main.MergeId).Return(nil, errorFromGitlab)
+
 		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", DraftNotePublishRequest{PublishAll: true})
-		server, _ := createRouterAndApi(fakeClient{
-			publishAllDraftNotes: publishAllDraftNotesErr,
-		})
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		assert(t, data.Message, "Could not publish draft note(s)")
 		assert(t, data.Status, http.StatusInternalServerError)

cmd/emoji.go

@@ -43,7 +43,7 @@ type CreateEmojiResponse struct {
 attachEmojisToApi reads the emojis from our external JSON file
 and attaches them to the API so that they can be looked up later
 */
-func attachEmojisToApi(a *api) error {
+func attachEmojisToApi(a *Api) error {
 
 	e, err := os.Executable()
 	if err != nil {
@@ -78,7 +78,7 @@ func attachEmojisToApi(a *api) error {
 Fetches emojis for a set of notes and comments in parallel and returns a map of note IDs to their emojis.
 Gitlab's API does not allow for fetching notes for an entire discussion thread so we have to do it per-note.
 */
-func (a *api) fetchEmojisForNotesAndComments(noteIDs []int) (map[int][]*gitlab.AwardEmoji, error) {
+func (a *Api) fetchEmojisForNotesAndComments(noteIDs []int) (map[int][]*gitlab.AwardEmoji, error) {
 	var wg sync.WaitGroup
 
 	emojis := make(map[int][]*gitlab.AwardEmoji)
@@ -131,7 +131,7 @@ func (a *api) fetchEmojisForNotesAndComments(noteIDs []int) (map[int][]*gitlab.A
 	return emojis, nil
 }
 
-func (a *api) emojiNoteHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) emojiNoteHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	switch r.Method {
 	case http.MethodPost:
@@ -145,7 +145,7 @@ func (a *api) emojiNoteHandler(w http.ResponseWriter, r *http.Request) {
 }
 
 /* deleteEmojiFromNote deletes an emoji from a note based on the emoji (awardable) ID and the note's ID */
-func (a *api) deleteEmojiFromNote(w http.ResponseWriter, r *http.Request) {
+func (a *Api) deleteEmojiFromNote(w http.ResponseWriter, r *http.Request) {
 
 	suffix := strings.TrimPrefix(r.URL.Path, "/mr/awardable/note/")
 	ids := strings.Split(suffix, "/")
@@ -187,7 +187,7 @@ func (a *api) deleteEmojiFromNote(w http.ResponseWriter, r *http.Request) {
 }
 
 /* postEmojiOnNote adds an emojis to a note based on the note's ID */
-func (a *api) postEmojiOnNote(w http.ResponseWriter, r *http.Request) {
+func (a *Api) postEmojiOnNote(w http.ResponseWriter, r *http.Request) {
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		handleError(w, err, "Could not read request body", http.StatusBadRequest)

cmd/git.go

@@ -12,7 +12,7 @@ type GitProjectInfo struct {
 	Namespace               string
 	ProjectName             string
 	BranchName              string
-	GetLatestCommitOnRemote func(a *api) (string, error)
+	GetLatestCommitOnRemote func(a *Api) (string, error)
 }
 
 /*
@@ -90,10 +90,10 @@ func GetCurrentBranchNameFromNativeGitCmd() (res string, e error) {
 
 /* Gets the project SSH or HTTPS url */
 func GetProjectUrlFromNativeGitCmd() (string, error) {
-	cmd := exec.Command("git", "remote", "get-url", "origin")
+	cmd := exec.Command("git", "remote", "get-url", pluginOptions.ConnectionSettings.Remote)
 	url, err := cmd.Output()
 	if err != nil {
-		return "", fmt.Errorf("Could not get origin remote")
+		return "", fmt.Errorf("Could not get remote")
 	}
 
 	return strings.TrimSpace(string(url)), nil
@@ -101,24 +101,24 @@ func GetProjectUrlFromNativeGitCmd() (string, error) {
 
 /* Pulls down latest commit information from Gitlab */
 func RefreshProjectInfo() error {
-	cmd := exec.Command("git", "fetch", "origin")
+	cmd := exec.Command("git", "fetch", pluginOptions.ConnectionSettings.Remote)
 	_, err := cmd.Output()
 	if err != nil {
-		return fmt.Errorf("Failed to run `git fetch origin`: %v", err)
+		return fmt.Errorf("Failed to run `git fetch %s`: %v", pluginOptions.ConnectionSettings.Remote, err)
 	}
 
 	return nil
 }
 
 /*
-The GetLatestCommitOnRemote function is attached during the createRouterAndApi call, since it needs to be called every time to get the latest commit.
+The GetLatestCommitOnRemote function is attached during the CreateRouterAndApi call, since it needs to be called every time to get the latest commit.
 */
-func GetLatestCommitOnRemote(a *api) (string, error) {
-	cmd := exec.Command("git", "log", "-1", "--format=%H", fmt.Sprintf("origin/%s", a.gitInfo.BranchName))
+func GetLatestCommitOnRemote(a *Api) (string, error) {
+	cmd := exec.Command("git", "log", "-1", "--format=%H", fmt.Sprintf("%s/%s", pluginOptions.ConnectionSettings.Remote, a.gitInfo.BranchName))
 
 	out, err := cmd.Output()
 	if err != nil {
-		return "", fmt.Errorf("Failed to run `git log -1 --format=%%H " + fmt.Sprintf("origin/%s", a.gitInfo.BranchName))
+		return "", fmt.Errorf("Failed to run `git log -1 --format=%%H " + fmt.Sprintf("%s/%s", pluginOptions.ConnectionSettings.Remote, a.gitInfo.BranchName))
 	}
 
 	commit := strings.TrimSpace(string(out))

cmd/git_test.go

@@ -249,7 +249,7 @@ func TestExtractGitInfo_FailToGetCurrentBranchName(t *testing.T) {
 }
 
 func TestRefreshGitRemote_FailToRefreshRemote(t *testing.T) {
-	expectedErrNestedMsg := "error when fetching origin commits"
+	expectedErrNestedMsg := "error when fetching commits"
 	_, actualErr := extractGitInfo(
 		func() error {
 			return errors.New(expectedErrNestedMsg)

cmd/info.go

@@ -13,7 +13,7 @@ type InfoResponse struct {
 }
 
 /* infoHandler fetches infomation about the current git project. The data returned here is used in many other API calls */
-func (a *api) infoHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) infoHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodGet {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodGet)

cmd/info_test.go

@@ -1,52 +1,58 @@
 package main
 
 import (
-	"errors"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
 )
 
-func getInfo(pid interface{}, mergeRequest int, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return &gitlab.MergeRequest{Title: "Some Title"}, makeResponse(http.StatusOK), nil
-}
-
-func getInfoNon200(pid interface{}, mergeRequest int, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
-}
-
-func getInfoErr(pid interface{}, mergeRequest int, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
 func TestInfoHandler(t *testing.T) {
 	t.Run("Returns normal information", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().GetMergeRequest("", mock_main.MergeId, &gitlab.GetMergeRequestsOptions{}).Return(&gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil)
+
+		server, _ := CreateRouterAndApi(client)
 		request := makeRequest(t, http.MethodGet, "/mr/info", nil)
-		server, _ := createRouterAndApi(fakeClient{getMergeRequest: getInfo})
 		data := serveRequest(t, server, request, InfoResponse{})
-		assert(t, data.Info.Title, "Some Title")
+
 		assert(t, data.SuccessResponse.Message, "Merge requests retrieved")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Disallows non-GET method", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+
+		server, _ := CreateRouterAndApi(client)
 		request := makeRequest(t, http.MethodPost, "/mr/info", nil)
-		server, _ := createRouterAndApi(fakeClient{getMergeRequest: getInfo})
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkBadMethod(t, *data, http.MethodGet)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().GetMergeRequest("", mock_main.MergeId, &gitlab.GetMergeRequestsOptions{}).Return(nil, nil, errorFromGitlab)
+
+		server, _ := CreateRouterAndApi(client)
 		request := makeRequest(t, http.MethodGet, "/mr/info", nil)
-		server, _ := createRouterAndApi(fakeClient{getMergeRequest: getInfoErr})
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkErrorFromGitlab(t, *data, "Could not get project info")
 	})
 
 	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().GetMergeRequest("", mock_main.MergeId, &gitlab.GetMergeRequestsOptions{}).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		server, _ := CreateRouterAndApi(client)
 		request := makeRequest(t, http.MethodGet, "/mr/info", nil)
-		server, _ := createRouterAndApi(fakeClient{getMergeRequest: getInfoNon200})
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkNon200(t, *data, "Could not get project info", "/mr/info")
 	})

cmd/job.go

@@ -16,7 +16,7 @@ type JobTraceResponse struct {
 }
 
 /* jobHandler returns a string that shows the output of a specific job run in a Gitlab pipeline */
-func (a *api) jobHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) jobHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodGet {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodGet)

cmd/job_test.go

@@ -2,53 +2,58 @@ package main
 
 import (
 	"bytes"
-	"errors"
 	"net/http"
 	"testing"
 
-	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
 )
 
-func getTraceFile(pid interface{}, jobID int, options ...gitlab.RequestOptionFunc) (*bytes.Reader, *gitlab.Response, error) {
-	return bytes.NewReader([]byte("Some data")), makeResponse(http.StatusOK), nil
-}
-
-func getTraceFileErr(pid interface{}, jobID int, options ...gitlab.RequestOptionFunc) (*bytes.Reader, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
-func getTraceFileNon200(pid interface{}, jobID int, options ...gitlab.RequestOptionFunc) (*bytes.Reader, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
-}
+var jobId = 0
 
 func TestJobHandler(t *testing.T) {
 	t.Run("Should read a job trace file", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().GetTraceFile("", jobId).Return(bytes.NewReader([]byte("Some data")), makeResponse(http.StatusOK), nil)
+
 		request := makeRequest(t, http.MethodGet, "/job", JobTraceRequest{})
-		server, _ := createRouterAndApi(fakeClient{getTraceFile: getTraceFile})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, JobTraceResponse{})
+
 		assert(t, data.SuccessResponse.Message, "Log file read")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 		assert(t, data.File, "Some data")
 	})
 
 	t.Run("Disallows non-GET methods", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().GetTraceFile("", jobId).Return(bytes.NewReader([]byte("Some data")), makeResponse(http.StatusOK), nil)
+
 		request := makeRequest(t, http.MethodPost, "/job", JobTraceRequest{})
-		server, _ := createRouterAndApi(fakeClient{getTraceFile: getTraceFile})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkBadMethod(t, *data, http.MethodGet)
 	})
 
 	t.Run("Should handle errors from Gitlab", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().GetTraceFile("", jobId).Return(nil, nil, errorFromGitlab)
+
 		request := makeRequest(t, http.MethodGet, "/job", JobTraceRequest{})
-		server, _ := createRouterAndApi(fakeClient{getTraceFile: getTraceFileErr})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkErrorFromGitlab(t, *data, "Could not get trace file for job")
 	})
 
-	t.Run("Should handle non-200s", func(t *testing.T) {
+	t.Run("Should handle non-2jobIdjobIds", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().GetTraceFile("", jobId).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
 		request := makeRequest(t, http.MethodGet, "/job", JobTraceRequest{})
-		server, _ := createRouterAndApi(fakeClient{getTraceFile: getTraceFileNon200})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkNon200(t, *data, "Could not get trace file for job", "/job")
 	})
 }

cmd/label.go

@@ -29,7 +29,7 @@ type LabelsRequestResponse struct {
 }
 
 /* labelsHandler adds or removes labels from a merge request, and returns all labels for the current project */
-func (a *api) labelHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) labelHandler(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
 		a.getLabels(w, r)
@@ -42,7 +42,7 @@ func (a *api) labelHandler(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (a *api) getLabels(w http.ResponseWriter, r *http.Request) {
+func (a *Api) getLabels(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	labels, res, err := a.client.ListLabels(a.projectInfo.ProjectId, &gitlab.ListLabelsOptions{})
@@ -82,7 +82,7 @@ func (a *api) getLabels(w http.ResponseWriter, r *http.Request) {
 
 }
 
-func (a *api) updateLabels(w http.ResponseWriter, r *http.Request) {
+func (a *Api) updateLabels(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	body, err := io.ReadAll(r.Body)
 	if err != nil {

cmd/list_discussions.go

@@ -41,7 +41,7 @@ func (n SortableDiscussions) Swap(i, j int) {
 listDiscussionsHandler lists all discusions for a given merge request, both those linked and unlinked to particular points in the code.
 The responses are sorted by date created, and blacklisted users are not included
 */
-func (a *api) listDiscussionsHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) listDiscussionsHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodPost {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodPost)
@@ -68,7 +68,7 @@ func (a *api) listDiscussionsHandler(w http.ResponseWriter, r *http.Request) {
 		PerPage: 250,
 	}
 
-	discussions, res, err := a.client.ListMergeRequestDiscussions(a.projectInfo.ProjectId, a.projectInfo.MergeId, &mergeRequestDiscussionOptions, nil)
+	discussions, res, err := a.client.ListMergeRequestDiscussions(a.projectInfo.ProjectId, a.projectInfo.MergeId, &mergeRequestDiscussionOptions)
 
 	if err != nil {
 		handleError(w, err, "Could not list discussions", http.StatusInternalServerError)

cmd/list_discussions_test.go

@@ -1,65 +1,64 @@
 package main
 
 import (
-	"errors"
 	"net/http"
 	"testing"
 	"time"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
+	"go.uber.org/mock/gomock"
 )
 
-func listMergeRequestDiscussions(pid interface{}, mergeRequest int, opt *gitlab.ListMergeRequestDiscussionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error) {
-	now := time.Now()
-	newer := now.Add(time.Second * 100)
-	discussions := []*gitlab.Discussion{
-		{
-			Notes: []*gitlab.Note{
-				{
-					CreatedAt: &now,
-					Type:      "DiffNote",
-					Author: Author{
-						Username: "hcramer",
-					},
+var now = time.Now()
+var newer = now.Add(time.Second * 100)
+
+type Author struct {
+	ID        int    `json:"id"`
+	Username  string `json:"username"`
+	Email     string `json:"email"`
+	Name      string `json:"name"`
+	State     string `json:"state"`
+	AvatarURL string `json:"avatar_url"`
+	WebURL    string `json:"web_url"`
+}
+
+var testListDiscussionsResponse = []*gitlab.Discussion{
+	{
+		Notes: []*gitlab.Note{
+			{
+				CreatedAt: &now,
+				Type:      "DiffNote",
+				Author: Author{
+					Username: "hcramer",
 				},
 			},
 		},
-		{
-			Notes: []*gitlab.Note{
-				{
-					CreatedAt: &newer,
-					Type:      "DiffNote",
-					Author: Author{
-						Username: "hcramer2",
-					},
+	},
+	{
+		Notes: []*gitlab.Note{
+			{
+				CreatedAt: &newer,
+				Type:      "DiffNote",
+				Author: Author{
+					Username: "hcramer2",
 				},
 			},
 		},
-	}
-	return discussions, makeResponse(http.StatusOK), nil
-}
-
-func listMergeRequestDiscussionsErr(pid interface{}, mergeRequest int, opt *gitlab.ListMergeRequestDiscussionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
-func listMergeRequestDiscussionsNon200(pid interface{}, mergeRequest int, opt *gitlab.ListMergeRequestDiscussionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
-}
-
-func listMergeRequestAwardEmojiOnNote(pid interface{}, mr int, noteID int, opt *gitlab.ListAwardEmojiOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.AwardEmoji, *gitlab.Response, error) {
-	return []*gitlab.AwardEmoji{}, makeResponse(http.StatusOK), nil
-}
-
-func listMergeRequestAwardEmojiOnNoteFailure(pid interface{}, mr int, noteID int, opt *gitlab.ListAwardEmojiOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.AwardEmoji, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusBadRequest), errors.New("Some error from Gitlab")
+	},
 }
 
 func TestListDiscussionsHandler(t *testing.T) {
 	t.Run("Returns sorted discussions", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListMergeRequestDiscussions("", mock_main.MergeId, gomock.Any()).Return(testListDiscussionsResponse, makeResponse(http.StatusOK), nil)
+		client.EXPECT().ListMergeRequestAwardEmojiOnNote("", mock_main.MergeId, gomock.Any(), gomock.Any()).Return([]*gitlab.AwardEmoji{}, makeResponse(http.StatusOK), nil).Times(2)
+
 		request := makeRequest(t, http.MethodPost, "/mr/discussions/list", DiscussionsRequest{})
-		server, _ := createRouterAndApi(fakeClient{listMergeRequestDiscussions: listMergeRequestDiscussions, listMergeRequestAwardEmojiOnNote: listMergeRequestAwardEmojiOnNote})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, DiscussionsResponse{})
+
 		assert(t, data.SuccessResponse.Message, "Discussions retrieved")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 		assert(t, data.Discussions[0].Notes[0].Author.Username, "hcramer2") /* Sorting applied */
@@ -67,9 +66,15 @@ func TestListDiscussionsHandler(t *testing.T) {
 	})
 
 	t.Run("Uses blacklist to filter unwanted authors", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListMergeRequestDiscussions("", mock_main.MergeId, gomock.Any()).Return(testListDiscussionsResponse, makeResponse(http.StatusOK), nil)
+		client.EXPECT().ListMergeRequestAwardEmojiOnNote("", mock_main.MergeId, gomock.Any(), gomock.Any()).Return([]*gitlab.AwardEmoji{}, makeResponse(http.StatusOK), nil).Times(2)
+
 		request := makeRequest(t, http.MethodPost, "/mr/discussions/list", DiscussionsRequest{Blacklist: []string{"hcramer"}})
-		server, _ := createRouterAndApi(fakeClient{listMergeRequestDiscussions: listMergeRequestDiscussions, listMergeRequestAwardEmojiOnNote: listMergeRequestAwardEmojiOnNote})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, DiscussionsResponse{})
+
 		assert(t, data.SuccessResponse.Message, "Discussions retrieved")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 		assert(t, len(data.Discussions), 1)
@@ -77,30 +82,51 @@ func TestListDiscussionsHandler(t *testing.T) {
 	})
 
 	t.Run("Disallows non-POST method", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPatch, "/mr/discussions/list", DiscussionsRequest{})
-		server, _ := createRouterAndApi(fakeClient{listMergeRequestDiscussions: listMergeRequestDiscussions, listMergeRequestAwardEmojiOnNote: listMergeRequestAwardEmojiOnNote})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+
+		request := makeRequest(t, http.MethodPut, "/mr/discussions/list", DiscussionsRequest{})
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkBadMethod(t, *data, http.MethodPost)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListMergeRequestDiscussions("", mock_main.MergeId, gomock.Any()).Return(nil, nil, errorFromGitlab)
+
 		request := makeRequest(t, http.MethodPost, "/mr/discussions/list", DiscussionsRequest{})
-		server, _ := createRouterAndApi(fakeClient{listMergeRequestDiscussions: listMergeRequestDiscussionsErr, listMergeRequestAwardEmojiOnNote: listMergeRequestAwardEmojiOnNote})
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkErrorFromGitlab(t, *data, "Could not list discussions")
 	})
 
 	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListMergeRequestDiscussions("", mock_main.MergeId, gomock.Any()).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
 		request := makeRequest(t, http.MethodPost, "/mr/discussions/list", DiscussionsRequest{})
-		server, _ := createRouterAndApi(fakeClient{listMergeRequestDiscussions: listMergeRequestDiscussionsNon200, listMergeRequestAwardEmojiOnNote: listMergeRequestAwardEmojiOnNote})
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkNon200(t, *data, "Could not list discussions", "/mr/discussions/list")
 	})
 
 	t.Run("Handles error from emoji service", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListMergeRequestDiscussions("", mock_main.MergeId, gomock.Any()).Return(testListDiscussionsResponse, makeResponse(http.StatusOK), nil)
+		client.EXPECT().ListMergeRequestAwardEmojiOnNote("", mock_main.MergeId, gomock.Any(), gomock.Any()).Return(nil, nil, errorFromGitlab).Times(2)
+
 		request := makeRequest(t, http.MethodPost, "/mr/discussions/list", DiscussionsRequest{})
-		server, _ := createRouterAndApi(fakeClient{listMergeRequestDiscussions: listMergeRequestDiscussions, listMergeRequestAwardEmojiOnNote: listMergeRequestAwardEmojiOnNoteFailure})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkErrorFromGitlab(t, *data, "Could not fetch emojis")
+
 	})
 }

cmd/main.go

@@ -1,11 +1,36 @@
 package main
 
 import (
+	"encoding/json"
 	"log"
+	"os"
 )
 
+type PluginOptions struct {
+	GitlabUrl string `json:"gitlab_url"`
+	Port      int    `json:"port"`
+	AuthToken string `json:"auth_token"`
+	LogPath   string `json:"log_path"`
+	Debug     struct {
+		Request  bool `json:"go_request"`
+		Response bool `json:"go_response"`
+	} `json:"debug"`
+	ConnectionSettings struct {
+		Insecure bool   `json:"insecure"`
+		Remote   string `json:"remote"`
+	} `json:"connection_settings"`
+}
+
+var pluginOptions PluginOptions
+
 func main() {
 	log.SetFlags(0)
+
+	err := json.Unmarshal([]byte(os.Args[1]), &pluginOptions)
+	if err != nil {
+		log.Fatalf("Failure parsing plugin settings: %v", err)
+	}
+
 	gitInfo, err := extractGitInfo(RefreshProjectInfo, GetProjectUrlFromNativeGitCmd, GetCurrentBranchNameFromNativeGitCmd)
 	if err != nil {
 		log.Fatalf("Failure initializing plugin: %v", err)

cmd/members.go

@@ -13,7 +13,7 @@ type ProjectMembersResponse struct {
 }
 
 /* projectMembersHandler returns all members of the current Gitlab project */
-func (a *api) projectMembersHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) projectMembersHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodGet {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodGet)

cmd/members_test.go

@@ -1,52 +1,56 @@
 package main
 
 import (
-	"errors"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
+	"go.uber.org/mock/gomock"
 )
 
-func listAllProjectMembers(pid interface{}, opt *gitlab.ListProjectMembersOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.ProjectMember, *gitlab.Response, error) {
-	return []*gitlab.ProjectMember{}, makeResponse(http.StatusOK), nil
-}
-
-func listAllProjectMembersErr(pid interface{}, opt *gitlab.ListProjectMembersOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.ProjectMember, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
-func listAllProjectMembersNon200(pid interface{}, opt *gitlab.ListProjectMembersOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.ProjectMember, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
-}
-
 func TestMembersHandler(t *testing.T) {
 	t.Run("Returns project members", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().ListAllProjectMembers("", gomock.Any()).Return([]*gitlab.ProjectMember{}, makeResponse(http.StatusOK), nil)
+
 		request := makeRequest(t, http.MethodGet, "/project/members", nil)
-		server, _ := createRouterAndApi(fakeClient{listAllProjectMembers: listAllProjectMembers})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ProjectMembersResponse{})
+
 		assert(t, data.SuccessResponse.Message, "Project members retrieved")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Disallows non-GET method", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+
 		request := makeRequest(t, http.MethodPost, "/project/members", nil)
-		server, _ := createRouterAndApi(fakeClient{listAllProjectMembers: listAllProjectMembers})
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkBadMethod(t, *data, http.MethodGet)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().ListAllProjectMembers("", gomock.Any()).Return(nil, nil, errorFromGitlab)
+
 		request := makeRequest(t, http.MethodGet, "/project/members", nil)
-		server, _ := createRouterAndApi(fakeClient{listAllProjectMembers: listAllProjectMembersErr})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkErrorFromGitlab(t, *data, "Could not retrieve project members")
 	})
 
 	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().ListAllProjectMembers("", gomock.Any()).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
 		request := makeRequest(t, http.MethodGet, "/project/members", nil)
-		server, _ := createRouterAndApi(fakeClient{listAllProjectMembers: listAllProjectMembersNon200})
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkNon200(t, *data, "Could not retrieve project members", "/project/members")
 	})
 }

cmd/merge.go

@@ -15,7 +15,7 @@ type AcceptMergeRequestRequest struct {
 }
 
 /* acceptAndMergeHandler merges a given merge request into the target branch */
-func (a *api) acceptAndMergeHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) acceptAndMergeHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("Access-Control-Allow-Methods", http.MethodGet)
 	if r.Method != http.MethodPost {

cmd/merge_requests.go

@@ -4,35 +4,63 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"net/http"
 
 	"github.com/xanzy/go-gitlab"
 )
 
+type ListMergeRequestRequest struct {
+	Label    []string `json:"label"`
+	NotLabel []string `json:"notlabel"`
+}
+
 type ListMergeRequestResponse struct {
 	SuccessResponse
 	MergeRequests []*gitlab.MergeRequest `json:"merge_requests"`
 }
 
-func (a *api) mergeRequestsHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) mergeRequestsHandler(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	if r.Method != http.MethodPost {
+		w.Header().Set("Access-Control-Allow-Methods", http.MethodPost)
+		handleError(w, InvalidRequestError{}, "Expected POST", http.StatusMethodNotAllowed)
+		return
+	}
 
-	if r.Method != http.MethodGet {
-		w.Header().Set("Access-Control-Allow-Methods", http.MethodGet)
-		handleError(w, InvalidRequestError{}, "Expected GET", http.StatusMethodNotAllowed)
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		handleError(w, err, "Could not read request body", http.StatusBadRequest)
+		return
+	}
+
+	defer r.Body.Close()
+	var listMergeRequestRequest ListMergeRequestRequest
+	err = json.Unmarshal(body, &listMergeRequestRequest)
+	if err != nil {
+		handleError(w, err, "Could not read JSON from request", http.StatusBadRequest)
 		return
 	}
 
 	options := gitlab.ListProjectMergeRequestsOptions{
-		Scope: gitlab.Ptr("all"),
-		State: gitlab.Ptr("opened"),
+		Scope:     gitlab.Ptr("all"),
+		State:     gitlab.Ptr("opened"),
+		Labels:    (*gitlab.LabelOptions)(&listMergeRequestRequest.Label),
+		NotLabels: (*gitlab.LabelOptions)(&listMergeRequestRequest.NotLabel),
 	}
 
-	mergeRequests, _, err := a.client.ListProjectMergeRequests(a.projectInfo.ProjectId, &options)
+	mergeRequests, res, err := a.client.ListProjectMergeRequests(a.projectInfo.ProjectId, &options)
+
 	if err != nil {
 		handleError(w, fmt.Errorf("Failed to list merge requests: %w", err), "Failed to list merge requests", http.StatusInternalServerError)
 		return
 	}
 
+	if res.StatusCode >= 300 {
+		handleError(w, GenericError{endpoint: "/merge_requests"}, "Failed to list merge requests", res.StatusCode)
+		return
+	}
+
 	if len(mergeRequests) == 0 {
 		handleError(w, errors.New("No merge requests found"), "No merge requests found", http.StatusNotFound)
 		return
@@ -51,5 +79,4 @@ func (a *api) mergeRequestsHandler(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		handleError(w, err, "Could not encode response", http.StatusInternalServerError)
 	}
-
 }

cmd/merge_requests_test.go

@@ -1,44 +1,72 @@
 package main
 
 import (
-	"errors"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
+	"go.uber.org/mock/gomock"
 )
 
-func listProjectMergeRequests200(pid interface{}, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error) {
-	return []*gitlab.MergeRequest{{ID: 1}}, &gitlab.Response{}, nil
-}
-
-func listProjectMergeRequestsEmpty(pid interface{}, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error) {
-	return []*gitlab.MergeRequest{}, &gitlab.Response{}, nil
-}
-
-func listProjectMergeRequestsErr(pid interface{}, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error")
+var testListMergeRequestsRequest = ListMergeRequestRequest{
+	Label:    []string{},
+	NotLabel: []string{},
 }
 
 func TestMergeRequestHandler(t *testing.T) {
 	t.Run("Should fetch merge requests", func(t *testing.T) {
-		request := makeRequest(t, http.MethodGet, "/merge_requests", nil)
-		server, _ := createRouterAndApi(fakeClient{listProjectMergeRequests: listProjectMergeRequests200})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListProjectMergeRequests("", gomock.Any()).Return([]*gitlab.MergeRequest{
+			{
+				IID: 10,
+			},
+		}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, "/merge_requests", testListMergeRequestsRequest)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ListMergeRequestResponse{})
+
 		assert(t, data.Message, "Merge requests fetched successfully")
 		assert(t, data.Status, http.StatusOK)
 	})
-	t.Run("Should handle an error", func(t *testing.T) {
-		request := makeRequest(t, http.MethodGet, "/merge_requests", nil)
-		server, _ := createRouterAndApi(fakeClient{listProjectMergeRequests: listProjectMergeRequestsErr})
+
+	t.Run("Should handle an error from Gitlab", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListProjectMergeRequests("", gomock.Any()).Return(nil, nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodPost, "/merge_requests", testListMergeRequestsRequest)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		assert(t, data.Message, "Failed to list merge requests")
 		assert(t, data.Status, http.StatusInternalServerError)
 	})
-	t.Run("Should handle not having any merge requests with 404", func(t *testing.T) {
-		request := makeRequest(t, http.MethodGet, "/merge_requests", nil)
-		server, _ := createRouterAndApi(fakeClient{listProjectMergeRequests: listProjectMergeRequestsEmpty})
+
+	t.Run("Should handle a non-200", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListProjectMergeRequests("", gomock.Any()).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodPost, "/merge_requests", testListMergeRequestsRequest)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
+		assert(t, data.Message, "Failed to list merge requests")
+		assert(t, data.Status, http.StatusSeeOther)
+	})
+
+	t.Run("Should handle not having any merge requests with 404", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().ListProjectMergeRequests("", gomock.Any()).Return([]*gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, "/merge_requests", testListMergeRequestsRequest)
+		server, _ := CreateRouterAndApi(client)
+		data := serveRequest(t, server, request, ListMergeRequestResponse{})
+
 		assert(t, data.Message, "No merge requests found")
 		assert(t, data.Status, http.StatusNotFound)
 	})

cmd/merge_test.go

@@ -1,52 +1,67 @@
 package main
 
 import (
-	"errors"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
+	"go.uber.org/mock/gomock"
 )
 
-func acceptMergeRequest(pid interface{}, mergeRequest int, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return &gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil
-}
-
-func acceptMergeRequestErr(pid interface{}, mergeRequest int, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
-func acceptAndMergeNon200(pid interface{}, mergeRequest int, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
+var testAcceptMergeRequestPayload = AcceptMergeRequestRequest{
+	Squash:        false,
+	SquashMessage: "Squash me!",
+	DeleteBranch:  false,
 }
 
 func TestAcceptAndMergeHandler(t *testing.T) {
 	t.Run("Accepts and merges a merge request", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/merge", AcceptMergeRequestRequest{})
-		server, _ := createRouterAndApi(fakeClient{acceptMergeRequest: acceptMergeRequest})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().AcceptMergeRequest("", mock_main.MergeId, gomock.Any()).Return(&gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, "/mr/merge", testAcceptMergeRequestPayload)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, SuccessResponse{})
+
 		assert(t, data.Message, "MR merged successfully")
 		assert(t, data.Status, http.StatusOK)
 	})
 
 	t.Run("Disallows non-POST methods", func(t *testing.T) {
-		request := makeRequest(t, http.MethodGet, "/mr/merge", AcceptMergeRequestRequest{})
-		server, _ := createRouterAndApi(fakeClient{acceptMergeRequest: acceptMergeRequest})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().AcceptMergeRequest("", mock_main.MergeId, gomock.Any()).Return(&gitlab.MergeRequest{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPatch, "/mr/merge", testAcceptMergeRequestPayload)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkBadMethod(t, *data, http.MethodPost)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/merge", AcceptMergeRequestRequest{})
-		server, _ := createRouterAndApi(fakeClient{acceptMergeRequest: acceptMergeRequestErr})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().AcceptMergeRequest("", mock_main.MergeId, gomock.Any()).Return(nil, nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodPost, "/mr/merge", testAcceptMergeRequestPayload)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkErrorFromGitlab(t, *data, "Could not merge MR")
 	})
 
 	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/merge", AcceptMergeRequestRequest{})
-		server, _ := createRouterAndApi(fakeClient{acceptMergeRequest: acceptAndMergeNon200})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().AcceptMergeRequest("", mock_main.MergeId, gomock.Any()).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodPost, "/mr/merge", testAcceptMergeRequestPayload)
+		server, _ := CreateRouterAndApi(client)
 		data := serveRequest(t, server, request, ErrorResponse{})
+
 		checkNon200(t, *data, "Could not merge MR", "/mr/merge")
 	})
 }

cmd/mocks/fake_client.go

@@ -0,0 +1,686 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: cmd/types.go
+//
+// Generated by this command:
+//
+//	mockgen -source cmd/types.go
+//
+
+// Package mock_main is a generated GoMock package.
+package mock_main
+
+import (
+	bytes "bytes"
+	io "io"
+	reflect "reflect"
+
+	gitlab "github.com/xanzy/go-gitlab"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockClientInterface is a mock of ClientInterface interface.
+type MockClientInterface struct {
+	ctrl     *gomock.Controller
+	recorder *MockClientInterfaceMockRecorder
+}
+
+// MockClientInterfaceMockRecorder is the mock recorder for MockClientInterface.
+type MockClientInterfaceMockRecorder struct {
+	mock *MockClientInterface
+}
+
+// NewMockClientInterface creates a new mock instance.
+func NewMockClientInterface(ctrl *gomock.Controller) *MockClientInterface {
+	mock := &MockClientInterface{ctrl: ctrl}
+	mock.recorder = &MockClientInterfaceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockClientInterface) EXPECT() *MockClientInterfaceMockRecorder {
+	return m.recorder
+}
+
+// AcceptMergeRequest mocks base method.
+func (m *MockClientInterface) AcceptMergeRequest(pid any, mergeRequestIID int, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AcceptMergeRequest", varargs...)
+	ret0, _ := ret[0].(*gitlab.MergeRequest)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// AcceptMergeRequest indicates an expected call of AcceptMergeRequest.
+func (mr *MockClientInterfaceMockRecorder) AcceptMergeRequest(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).AcceptMergeRequest), varargs...)
+}
+
+// AddMergeRequestDiscussionNote mocks base method.
+func (m *MockClientInterface) AddMergeRequestDiscussionNote(pid any, mergeRequestIID int, discussion string, opt *gitlab.AddMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, discussion, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AddMergeRequestDiscussionNote", varargs...)
+	ret0, _ := ret[0].(*gitlab.Note)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// AddMergeRequestDiscussionNote indicates an expected call of AddMergeRequestDiscussionNote.
+func (mr *MockClientInterfaceMockRecorder) AddMergeRequestDiscussionNote(pid, mergeRequestIID, discussion, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, discussion, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMergeRequestDiscussionNote", reflect.TypeOf((*MockClientInterface)(nil).AddMergeRequestDiscussionNote), varargs...)
+}
+
+// ApproveMergeRequest mocks base method.
+func (m *MockClientInterface) ApproveMergeRequest(pid any, mergeRequestIID int, opt *gitlab.ApproveMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ApproveMergeRequest", varargs...)
+	ret0, _ := ret[0].(*gitlab.MergeRequestApprovals)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ApproveMergeRequest indicates an expected call of ApproveMergeRequest.
+func (mr *MockClientInterfaceMockRecorder) ApproveMergeRequest(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).ApproveMergeRequest), varargs...)
+}
+
+// CreateDraftNote mocks base method.
+func (m *MockClientInterface) CreateDraftNote(pid any, mergeRequestIID int, opt *gitlab.CreateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateDraftNote", varargs...)
+	ret0, _ := ret[0].(*gitlab.DraftNote)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// CreateDraftNote indicates an expected call of CreateDraftNote.
+func (mr *MockClientInterfaceMockRecorder) CreateDraftNote(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDraftNote", reflect.TypeOf((*MockClientInterface)(nil).CreateDraftNote), varargs...)
+}
+
+// CreateMergeRequest mocks base method.
+func (m *MockClientInterface) CreateMergeRequest(pid any, opt *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateMergeRequest", varargs...)
+	ret0, _ := ret[0].(*gitlab.MergeRequest)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// CreateMergeRequest indicates an expected call of CreateMergeRequest.
+func (mr *MockClientInterfaceMockRecorder) CreateMergeRequest(pid, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).CreateMergeRequest), varargs...)
+}
+
+// CreateMergeRequestAwardEmojiOnNote mocks base method.
+func (m *MockClientInterface) CreateMergeRequestAwardEmojiOnNote(pid any, mergeRequestIID, noteID int, opt *gitlab.CreateAwardEmojiOptions, options ...gitlab.RequestOptionFunc) (*gitlab.AwardEmoji, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, noteID, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateMergeRequestAwardEmojiOnNote", varargs...)
+	ret0, _ := ret[0].(*gitlab.AwardEmoji)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// CreateMergeRequestAwardEmojiOnNote indicates an expected call of CreateMergeRequestAwardEmojiOnNote.
+func (mr *MockClientInterfaceMockRecorder) CreateMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, noteID, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequestAwardEmojiOnNote", reflect.TypeOf((*MockClientInterface)(nil).CreateMergeRequestAwardEmojiOnNote), varargs...)
+}
+
+// CreateMergeRequestDiscussion mocks base method.
+func (m *MockClientInterface) CreateMergeRequestDiscussion(pid any, mergeRequestIID int, opt *gitlab.CreateMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateMergeRequestDiscussion", varargs...)
+	ret0, _ := ret[0].(*gitlab.Discussion)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// CreateMergeRequestDiscussion indicates an expected call of CreateMergeRequestDiscussion.
+func (mr *MockClientInterfaceMockRecorder) CreateMergeRequestDiscussion(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequestDiscussion", reflect.TypeOf((*MockClientInterface)(nil).CreateMergeRequestDiscussion), varargs...)
+}
+
+// CurrentUser mocks base method.
+func (m *MockClientInterface) CurrentUser(options ...gitlab.RequestOptionFunc) (*gitlab.User, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CurrentUser", varargs...)
+	ret0, _ := ret[0].(*gitlab.User)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// CurrentUser indicates an expected call of CurrentUser.
+func (mr *MockClientInterfaceMockRecorder) CurrentUser(options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentUser", reflect.TypeOf((*MockClientInterface)(nil).CurrentUser), options...)
+}
+
+// DeleteDraftNote mocks base method.
+func (m *MockClientInterface) DeleteDraftNote(pid any, mergeRequest, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequest, note}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDraftNote", varargs...)
+	ret0, _ := ret[0].(*gitlab.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDraftNote indicates an expected call of DeleteDraftNote.
+func (mr *MockClientInterfaceMockRecorder) DeleteDraftNote(pid, mergeRequest, note any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequest, note}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDraftNote", reflect.TypeOf((*MockClientInterface)(nil).DeleteDraftNote), varargs...)
+}
+
+// DeleteMergeRequestAwardEmojiOnNote mocks base method.
+func (m *MockClientInterface) DeleteMergeRequestAwardEmojiOnNote(pid any, mergeRequestIID, noteID, awardID int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, noteID, awardID}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteMergeRequestAwardEmojiOnNote", varargs...)
+	ret0, _ := ret[0].(*gitlab.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteMergeRequestAwardEmojiOnNote indicates an expected call of DeleteMergeRequestAwardEmojiOnNote.
+func (mr *MockClientInterfaceMockRecorder) DeleteMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, awardID any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, noteID, awardID}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMergeRequestAwardEmojiOnNote", reflect.TypeOf((*MockClientInterface)(nil).DeleteMergeRequestAwardEmojiOnNote), varargs...)
+}
+
+// DeleteMergeRequestDiscussionNote mocks base method.
+func (m *MockClientInterface) DeleteMergeRequestDiscussionNote(pid any, mergeRequestIID int, discussion string, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, discussion, note}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteMergeRequestDiscussionNote", varargs...)
+	ret0, _ := ret[0].(*gitlab.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteMergeRequestDiscussionNote indicates an expected call of DeleteMergeRequestDiscussionNote.
+func (mr *MockClientInterfaceMockRecorder) DeleteMergeRequestDiscussionNote(pid, mergeRequestIID, discussion, note any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, discussion, note}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMergeRequestDiscussionNote", reflect.TypeOf((*MockClientInterface)(nil).DeleteMergeRequestDiscussionNote), varargs...)
+}
+
+// GetMergeRequest mocks base method.
+func (m *MockClientInterface) GetMergeRequest(pid any, mergeRequestIID int, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetMergeRequest", varargs...)
+	ret0, _ := ret[0].(*gitlab.MergeRequest)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// GetMergeRequest indicates an expected call of GetMergeRequest.
+func (mr *MockClientInterfaceMockRecorder) GetMergeRequest(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).GetMergeRequest), varargs...)
+}
+
+// GetMergeRequestDiffVersions mocks base method.
+func (m *MockClientInterface) GetMergeRequestDiffVersions(pid any, mergeRequestIID int, opt *gitlab.GetMergeRequestDiffVersionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiffVersion, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetMergeRequestDiffVersions", varargs...)
+	ret0, _ := ret[0].([]*gitlab.MergeRequestDiffVersion)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// GetMergeRequestDiffVersions indicates an expected call of GetMergeRequestDiffVersions.
+func (mr *MockClientInterfaceMockRecorder) GetMergeRequestDiffVersions(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequestDiffVersions", reflect.TypeOf((*MockClientInterface)(nil).GetMergeRequestDiffVersions), varargs...)
+}
+
+// GetTraceFile mocks base method.
+func (m *MockClientInterface) GetTraceFile(pid any, jobID int, options ...gitlab.RequestOptionFunc) (*bytes.Reader, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, jobID}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetTraceFile", varargs...)
+	ret0, _ := ret[0].(*bytes.Reader)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// GetTraceFile indicates an expected call of GetTraceFile.
+func (mr *MockClientInterfaceMockRecorder) GetTraceFile(pid, jobID any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, jobID}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTraceFile", reflect.TypeOf((*MockClientInterface)(nil).GetTraceFile), varargs...)
+}
+
+// ListAllProjectMembers mocks base method.
+func (m *MockClientInterface) ListAllProjectMembers(pid any, opt *gitlab.ListProjectMembersOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.ProjectMember, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListAllProjectMembers", varargs...)
+	ret0, _ := ret[0].([]*gitlab.ProjectMember)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListAllProjectMembers indicates an expected call of ListAllProjectMembers.
+func (mr *MockClientInterfaceMockRecorder) ListAllProjectMembers(pid, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllProjectMembers", reflect.TypeOf((*MockClientInterface)(nil).ListAllProjectMembers), varargs...)
+}
+
+// ListDraftNotes mocks base method.
+func (m *MockClientInterface) ListDraftNotes(pid any, mergeRequest int, opt *gitlab.ListDraftNotesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.DraftNote, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequest, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListDraftNotes", varargs...)
+	ret0, _ := ret[0].([]*gitlab.DraftNote)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListDraftNotes indicates an expected call of ListDraftNotes.
+func (mr *MockClientInterfaceMockRecorder) ListDraftNotes(pid, mergeRequest, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequest, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDraftNotes", reflect.TypeOf((*MockClientInterface)(nil).ListDraftNotes), varargs...)
+}
+
+// ListLabels mocks base method.
+func (m *MockClientInterface) ListLabels(pid any, opt *gitlab.ListLabelsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Label, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListLabels", varargs...)
+	ret0, _ := ret[0].([]*gitlab.Label)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListLabels indicates an expected call of ListLabels.
+func (mr *MockClientInterfaceMockRecorder) ListLabels(pid, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLabels", reflect.TypeOf((*MockClientInterface)(nil).ListLabels), varargs...)
+}
+
+// ListMergeRequestAwardEmojiOnNote mocks base method.
+func (m *MockClientInterface) ListMergeRequestAwardEmojiOnNote(pid any, mergeRequestIID, noteID int, opt *gitlab.ListAwardEmojiOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.AwardEmoji, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, noteID, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListMergeRequestAwardEmojiOnNote", varargs...)
+	ret0, _ := ret[0].([]*gitlab.AwardEmoji)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListMergeRequestAwardEmojiOnNote indicates an expected call of ListMergeRequestAwardEmojiOnNote.
+func (mr *MockClientInterfaceMockRecorder) ListMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, noteID, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMergeRequestAwardEmojiOnNote", reflect.TypeOf((*MockClientInterface)(nil).ListMergeRequestAwardEmojiOnNote), varargs...)
+}
+
+// ListMergeRequestDiscussions mocks base method.
+func (m *MockClientInterface) ListMergeRequestDiscussions(pid any, mergeRequestIID int, opt *gitlab.ListMergeRequestDiscussionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListMergeRequestDiscussions", varargs...)
+	ret0, _ := ret[0].([]*gitlab.Discussion)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListMergeRequestDiscussions indicates an expected call of ListMergeRequestDiscussions.
+func (mr *MockClientInterfaceMockRecorder) ListMergeRequestDiscussions(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMergeRequestDiscussions", reflect.TypeOf((*MockClientInterface)(nil).ListMergeRequestDiscussions), varargs...)
+}
+
+// ListPipelineJobs mocks base method.
+func (m *MockClientInterface) ListPipelineJobs(pid any, pipelineID int, opts *gitlab.ListJobsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Job, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, pipelineID, opts}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListPipelineJobs", varargs...)
+	ret0, _ := ret[0].([]*gitlab.Job)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListPipelineJobs indicates an expected call of ListPipelineJobs.
+func (mr *MockClientInterfaceMockRecorder) ListPipelineJobs(pid, pipelineID, opts any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, pipelineID, opts}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPipelineJobs", reflect.TypeOf((*MockClientInterface)(nil).ListPipelineJobs), varargs...)
+}
+
+// ListProjectMergeRequests mocks base method.
+func (m *MockClientInterface) ListProjectMergeRequests(pid any, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListProjectMergeRequests", varargs...)
+	ret0, _ := ret[0].([]*gitlab.MergeRequest)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListProjectMergeRequests indicates an expected call of ListProjectMergeRequests.
+func (mr *MockClientInterfaceMockRecorder) ListProjectMergeRequests(pid, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectMergeRequests", reflect.TypeOf((*MockClientInterface)(nil).ListProjectMergeRequests), varargs...)
+}
+
+// ListProjectPipelines mocks base method.
+func (m *MockClientInterface) ListProjectPipelines(pid any, opt *gitlab.ListProjectPipelinesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.PipelineInfo, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListProjectPipelines", varargs...)
+	ret0, _ := ret[0].([]*gitlab.PipelineInfo)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListProjectPipelines indicates an expected call of ListProjectPipelines.
+func (mr *MockClientInterfaceMockRecorder) ListProjectPipelines(pid, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectPipelines", reflect.TypeOf((*MockClientInterface)(nil).ListProjectPipelines), varargs...)
+}
+
+// PublishAllDraftNotes mocks base method.
+func (m *MockClientInterface) PublishAllDraftNotes(pid any, mergeRequest int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequest}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PublishAllDraftNotes", varargs...)
+	ret0, _ := ret[0].(*gitlab.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PublishAllDraftNotes indicates an expected call of PublishAllDraftNotes.
+func (mr *MockClientInterfaceMockRecorder) PublishAllDraftNotes(pid, mergeRequest any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequest}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishAllDraftNotes", reflect.TypeOf((*MockClientInterface)(nil).PublishAllDraftNotes), varargs...)
+}
+
+// PublishDraftNote mocks base method.
+func (m *MockClientInterface) PublishDraftNote(pid any, mergeRequest, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequest, note}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PublishDraftNote", varargs...)
+	ret0, _ := ret[0].(*gitlab.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PublishDraftNote indicates an expected call of PublishDraftNote.
+func (mr *MockClientInterfaceMockRecorder) PublishDraftNote(pid, mergeRequest, note any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequest, note}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishDraftNote", reflect.TypeOf((*MockClientInterface)(nil).PublishDraftNote), varargs...)
+}
+
+// ResolveMergeRequestDiscussion mocks base method.
+func (m *MockClientInterface) ResolveMergeRequestDiscussion(pid any, mergeRequestIID int, discussion string, opt *gitlab.ResolveMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, discussion, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ResolveMergeRequestDiscussion", varargs...)
+	ret0, _ := ret[0].(*gitlab.Discussion)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ResolveMergeRequestDiscussion indicates an expected call of ResolveMergeRequestDiscussion.
+func (mr *MockClientInterfaceMockRecorder) ResolveMergeRequestDiscussion(pid, mergeRequestIID, discussion, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, discussion, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveMergeRequestDiscussion", reflect.TypeOf((*MockClientInterface)(nil).ResolveMergeRequestDiscussion), varargs...)
+}
+
+// RetryPipelineBuild mocks base method.
+func (m *MockClientInterface) RetryPipelineBuild(pid any, pipeline int, options ...gitlab.RequestOptionFunc) (*gitlab.Pipeline, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, pipeline}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RetryPipelineBuild", varargs...)
+	ret0, _ := ret[0].(*gitlab.Pipeline)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// RetryPipelineBuild indicates an expected call of RetryPipelineBuild.
+func (mr *MockClientInterfaceMockRecorder) RetryPipelineBuild(pid, pipeline any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, pipeline}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryPipelineBuild", reflect.TypeOf((*MockClientInterface)(nil).RetryPipelineBuild), varargs...)
+}
+
+// UnapproveMergeRequest mocks base method.
+func (m *MockClientInterface) UnapproveMergeRequest(pid any, mergeRequestIID int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UnapproveMergeRequest", varargs...)
+	ret0, _ := ret[0].(*gitlab.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UnapproveMergeRequest indicates an expected call of UnapproveMergeRequest.
+func (mr *MockClientInterfaceMockRecorder) UnapproveMergeRequest(pid, mergeRequestIID any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnapproveMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).UnapproveMergeRequest), varargs...)
+}
+
+// UpdateDraftNote mocks base method.
+func (m *MockClientInterface) UpdateDraftNote(pid any, mergeRequest, note int, opt *gitlab.UpdateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequest, note, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateDraftNote", varargs...)
+	ret0, _ := ret[0].(*gitlab.DraftNote)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// UpdateDraftNote indicates an expected call of UpdateDraftNote.
+func (mr *MockClientInterfaceMockRecorder) UpdateDraftNote(pid, mergeRequest, note, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequest, note, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDraftNote", reflect.TypeOf((*MockClientInterface)(nil).UpdateDraftNote), varargs...)
+}
+
+// UpdateMergeRequest mocks base method.
+func (m *MockClientInterface) UpdateMergeRequest(pid any, mergeRequestIID int, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateMergeRequest", varargs...)
+	ret0, _ := ret[0].(*gitlab.MergeRequest)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// UpdateMergeRequest indicates an expected call of UpdateMergeRequest.
+func (mr *MockClientInterfaceMockRecorder) UpdateMergeRequest(pid, mergeRequestIID, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMergeRequest", reflect.TypeOf((*MockClientInterface)(nil).UpdateMergeRequest), varargs...)
+}
+
+// UpdateMergeRequestDiscussionNote mocks base method.
+func (m *MockClientInterface) UpdateMergeRequestDiscussionNote(pid any, mergeRequestIID int, discussion string, note int, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, mergeRequestIID, discussion, note, opt}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateMergeRequestDiscussionNote", varargs...)
+	ret0, _ := ret[0].(*gitlab.Note)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// UpdateMergeRequestDiscussionNote indicates an expected call of UpdateMergeRequestDiscussionNote.
+func (mr *MockClientInterfaceMockRecorder) UpdateMergeRequestDiscussionNote(pid, mergeRequestIID, discussion, note, opt any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, mergeRequestIID, discussion, note, opt}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMergeRequestDiscussionNote", reflect.TypeOf((*MockClientInterface)(nil).UpdateMergeRequestDiscussionNote), varargs...)
+}
+
+// UploadFile mocks base method.
+func (m *MockClientInterface) UploadFile(pid any, content io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectFile, *gitlab.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{pid, content, filename}
+	for _, a := range options {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UploadFile", varargs...)
+	ret0, _ := ret[0].(*gitlab.ProjectFile)
+	ret1, _ := ret[1].(*gitlab.Response)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// UploadFile indicates an expected call of UploadFile.
+func (mr *MockClientInterfaceMockRecorder) UploadFile(pid, content, filename any, options ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{pid, content, filename}, options...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadFile", reflect.TypeOf((*MockClientInterface)(nil).UploadFile), varargs...)
+}

cmd/mocks/helpers.go

@@ -0,0 +1,60 @@
+package mock_main
+
+import (
+	bytes "bytes"
+	io "io"
+	"net/http"
+	"testing"
+
+	gitlab "github.com/xanzy/go-gitlab"
+	gomock "go.uber.org/mock/gomock"
+)
+
+var MergeId = 3
+
+func NewListMrOptions() *gitlab.ListProjectMergeRequestsOptions {
+	return &gitlab.ListProjectMergeRequestsOptions{
+		Scope:        gitlab.Ptr("all"),
+		State:        gitlab.Ptr("opened"),
+		SourceBranch: gitlab.Ptr(""),
+	}
+}
+
+/* Make response makes a simple response value with the right status code */
+func makeResponse(status int) *gitlab.Response {
+	return &gitlab.Response{
+		Response: &http.Response{
+			StatusCode: status,
+		},
+	}
+}
+
+type MockOpts struct {
+	MergeId int
+}
+
+func NewMockClient(t *testing.T) *MockClientInterface {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	mockObj := NewMockClientInterface(ctrl)
+	return mockObj
+}
+
+/** Adds a handler to satisfy the withMrs middleware by returning an MR from that endpoint with the given ID */
+func WithMr(t *testing.T, m *MockClientInterface) *MockClientInterface {
+	options := gitlab.ListProjectMergeRequestsOptions{
+		Scope:        gitlab.Ptr("all"),
+		State:        gitlab.Ptr("opened"),
+		SourceBranch: gitlab.Ptr(""),
+	}
+
+	m.EXPECT().ListProjectMergeRequests("", &options).Return([]*gitlab.MergeRequest{{IID: MergeId}}, makeResponse(http.StatusOK), nil)
+
+	return m
+}
+
+type MockAttachmentReader struct{}
+
+func (mf MockAttachmentReader) ReadFile(path string) (io.Reader, error) {
+	return bytes.NewReader([]byte{}), nil
+}

cmd/pipeline.go

@@ -30,7 +30,7 @@ type GetPipelineAndJobsResponse struct {
 pipelineHandler fetches information about the current pipeline, and retriggers a pipeline run. For more detailed information
 about a given job in a pipeline, see the jobHandler function
 */
-func (a *api) pipelineHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) pipelineHandler(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
 		a.GetPipelineAndJobs(w, r)
@@ -44,22 +44,23 @@ func (a *api) pipelineHandler(w http.ResponseWriter, r *http.Request) {
 }
 
 /* Gets the latest pipeline for a given commit, returns an error if there is no pipeline */
-func (a *api) GetLastPipeline(commit string) (*gitlab.PipelineInfo, error) {
+func (a *Api) GetLastPipeline(commit string) (*gitlab.PipelineInfo, error) {
 
 	l := &gitlab.ListProjectPipelinesOptions{
 		SHA:  gitlab.Ptr(commit),
 		Sort: gitlab.Ptr("desc"),
 	}
 
-	l.Page = 1
-	l.PerPage = 1
-
-	pipes, _, err := a.client.ListProjectPipelines(a.projectInfo.ProjectId, l)
+	pipes, res, err := a.client.ListProjectPipelines(a.projectInfo.ProjectId, l)
 
 	if err != nil {
 		return nil, err
 	}
 
+	if res.StatusCode >= 300 {
+		return nil, errors.New("Could not get pipelines")
+	}
+
 	if len(pipes) == 0 {
 		return nil, errors.New("No pipeline running or available for commit " + commit)
 	}
@@ -68,13 +69,12 @@ func (a *api) GetLastPipeline(commit string) (*gitlab.PipelineInfo, error) {
 }
 
 /* Gets the latest pipeline and job information for the current branch */
-func (a *api) GetPipelineAndJobs(w http.ResponseWriter, r *http.Request) {
+func (a *Api) GetPipelineAndJobs(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	commit, err := a.gitInfo.GetLatestCommitOnRemote(a)
 
 	if err != nil {
-		fmt.Println(err)
 		handleError(w, err, "Error getting commit on remote branch", http.StatusInternalServerError)
 		return
 	}
@@ -121,7 +121,7 @@ func (a *api) GetPipelineAndJobs(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (a *api) RetriggerPipeline(w http.ResponseWriter, r *http.Request) {
+func (a *Api) RetriggerPipeline(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	id := strings.TrimPrefix(r.URL.Path, "/pipeline/trigger/")

cmd/pipeline_test.go

@@ -1,46 +1,23 @@
 package main
 
 import (
-	"errors"
+	"fmt"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
+	"go.uber.org/mock/gomock"
 )
 
-func listPipelineJobs(pid interface{}, pipelineID int, opts *gitlab.ListJobsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Job, *gitlab.Response, error) {
-	return []*gitlab.Job{}, makeResponse(http.StatusOK), nil
-}
+var testPipelineId = 12435
+var testPipelineCommit = "abc123"
+var fakeProjectPipelines = []*gitlab.PipelineInfo{{ID: testPipelineId}}
 
-func listPipelineJobsErr(pid interface{}, pipelineID int, opts *gitlab.ListJobsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Job, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
-func listPipelineJobsNon200(pid interface{}, pipelineID int, opts *gitlab.ListJobsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Job, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
-}
-
-func retryPipelineBuild(pid interface{}, pipeline int, options ...gitlab.RequestOptionFunc) (*gitlab.Pipeline, *gitlab.Response, error) {
-	return &gitlab.Pipeline{}, makeResponse(http.StatusOK), nil
-}
-
-func retryPipelineBuildErr(pid interface{}, pipeline int, options ...gitlab.RequestOptionFunc) (*gitlab.Pipeline, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
-func retryPipelineBuildNon200(pid interface{}, pipeline int, options ...gitlab.RequestOptionFunc) (*gitlab.Pipeline, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
-}
-
-func listProjectPipelines(pid interface{}, opt *gitlab.ListProjectPipelinesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.PipelineInfo, *gitlab.Response, error) {
-	return []*gitlab.PipelineInfo{
-		{ID: 12345},
-	}, makeResponse(http.StatusOK), nil
-}
-
-func withGitInfo(a *api) error {
-	a.gitInfo.GetLatestCommitOnRemote = func(a *api) (string, error) {
-		return "123abc", nil
+/* This helps us stub out git interactions that the server would normally run in the project directory */
+func withGitInfo(a *Api) error {
+	a.gitInfo.GetLatestCommitOnRemote = func(a *Api) (string, error) {
+		return testPipelineCommit, nil
 	}
 	a.gitInfo.BranchName = "some-feature"
 	return nil
@@ -48,74 +25,82 @@ func withGitInfo(a *api) error {
 
 func TestPipelineHandler(t *testing.T) {
 	t.Run("Gets all pipeline jobs", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().ListProjectPipelines("", gomock.Any()).Return(fakeProjectPipelines, makeResponse(http.StatusOK), nil)
+		client.EXPECT().ListPipelineJobs("", testPipelineId, &gitlab.ListJobsOptions{}).Return([]*gitlab.Job{}, makeResponse(http.StatusOK), nil)
+
 		request := makeRequest(t, http.MethodGet, "/pipeline", nil)
-		server, _ := createRouterAndApi(fakeClient{
-			listPipelineJobs:     listPipelineJobs,
-			listProjectPipelines: listProjectPipelines,
-		}, withGitInfo)
+		server, _ := CreateRouterAndApi(client, withGitInfo)
 		data := serveRequest(t, server, request, GetPipelineAndJobsResponse{})
+
 		assert(t, data.SuccessResponse.Message, "Pipeline retrieved")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Disallows non-GET, non-POST methods", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
 		request := makeRequest(t, http.MethodPatch, "/pipeline", nil)
-		server, _ := createRouterAndApi(fakeClient{
-			listPipelineJobs:     listPipelineJobs,
-			listProjectPipelines: listProjectPipelines,
-		}, withGitInfo)
+		server, _ := CreateRouterAndApi(client, withGitInfo)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkBadMethod(t, *data, http.MethodGet, http.MethodPost)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().ListProjectPipelines("", gomock.Any()).Return(fakeProjectPipelines, makeResponse(http.StatusOK), nil)
+		client.EXPECT().ListPipelineJobs("", testPipelineId, &gitlab.ListJobsOptions{}).Return(nil, nil, errorFromGitlab)
+
 		request := makeRequest(t, http.MethodGet, "/pipeline", nil)
-		server, _ := createRouterAndApi(fakeClient{
-			listPipelineJobs:     listPipelineJobsErr,
-			listProjectPipelines: listProjectPipelines,
-		}, withGitInfo)
+		server, _ := CreateRouterAndApi(client, withGitInfo)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkErrorFromGitlab(t, *data, "Could not get pipeline jobs")
 	})
 
 	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().ListProjectPipelines("", gomock.Any()).Return(fakeProjectPipelines, makeResponse(http.StatusOK), nil)
+		client.EXPECT().ListPipelineJobs("", testPipelineId, &gitlab.ListJobsOptions{}).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
 		request := makeRequest(t, http.MethodGet, "/pipeline", nil)
-		server, _ := createRouterAndApi(fakeClient{
-			listPipelineJobs:     listPipelineJobsNon200,
-			listProjectPipelines: listProjectPipelines,
-		}, withGitInfo)
+		server, _ := CreateRouterAndApi(client, withGitInfo)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkNon200(t, *data, "Could not get pipeline jobs", "/pipeline")
 	})
 
-	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/pipeline/trigger/1", nil)
-		server, _ := createRouterAndApi(fakeClient{
-			retryPipelineBuild:   retryPipelineBuildErr,
-			listProjectPipelines: listProjectPipelines,
-		}, withGitInfo)
-		data := serveRequest(t, server, request, ErrorResponse{})
-		checkErrorFromGitlab(t, *data, "Could not retrigger pipeline")
-	})
-
 	t.Run("Retriggers pipeline", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/pipeline/trigger/1", nil)
-		server, _ := createRouterAndApi(fakeClient{
-			retryPipelineBuild:   retryPipelineBuild,
-			listProjectPipelines: listProjectPipelines,
-		}, withGitInfo)
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().RetryPipelineBuild("", testPipelineId).Return(&gitlab.Pipeline{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, fmt.Sprintf("/pipeline/trigger/%d", testPipelineId), nil)
+		server, _ := CreateRouterAndApi(client, withGitInfo)
+
 		data := serveRequest(t, server, request, GetPipelineAndJobsResponse{})
 		assert(t, data.SuccessResponse.Message, "Pipeline retriggered")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Handles non-200s from Gitlab client on retrigger", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/pipeline/trigger/1", nil)
-		server, _ := createRouterAndApi(fakeClient{
-			retryPipelineBuild:   retryPipelineBuildNon200,
-			listProjectPipelines: listProjectPipelines,
-		}, withGitInfo)
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().RetryPipelineBuild("", testPipelineId).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodPost, fmt.Sprintf("/pipeline/trigger/%d", testPipelineId), nil)
+		server, _ := CreateRouterAndApi(client, withGitInfo)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkNon200(t, *data, "Could not retrigger pipeline", "/pipeline")
 	})
+
+	t.Run("Handles error from Gitlab client on retrigger", func(t *testing.T) {
+		client := mock_main.NewMockClient(t)
+		client.EXPECT().RetryPipelineBuild("", testPipelineId).Return(nil, nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodPost, fmt.Sprintf("/pipeline/trigger/%d", testPipelineId), nil)
+		server, _ := CreateRouterAndApi(client, withGitInfo)
+
+		data := serveRequest(t, server, request, ErrorResponse{})
+		checkErrorFromGitlab(t, *data, "Could not retrigger pipeline")
+	})
 }

cmd/reply.go

@@ -21,7 +21,7 @@ type ReplyResponse struct {
 }
 
 /* replyHandler sends a reply to a note or comment */
-func (a *api) replyHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) replyHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodPost {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodPost)

cmd/reply_test.go

@@ -1,51 +1,80 @@
 package main
 
 import (
-	"errors"
 	"net/http"
 	"testing"
 
 	"github.com/xanzy/go-gitlab"
+	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
+	"go.uber.org/mock/gomock"
 )
 
-func addMergeRequestDiscussionNote(pid interface{}, mergeRequest int, discussion string, opt *gitlab.AddMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
-	return &gitlab.Note{}, makeResponse(http.StatusOK), nil
-}
-
-func addMergeRequestDiscussionNoteErr(pid interface{}, mergeRequest int, discussion string, opt *gitlab.AddMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
-	return nil, nil, errors.New("Some error from Gitlab")
-}
-
-func addMergeRequestDiscussionNoteNon200(pid interface{}, mergeRequest int, discussion string, opt *gitlab.AddMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
-	return nil, makeResponse(http.StatusSeeOther), nil
+var testReplyRequest = ReplyRequest{
+	DiscussionId: "abc123",
+	Reply:        "Some Reply",
+	IsDraft:      false,
 }
 
 func TestReplyHandler(t *testing.T) {
 	t.Run("Sends a reply", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/reply", ReplyRequest{})
-		server, _ := createRouterAndApi(fakeClient{addMergeRequestDiscussionNote: addMergeRequestDiscussionNote})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().AddMergeRequestDiscussionNote(
+			"",
+			mock_main.MergeId,
+			testReplyRequest.DiscussionId,
+			gomock.Any(),
+		).Return(&gitlab.Note{}, makeResponse(http.StatusOK), nil)
+
+		request := makeRequest(t, http.MethodPost, "/mr/reply", testReplyRequest)
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, ReplyResponse{})
 		assert(t, data.SuccessResponse.Message, "Replied to comment")
 		assert(t, data.SuccessResponse.Status, http.StatusOK)
 	})
 
 	t.Run("Disallows non-POST methods", func(t *testing.T) {
-		request := makeRequest(t, http.MethodGet, "/mr/reply", ReplyRequest{})
-		server, _ := createRouterAndApi(fakeClient{addMergeRequestDiscussionNote: addMergeRequestDiscussionNote})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+
+		request := makeRequest(t, http.MethodPut, "/mr/reply", testReplyRequest)
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkBadMethod(t, *data, http.MethodPost)
 	})
 
 	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/reply", ReplyRequest{})
-		server, _ := createRouterAndApi(fakeClient{addMergeRequestDiscussionNote: addMergeRequestDiscussionNoteErr})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().AddMergeRequestDiscussionNote(
+			"",
+			mock_main.MergeId,
+			testReplyRequest.DiscussionId,
+			gomock.Any(),
+		).Return(nil, nil, errorFromGitlab)
+
+		request := makeRequest(t, http.MethodPost, "/mr/reply", testReplyRequest)
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkErrorFromGitlab(t, *data, "Could not leave reply")
 	})
 
 	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
-		request := makeRequest(t, http.MethodPost, "/mr/reply", ReplyRequest{})
-		server, _ := createRouterAndApi(fakeClient{addMergeRequestDiscussionNote: addMergeRequestDiscussionNoteNon200})
+		client := mock_main.NewMockClient(t)
+		mock_main.WithMr(t, client)
+		client.EXPECT().AddMergeRequestDiscussionNote(
+			"",
+			mock_main.MergeId,
+			testReplyRequest.DiscussionId,
+			gomock.Any(),
+		).Return(nil, makeResponse(http.StatusSeeOther), nil)
+
+		request := makeRequest(t, http.MethodPost, "/mr/reply", testReplyRequest)
+		server, _ := CreateRouterAndApi(client)
+
 		data := serveRequest(t, server, request, ErrorResponse{})
 		checkNon200(t, *data, "Could not leave reply", "/mr/reply")
 	})

cmd/resolve_discussion.go

@@ -15,7 +15,7 @@ type DiscussionResolveRequest struct {
 }
 
 /* discussionsResolveHandler sets a discussion to be "resolved" or not resolved, depending on the payload */
-func (a *api) discussionsResolveHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) discussionsResolveHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodPut {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodPut)

cmd/reviewer.go

@@ -23,7 +23,7 @@ type ReviewersRequestResponse struct {
 }
 
 /* reviewersHandler adds or removes reviewers from an MR */
-func (a *api) reviewersHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) reviewersHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodPut {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodPut)

cmd/revisions.go

@@ -16,7 +16,7 @@ type RevisionsResponse struct {
 revisionsHandler gets revision information about the current MR. This data is not used directly but is
 a precursor API call for other functionality
 */
-func (a *api) revisionsHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) revisionsHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodGet {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodGet)

cmd/revoke.go

@@ -6,7 +6,7 @@ import (
 )
 
 /* revokeHandler revokes approval for the current merge request */
-func (a *api) revokeHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) revokeHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodPost {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodPost)

cmd/server.go

@@ -19,24 +19,24 @@ to handle potential shutdown requests and incoming HTTP requests.
 */
 func startServer(client *Client, projectInfo *ProjectInfo, gitInfo GitProjectInfo) {
 
-	m, a := createRouterAndApi(client,
-		func(a *api) error {
+	m, a := CreateRouterAndApi(client,
+		func(a *Api) error {
 			a.projectInfo = projectInfo
 			return nil
 		},
-		func(a *api) error {
+		func(a *Api) error {
 			a.fileReader = attachmentReader{}
 			return nil
 		},
-		func(a *api) error {
+		func(a *Api) error {
 			a.gitInfo = &gitInfo
 			return nil
 		},
-		func(a *api) error {
+		func(a *Api) error {
 			err := attachEmojisToApi(a)
 			return err
 		},
-		func(a *api) error {
+		func(a *Api) error {
 			a.gitInfo.GetLatestCommitOnRemote = GetLatestCommitOnRemote
 			return nil
 		})
@@ -78,13 +78,13 @@ func startServer(client *Client, projectInfo *ProjectInfo, gitInfo GitProjectInf
 }
 
 /*
-The api struct contains common configuration that's accessible to all handlers, such as the gitlab
+The Api struct contains common configuration that's accessible to all handlers, such as the gitlab
 client, the project information, and the channels for signaling error or shutdown requests
 
-The handlers for different Gitlab operations are are all methods on the api struct and interact
+The handlers for different Gitlab operations are are all methods on the Api struct and interact
 with the client value, which is a go-gitlab client.
 */
-type api struct {
+type Api struct {
 	client      ClientInterface
 	projectInfo *ProjectInfo
 	gitInfo     *GitProjectInfo
@@ -93,17 +93,17 @@ type api struct {
 	sigCh       chan os.Signal
 }
 
-type optFunc func(a *api) error
+type optFunc func(a *Api) error
 
 /*
-createRouterAndApi wires up the router and attaches all handlers to their respective routes. It also
+CreateRouterAndApi wires up the router and attaches all handlers to their respective routes. It also
 iterates over all option functions to configure API fields such as the project information and default
 file reader functionality
 */
 
-func createRouterAndApi(client ClientInterface, optFuncs ...optFunc) (*http.ServeMux, api) {
+func CreateRouterAndApi(client ClientInterface, optFuncs ...optFunc) (*http.ServeMux, Api) {
 	m := http.NewServeMux()
-	a := api{
+	a := Api{
 		client:      client,
 		projectInfo: &ProjectInfo{},
 		gitInfo:     &GitProjectInfo{},
@@ -173,11 +173,7 @@ func checkServer(port int) error {
 
 /* Creates a TCP listener on the port specified by the user or a random port */
 func createListener() (l net.Listener) {
-	port := os.Args[2]
-	if port == "" {
-		port = "0"
-	}
-	addr := fmt.Sprintf("localhost:%s", port)
+	addr := fmt.Sprintf("localhost:%d", pluginOptions.Port)
 	l, err := net.Listen("tcp", addr)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error starting server: %s\n", err)
@@ -188,7 +184,7 @@ func createListener() (l net.Listener) {
 }
 
 /* withMr is a Middlware that gets the current merge request ID and attaches it to the projectInfo */
-func (a *api) withMr(f func(w http.ResponseWriter, r *http.Request)) func(http.ResponseWriter, *http.Request) {
+func (a *Api) withMr(f func(w http.ResponseWriter, r *http.Request)) func(http.ResponseWriter, *http.Request) {
 	return func(w http.ResponseWriter, r *http.Request) {
 
 		if a.projectInfo.MergeId != 0 {

cmd/shutdown.go

@@ -19,7 +19,7 @@ type ShutdownRequest struct {
 }
 
 /* shutdownHandler will shutdown the HTTP server and exit the process by signaling to the shutdown channel */
-func (a *api) shutdownHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) shutdownHandler(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {
 		w.Header().Set("Allow", http.MethodPost)
 		handleError(w, errors.New("Invalid request type"), "That request type is not allowed", http.StatusMethodNotAllowed)

cmd/summary.go

@@ -18,7 +18,7 @@ type SummaryUpdateResponse struct {
 	MergeRequest *gitlab.MergeRequest `json:"mr"`
 }
 
-func (a *api) summaryHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) summaryHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	if r.Method != http.MethodPut {

cmd/test.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -17,177 +18,7 @@ import (
 The FakeHandlerClient is used to create a fake gitlab client for testing our handlers, where the gitlab APIs are all mocked depending on what is provided during the variable initialization, so that we can simulate different responses from Gitlab
 */
 
-type fakeClient struct {
-	createMrFn                         func(pid interface{}, opt *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
-	getMergeRequest                    func(pid interface{}, mergeRequestIID int, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
-	updateMergeRequest                 func(pid interface{}, mergeRequestIID int, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
-	acceptMergeRequest                 func(pid interface{}, mergeRequestIID int, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
-	unapproveMergeRequest              func(pid interface{}, mergeRequestIID int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	uploadFile                         func(pid interface{}, content io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectFile, *gitlab.Response, error)
-	getMergeRequestDiffVersions        func(pid interface{}, mergeRequestIID int, opt *gitlab.GetMergeRequestDiffVersionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiffVersion, *gitlab.Response, error)
-	approveMergeRequest                func(pid interface{}, mergeRequestIID int, opt *gitlab.ApproveMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error)
-	listMergeRequestDiscussions        func(pid interface{}, mergeRequestIID int, opt *gitlab.ListMergeRequestDiscussionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error)
-	resolveMergeRequestDiscussion      func(pid interface{}, mergeRequestIID int, discussion string, opt *gitlab.ResolveMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error)
-	createMergeRequestDiscussion       func(pid interface{}, mergeRequestIID int, opt *gitlab.CreateMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error)
-	updateMergeRequestDiscussionNote   func(pid interface{}, mergeRequestIID int, discussion string, note int, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error)
-	deleteMergeRequestDiscussionNote   func(pid interface{}, mergeRequestIID int, discussion string, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	addMergeRequestDiscussionNote      func(pid interface{}, mergeRequestIID int, discussion string, opt *gitlab.AddMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error)
-	listAllProjectMembers              func(pid interface{}, opt *gitlab.ListProjectMembersOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.ProjectMember, *gitlab.Response, error)
-	retryPipelineBuild                 func(pid interface{}, pipeline int, options ...gitlab.RequestOptionFunc) (*gitlab.Pipeline, *gitlab.Response, error)
-	listPipelineJobs                   func(pid interface{}, pipelineID int, opts *gitlab.ListJobsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Job, *gitlab.Response, error)
-	listProjectPipelines               func(pid interface{}, opt *gitlab.ListProjectPipelinesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.PipelineInfo, *gitlab.Response, error)
-	getTraceFile                       func(pid interface{}, jobID int, options ...gitlab.RequestOptionFunc) (*bytes.Reader, *gitlab.Response, error)
-	listLabels                         func(pid interface{}, opt *gitlab.ListLabelsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Label, *gitlab.Response, error)
-	listMergeRequestAwardEmojiOnNote   func(pid interface{}, mergeRequestIID, noteID int, opt *gitlab.ListAwardEmojiOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.AwardEmoji, *gitlab.Response, error)
-	deleteMergeRequestAwardEmojiOnNote func(pid interface{}, mergeRequestIID, noteID, awardID int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	currentUser                        func(options ...gitlab.RequestOptionFunc) (*gitlab.User, *gitlab.Response, error)
-	createDraftNote                    func(pid interface{}, mergeRequestIID int, opt *gitlab.CreateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error)
-	listDraftNotes                     func(pid interface{}, mergeRequest int, opt *gitlab.ListDraftNotesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.DraftNote, *gitlab.Response, error)
-	deleteDraftNote                    func(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	updateDraftNote                    func(pid interface{}, mergeRequest int, note int, opt *gitlab.UpdateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error)
-	publishAllDraftNotes               func(pid interface{}, mergeRequest int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	publishDraftNote                   func(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	listProjectMergeRequests           func(pid interface{}, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error)
-}
-
-type Author struct {
-	ID        int    `json:"id"`
-	Username  string `json:"username"`
-	Email     string `json:"email"`
-	Name      string `json:"name"`
-	State     string `json:"state"`
-	AvatarURL string `json:"avatar_url"`
-	WebURL    string `json:"web_url"`
-}
-
-func (f fakeClient) CreateMergeRequest(pid interface{}, opt *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return f.createMrFn(pid, opt, options...)
-}
-
-func (f fakeClient) AcceptMergeRequest(pid interface{}, mergeRequestIID int, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return f.acceptMergeRequest(pid, mergeRequestIID, opt, options...)
-}
-
-func (f fakeClient) GetMergeRequest(pid interface{}, mergeRequestIID int, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return f.getMergeRequest(pid, mergeRequestIID, opt, options...)
-}
-
-func (f fakeClient) UpdateMergeRequest(pid interface{}, mergeRequestIID int, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
-	return f.updateMergeRequest(pid, mergeRequestIID, opt, options...)
-}
-
-func (f fakeClient) UnapproveMergeRequest(pid interface{}, mergeRequestIID int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return f.unapproveMergeRequest(pid, mergeRequestIID, options...)
-}
-
-func (f fakeClient) UploadFile(pid interface{}, content io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectFile, *gitlab.Response, error) {
-	return f.uploadFile(pid, content, filename, options...)
-}
-
-func (f fakeClient) GetMergeRequestDiffVersions(pid interface{}, mergeRequestIID int, opt *gitlab.GetMergeRequestDiffVersionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiffVersion, *gitlab.Response, error) {
-	return f.getMergeRequestDiffVersions(pid, mergeRequestIID, opt, options...)
-}
-
-func (f fakeClient) ApproveMergeRequest(pid interface{}, mergeRequestIID int, opt *gitlab.ApproveMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error) {
-	return f.approveMergeRequest(pid, mergeRequestIID, opt, options...)
-}
-
-func (f fakeClient) ListMergeRequestDiscussions(pid interface{}, mergeRequestIID int, opt *gitlab.ListMergeRequestDiscussionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error) {
-	return f.listMergeRequestDiscussions(pid, mergeRequestIID, opt, options...)
-}
-
-func (f fakeClient) ResolveMergeRequestDiscussion(pid interface{}, mergeRequestIID int, discussion string, opt *gitlab.ResolveMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
-	return f.resolveMergeRequestDiscussion(pid, mergeRequestIID, discussion, opt, options...)
-}
-
-func (f fakeClient) CreateMergeRequestDiscussion(pid interface{}, mergeRequestIID int, opt *gitlab.CreateMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
-	return f.createMergeRequestDiscussion(pid, mergeRequestIID, opt, options...)
-}
-
-func (f fakeClient) UpdateMergeRequestDiscussionNote(pid interface{}, mergeRequestIID int, discussion string, note int, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
-	return f.updateMergeRequestDiscussionNote(pid, mergeRequestIID, discussion, note, opt, options...)
-}
-
-func (f fakeClient) DeleteMergeRequestDiscussionNote(pid interface{}, mergeRequestIID int, discussion string, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return f.deleteMergeRequestDiscussionNote(pid, mergeRequestIID, discussion, note, options...)
-}
-
-func (f fakeClient) AddMergeRequestDiscussionNote(pid interface{}, mergeRequestIID int, discussion string, opt *gitlab.AddMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
-	return f.addMergeRequestDiscussionNote(pid, mergeRequestIID, discussion, opt, options...)
-}
-
-func (f fakeClient) ListAllProjectMembers(pid interface{}, opt *gitlab.ListProjectMembersOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.ProjectMember, *gitlab.Response, error) {
-	return f.listAllProjectMembers(pid, opt, options...)
-}
-
-func (f fakeClient) RetryPipelineBuild(pid interface{}, pipeline int, options ...gitlab.RequestOptionFunc) (*gitlab.Pipeline, *gitlab.Response, error) {
-	return f.retryPipelineBuild(pid, pipeline, options...)
-}
-
-func (f fakeClient) ListPipelineJobs(pid interface{}, pipelineID int, opts *gitlab.ListJobsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Job, *gitlab.Response, error) {
-	return f.listPipelineJobs(pid, pipelineID, opts, options...)
-}
-
-func (f fakeClient) ListProjectPipelines(pid interface{}, opt *gitlab.ListProjectPipelinesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.PipelineInfo, *gitlab.Response, error) {
-	return f.listProjectPipelines(pid, opt, options...)
-}
-
-func (f fakeClient) GetTraceFile(pid interface{}, jobID int, options ...gitlab.RequestOptionFunc) (*bytes.Reader, *gitlab.Response, error) {
-	return f.getTraceFile(pid, jobID, options...)
-}
-
-func (f fakeClient) ListLabels(pid interface{}, opt *gitlab.ListLabelsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Label, *gitlab.Response, error) {
-	return f.listLabels(pid, opt, options...)
-}
-
-func (f fakeClient) ListMergeRequestAwardEmojiOnNote(pid interface{}, mergeRequestIID int, noteID int, opt *gitlab.ListAwardEmojiOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.AwardEmoji, *gitlab.Response, error) {
-	return f.listMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, opt, options...)
-}
-
-func (f fakeClient) DeleteMergeRequestAwardEmojiOnNote(pid interface{}, mergeRequestIID, noteID, awardID int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return f.deleteMergeRequestAwardEmojiOnNote(pid, mergeRequestIID, noteID, awardID)
-}
-
-func (f fakeClient) CreateDraftNote(pid interface{}, mergeRequestIID int, opt *gitlab.CreateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error) {
-	return f.createDraftNote(pid, mergeRequestIID, opt)
-}
-
-func (f fakeClient) ListDraftNotes(pid interface{}, mergeRequestIID int, opt *gitlab.ListDraftNotesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.DraftNote, *gitlab.Response, error) {
-	return f.listDraftNotes(pid, mergeRequestIID, opt)
-}
-
-func (f fakeClient) CurrentUser(options ...gitlab.RequestOptionFunc) (*gitlab.User, *gitlab.Response, error) {
-	return f.currentUser()
-}
-
-func (f fakeClient) CreateMergeRequestAwardEmojiOnNote(pid interface{}, mergeRequestIID, noteID int, opt *gitlab.CreateAwardEmojiOptions, options ...gitlab.RequestOptionFunc) (*gitlab.AwardEmoji, *gitlab.Response, error) {
-	return &gitlab.AwardEmoji{}, &gitlab.Response{}, nil
-}
-
-func (f fakeClient) UpdateDraftNote(pid interface{}, mergeRequest int, note int, opt *gitlab.UpdateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error) {
-	return f.updateDraftNote(pid, mergeRequest, note, opt)
-}
-
-func (f fakeClient) DeleteDraftNote(pid interface{}, mergeRequestIID int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return f.deleteDraftNote(pid, mergeRequestIID, note)
-}
-
-func (f fakeClient) PublishDraftNote(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return f.publishDraftNote(pid, mergeRequest, note)
-}
-
-func (f fakeClient) PublishAllDraftNotes(pid interface{}, mergeRequest int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
-	return f.publishAllDraftNotes(pid, mergeRequest)
-}
-
-/* This middleware function needs to return an ID for the rest of the handlers */
-func (f fakeClient) ListProjectMergeRequests(pid interface{}, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error) {
-	if f.listProjectMergeRequests == nil {
-		return []*gitlab.MergeRequest{{ID: 1}}, &gitlab.Response{}, nil
-	} else {
-		return f.listProjectMergeRequests(pid, opt)
-	}
-}
+var errorFromGitlab = errors.New("Some error from Gitlab")
 
 /* The assert function is a helper function used to check two comparables */
 func assert[T comparable](t *testing.T, got T, want T) {
@@ -247,7 +78,7 @@ func checkErrorFromGitlab(t *testing.T, data ErrorResponse, msg string) {
 	t.Helper()
 	assert(t, data.Status, http.StatusInternalServerError)
 	assert(t, data.Message, msg)
-	assert(t, data.Details, "Some error from Gitlab")
+	assert(t, data.Details, errorFromGitlab.Error())
 }
 
 func checkBadMethod(t *testing.T, data ErrorResponse, methods ...string) {

cmd/user.go

@@ -12,7 +12,7 @@ type UserResponse struct {
 	User *gitlab.User `json:"user"`
 }
 
-func (a *api) meHandler(w http.ResponseWriter, r *http.Request) {
+func (a *Api) meHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	if r.Method != http.MethodGet {
 		w.Header().Set("Access-Control-Allow-Methods", http.MethodGet)