Fix MR Selection, Go Code Refactor (#358)

refactor: Refactors the Go codebase into a more modular and idiomatic approach
fix: require selection of specific MR when there are multiple targets for a given source branch
feat: Allows for the passing of Gitlab's filter options when choosing an MR, improves MR selection
feat: API to choose an MR from a list based on the provided username's involvement as an assignee/reviewer/author

This is a #MINOR release

cmd/app/approve.go

@@ -1,12 +1,23 @@
-package main
+package app
 
 import (
 	"encoding/json"
 	"net/http"
+
+	"github.com/xanzy/go-gitlab"
 )
 
+type MergeRequestApprover interface {
+	ApproveMergeRequest(pid interface{}, mr int, opt *gitlab.ApproveMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error)
+}
+
+type mergeRequestApproverService struct {
+	data
+	client MergeRequestApprover
+}
+
 /* approveHandler approves a merge request. */
-func (a *Api) approveHandler(w http.ResponseWriter, r *http.Request) {
+func (a mergeRequestApproverService) handler(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/app/approve_test.go

@@ -0,0 +1,55 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeApproverClient struct {
+	testBase
+}
+
+func (f fakeApproverClient) ApproveMergeRequest(pid interface{}, mr int, opt *gitlab.ApproveMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	return &gitlab.MergeRequestApprovals{}, resp, nil
+}
+
+func TestApproveHandler(t *testing.T) {
+	t.Run("Approves merge request", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/approve", nil)
+		client := fakeApproverClient{}
+		svc := mergeRequestApproverService{testProjectData, client}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Approved MR")
+		assert(t, data.Status, http.StatusOK)
+	})
+
+	t.Run("Disallows non-POST method", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/approve", nil)
+		client := fakeApproverClient{}
+		svc := mergeRequestApproverService{testProjectData, client}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodPost)
+	})
+
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/approve", nil)
+		client := fakeApproverClient{testBase{errFromGitlab: true}}
+		svc := mergeRequestApproverService{testProjectData, client}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not approve merge request")
+	})
+
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/approve", nil)
+		client := fakeApproverClient{testBase{status: http.StatusSeeOther}}
+		svc := mergeRequestApproverService{testProjectData, client}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not approve merge request", "/mr/approve")
+	})
+}

cmd/app/assignee.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -22,8 +22,13 @@ type AssigneesRequestResponse struct {
 	Assignees []int `json:"assignees"`
 }
 
+type assigneesService struct {
+	data
+	client MergeRequestUpdater
+}
+
 /* assigneesHandler adds or removes assignees from a merge request. */
-func (a *Api) assigneesHandler(w http.ResponseWriter, r *http.Request) {
+func (a assigneesService) handler(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/app/assignee_test.go

@@ -0,0 +1,57 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeAssigneeClient struct {
+	testBase
+}
+
+func (f fakeAssigneeClient) UpdateMergeRequest(pid interface{}, mergeRequest int, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	return &gitlab.MergeRequest{}, resp, nil
+}
+
+func TestAssigneeHandler(t *testing.T) {
+	var updatePayload = AssigneeUpdateRequest{Ids: []int{1, 2}}
+
+	t.Run("Updates assignees", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPut, "/mr/assignee", updatePayload)
+		client := fakeAssigneeClient{}
+		svc := assigneesService{testProjectData, client}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Assignees updated")
+		assert(t, data.Status, http.StatusOK)
+	})
+
+	t.Run("Disallows non-PUT method", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/assignee", nil)
+		client := fakeAssigneeClient{}
+		svc := assigneesService{testProjectData, client}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodPut)
+	})
+
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPut, "/mr/approve", updatePayload)
+		client := fakeAssigneeClient{testBase{errFromGitlab: true}}
+		svc := assigneesService{testProjectData, client}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not modify merge request assignees")
+	})
+
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPut, "/mr/approve", updatePayload)
+		client := fakeAssigneeClient{testBase{status: http.StatusSeeOther}}
+		svc := assigneesService{testProjectData, client}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not modify merge request assignees", "/mr/assignee")
+	})
+}

cmd/app/attachment.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"bytes"
@@ -7,6 +7,8 @@ import (
 	"io"
 	"net/http"
 	"os"
+
+	"github.com/xanzy/go-gitlab"
 )
 
 type FileReader interface {
@@ -45,8 +47,18 @@ func (ar attachmentReader) ReadFile(path string) (io.Reader, error) {
 	return reader, nil
 }
 
+type FileUploader interface {
+	UploadFile(pid interface{}, content io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectFile, *gitlab.Response, error)
+}
+
+type attachmentService struct {
+	data
+	fileReader FileReader
+	client     FileUploader
+}
+
 /* 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 attachmentService) handler(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/app/attachment_test.go

@@ -0,0 +1,64 @@
+package app
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeFileUploaderClient struct {
+	testBase
+}
+
+func (f fakeFileUploaderClient) UploadFile(pid interface{}, content io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectFile, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &gitlab.ProjectFile{}, resp, nil
+}
+
+type fakeFileReader struct{}
+
+func (f fakeFileReader) ReadFile(path string) (io.Reader, error) {
+	return &bytes.Reader{}, nil
+}
+
+func TestAttachmentHandler(t *testing.T) {
+	attachmentTestRequestData := AttachmentRequest{
+		FileName: "some_file_name",
+		FilePath: "some_file_path",
+	}
+
+	t.Run("Returns 200-status response after upload", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/attachment", attachmentTestRequestData)
+		svc := attachmentService{testProjectData, fakeFileReader{}, fakeFileUploaderClient{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Status, http.StatusOK)
+		assert(t, data.Message, "File uploaded successfully")
+	})
+
+	t.Run("Disallows non-POST method", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/attachment", nil)
+		svc := attachmentService{testProjectData, fakeFileReader{}, fakeFileUploaderClient{}}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodPost)
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/attachment", attachmentTestRequestData)
+		svc := attachmentService{testProjectData, fakeFileReader{}, fakeFileUploaderClient{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		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", attachmentTestRequestData)
+		svc := attachmentService{testProjectData, fakeFileReader{}, fakeFileUploaderClient{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not upload some_file_name to Gitlab", "/attachment")
+	})
+}

cmd/app/client.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"crypto/tls"
@@ -10,6 +10,7 @@ import (
 	"net/http/httputil"
 	"os"
 
+	"github.com/harrisoncramer/gitlab.nvim/cmd/app/git"
 	"github.com/hashicorp/go-retryablehttp"
 	"github.com/xanzy/go-gitlab"
 )
@@ -34,8 +35,8 @@ type Client struct {
 	*gitlab.DraftNotesService
 }
 
-/* initGitlabClient parses and validates the project settings and initializes the Gitlab client. */
-func initGitlabClient() (error, *Client) {
+/* NewClient parses and validates the project settings and initializes the Gitlab client. */
+func NewClient() (error, *Client) {
 
 	if pluginOptions.GitlabUrl == "" {
 		return errors.New("GitLab instance URL cannot be empty"), nil
@@ -86,11 +87,11 @@ func initGitlabClient() (error, *Client) {
 	}
 }
 
-/* initProjectSettings fetch the project ID using the client */
-func initProjectSettings(c *Client, gitInfo GitProjectInfo) (error, *ProjectInfo) {
+/* InitProjectSettings fetch the project ID using the client */
+func InitProjectSettings(c *Client, gitInfo git.GitData) (error, *ProjectInfo) {
 
 	opt := gitlab.GetProjectOptions{}
-	project, _, err := c.GetProject(gitInfo.projectPath(), &opt)
+	project, _, err := c.GetProject(gitInfo.ProjectPath(), &opt)
 
 	if err != nil {
 		return fmt.Errorf(fmt.Sprintf("Error getting project at %s", gitInfo.RemoteUrl), err), nil

cmd/app/comment.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -41,8 +41,19 @@ func (comment CommentWithPosition) GetPositionData() PositionData {
 	return comment.PositionData
 }
 
+type CommentManager interface {
+	CreateMergeRequestDiscussion(pid interface{}, mergeRequest int, opt *gitlab.CreateMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error)
+	UpdateMergeRequestDiscussionNote(pid interface{}, mergeRequest int, discussion string, note int, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error)
+	DeleteMergeRequestDiscussionNote(pid interface{}, mergeRequest int, discussion string, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
+}
+
+type commentService struct {
+	data
+	client CommentManager
+}
+
 /* commentHandler creates, edits, and deletes discussions (comments, multi-line comments) */
-func (a *Api) commentHandler(w http.ResponseWriter, r *http.Request) {
+func (a commentService) handler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	switch r.Method {
 	case http.MethodPost:
@@ -58,7 +69,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 commentService) 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 +110,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 commentService) 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 +167,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 commentService) editComment(w http.ResponseWriter, r *http.Request) {
 	body, err := io.ReadAll(r.Body)
 
 	if err != nil {

cmd/app/comment_helpers.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"crypto/sha1"

cmd/app/comment_test.go

@@ -0,0 +1,124 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeCommentClient struct {
+	testBase
+}
+
+func (f fakeCommentClient) CreateMergeRequestDiscussion(pid interface{}, mergeRequest int, opt *gitlab.CreateMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &gitlab.Discussion{Notes: []*gitlab.Note{{}}}, resp, err
+}
+func (f fakeCommentClient) UpdateMergeRequestDiscussionNote(pid interface{}, mergeRequest int, discussion string, note int, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &gitlab.Note{}, resp, err
+}
+
+func (f fakeCommentClient) DeleteMergeRequestDiscussionNote(pid interface{}, mergeRequest int, discussion string, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, err
+	}
+	return resp, err
+}
+
+func TestPostComment(t *testing.T) {
+	var testCommentCreationData = PostCommentRequest{Comment: "Some comment"}
+	t.Run("Creates a new note (unlinked comment)", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/comment", testCommentCreationData)
+		svc := commentService{testProjectData, fakeCommentClient{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Comment created successfully")
+		assert(t, data.Status, http.StatusOK)
+	})
+
+	t.Run("Creates a new comment", func(t *testing.T) {
+		testCommentCreationData := PostCommentRequest{ // Re-create comment creation data to avoid mutating this variable in other tests
+			Comment: "Some comment",
+			PositionData: PositionData{
+				FileName: "file.txt",
+			},
+		}
+		request := makeRequest(t, http.MethodPost, "/mr/comment", testCommentCreationData)
+		svc := commentService{testProjectData, fakeCommentClient{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Comment created successfully")
+		assert(t, data.Status, http.StatusOK)
+	})
+
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/comment", testCommentCreationData)
+		svc := commentService{testProjectData, fakeCommentClient{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not create discussion")
+	})
+
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/comment", testCommentCreationData)
+		svc := commentService{testProjectData, fakeCommentClient{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not create discussion", "/mr/comment")
+	})
+}
+
+func TestDeleteComment(t *testing.T) {
+	var testCommentDeletionData = DeleteCommentRequest{NoteId: 3, DiscussionId: "abc123"}
+	t.Run("Deletes a comment", func(t *testing.T) {
+		request := makeRequest(t, http.MethodDelete, "/mr/comment", testCommentDeletionData)
+		svc := commentService{testProjectData, fakeCommentClient{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Comment deleted successfully")
+		assert(t, data.Status, http.StatusOK)
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodDelete, "/mr/comment", testCommentDeletionData)
+		svc := commentService{testProjectData, fakeCommentClient{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not delete comment")
+	})
+
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodDelete, "/mr/comment", testCommentDeletionData)
+		svc := commentService{testProjectData, fakeCommentClient{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not delete comment", "/mr/comment")
+	})
+}
+
+func TestEditComment(t *testing.T) {
+	var testEditCommentData = EditCommentRequest{Comment: "Some comment", NoteId: 3, DiscussionId: "abc123"}
+	t.Run("Edits a comment", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPatch, "/mr/comment", testEditCommentData)
+		svc := commentService{testProjectData, fakeCommentClient{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Comment updated successfully")
+		assert(t, data.Status, http.StatusOK)
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPatch, "/mr/comment", testEditCommentData)
+		svc := commentService{testProjectData, fakeCommentClient{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not update comment")
+	})
+
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPatch, "/mr/comment", testEditCommentData)
+		svc := commentService{testProjectData, fakeCommentClient{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not update comment", "/mr/comment")
+	})
+}

cmd/app/config.go

@@ -0,0 +1,23 @@
+package app
+
+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"`
+	ChosenTargetBranch *string `json:"chosen_target_branch,omitempty"`
+	ConnectionSettings struct {
+		Insecure bool   `json:"insecure"`
+		Remote   string `json:"remote"`
+	} `json:"connection_settings"`
+}
+
+var pluginOptions PluginOptions
+
+func SetPluginOptions(p PluginOptions) {
+	pluginOptions = p
+}

cmd/app/create_mr.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -19,8 +19,17 @@ type CreateMrRequest struct {
 	TargetProjectID int    `json:"forked_project_id,omitempty"`
 }
 
+type MergeRequestCreator interface {
+	CreateMergeRequest(pid interface{}, opt *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
+}
+
+type mergeRequestCreatorService struct {
+	data
+	client MergeRequestCreator
+}
+
 /* createMr creates a merge request */
-func (a *Api) createMr(w http.ResponseWriter, r *http.Request) {
+func (a mergeRequestCreatorService) handler(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/app/create_mr_test.go

@@ -0,0 +1,80 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeMergeCreatorClient struct {
+	testBase
+}
+
+func (f fakeMergeCreatorClient) CreateMergeRequest(pid interface{}, opt *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	return &gitlab.MergeRequest{}, resp, nil
+}
+
+func TestCreateMr(t *testing.T) {
+	var testCreateMrRequestData = CreateMrRequest{
+		Title:        "Some title",
+		Description:  "Some description",
+		TargetBranch: "main",
+		DeleteBranch: false,
+		Squash:       false,
+	}
+	t.Run("Creates an MR", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/create_mr", testCreateMrRequestData)
+		svc := mergeRequestCreatorService{testProjectData, fakeMergeCreatorClient{}}
+		data := getSuccessData(t, svc, request)
+		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", testCreateMrRequestData)
+		svc := mergeRequestCreatorService{testProjectData, fakeMergeCreatorClient{}}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodPost)
+	})
+
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/create_mr", testCreateMrRequestData)
+		svc := mergeRequestCreatorService{testProjectData, fakeMergeCreatorClient{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not create MR")
+	})
+
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/create_mr", testCreateMrRequestData)
+		svc := mergeRequestCreatorService{testProjectData, fakeMergeCreatorClient{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not create MR", "/create_mr")
+	})
+
+	t.Run("Handles missing titles", func(t *testing.T) {
+		reqData := testCreateMrRequestData
+		reqData.Title = ""
+		request := makeRequest(t, http.MethodPost, "/create_mr", reqData)
+		svc := mergeRequestCreatorService{testProjectData, fakeMergeCreatorClient{}}
+		data := getFailData(t, svc, request)
+		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) {
+		reqData := testCreateMrRequestData
+		reqData.TargetBranch = ""
+		request := makeRequest(t, http.MethodPost, "/create_mr", reqData)
+		svc := mergeRequestCreatorService{testProjectData, fakeMergeCreatorClient{}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Status, http.StatusBadRequest)
+		assert(t, data.Message, "Could not create MR")
+		assert(t, data.Details, "Target branch cannot be empty")
+	})
+}

cmd/app/draft_note_publisher.go

@@ -0,0 +1,76 @@
+package app
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type DraftNotePublisher interface {
+	PublishAllDraftNotes(pid interface{}, mergeRequest int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
+	PublishDraftNote(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
+}
+
+type draftNotePublisherService struct {
+	data
+	client DraftNotePublisher
+}
+
+func (a draftNotePublisherService) handler(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
+	}
+
+	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 draftNotePublishRequest DraftNotePublishRequest
+	err = json.Unmarshal(body, &draftNotePublishRequest)
+
+	if err != nil {
+		handleError(w, err, "Could not read JSON from request", http.StatusBadRequest)
+		return
+	}
+
+	var res *gitlab.Response
+	if draftNotePublishRequest.PublishAll {
+		res, err = a.client.PublishAllDraftNotes(a.projectInfo.ProjectId, a.projectInfo.MergeId)
+	} else {
+		if draftNotePublishRequest.Note == 0 {
+			handleError(w, errors.New("No ID provided"), "Must provide Note ID", http.StatusBadRequest)
+			return
+		}
+		res, err = a.client.PublishDraftNote(a.projectInfo.ProjectId, a.projectInfo.MergeId, draftNotePublishRequest.Note)
+	}
+
+	if err != nil {
+		handleError(w, err, "Could not publish draft note(s)", http.StatusInternalServerError)
+		return
+	}
+
+	if res.StatusCode >= 300 {
+		handleError(w, GenericError{endpoint: "/mr/draft_notes/publish"}, "Could not publish dfaft note", res.StatusCode)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	response := SuccessResponse{
+		Message: "Draft note(s) published",
+		Status:  http.StatusOK,
+	}
+
+	err = json.NewEncoder(w).Encode(response)
+	if err != nil {
+		handleError(w, err, "Could not encode response", http.StatusInternalServerError)
+	}
+}

cmd/app/draft_note_publisher_test.go

@@ -0,0 +1,74 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeDraftNotePublisher struct {
+	testBase
+}
+
+func (f fakeDraftNotePublisher) PublishAllDraftNotes(pid interface{}, mergeRequest int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	return f.handleGitlabError()
+}
+func (f fakeDraftNotePublisher) PublishDraftNote(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	return f.handleGitlabError()
+}
+
+func TestPublishDraftNote(t *testing.T) {
+	var testDraftNotePublishRequest = DraftNotePublishRequest{Note: 3, PublishAll: false}
+	t.Run("Publishes draft note", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", testDraftNotePublishRequest)
+		svc := draftNotePublisherService{testProjectData, fakeDraftNotePublisher{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Status, http.StatusOK)
+		assert(t, data.Message, "Draft note(s) published")
+	})
+	t.Run("Disallows non-POST method", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/draft_notes/publish", testDraftNotePublishRequest)
+		svc := draftNotePublisherService{testProjectData, fakeDraftNotePublisher{}}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodPost)
+	})
+	t.Run("Handles bad ID", func(t *testing.T) {
+		badData := testDraftNotePublishRequest
+		badData.Note = 0
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", badData)
+		svc := draftNotePublisherService{testProjectData, fakeDraftNotePublisher{}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Status, http.StatusBadRequest)
+		assert(t, data.Message, "Must provide Note ID")
+	})
+	t.Run("Handles error from Gitlab", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", testDraftNotePublishRequest)
+		svc := draftNotePublisherService{testProjectData, fakeDraftNotePublisher{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not publish draft note(s)")
+	})
+}
+
+func TestPublishAllDraftNotes(t *testing.T) {
+	var testDraftNotePublishRequest = DraftNotePublishRequest{PublishAll: true}
+	t.Run("Should publish all draft notes", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", testDraftNotePublishRequest)
+		svc := draftNotePublisherService{testProjectData, fakeDraftNotePublisher{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Status, http.StatusOK)
+		assert(t, data.Message, "Draft note(s) published")
+	})
+	t.Run("Disallows non-POST method", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/draft_notes/publish", testDraftNotePublishRequest)
+		svc := draftNotePublisherService{testProjectData, fakeDraftNotePublisher{}}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodPost)
+	})
+	t.Run("Handles error from Gitlab", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/publish", testDraftNotePublishRequest)
+		svc := draftNotePublisherService{testProjectData, fakeDraftNotePublisher{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not publish draft note(s)")
+	})
+}

cmd/app/draft_notes.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -51,8 +51,20 @@ func (draftNote DraftNoteWithPosition) GetPositionData() PositionData {
 	return draftNote.PositionData
 }
 
+type DraftNoteManager interface {
+	ListDraftNotes(pid interface{}, mergeRequest int, opt *gitlab.ListDraftNotesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.DraftNote, *gitlab.Response, error)
+	CreateDraftNote(pid interface{}, mergeRequest int, opt *gitlab.CreateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error)
+	DeleteDraftNote(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
+	UpdateDraftNote(pid interface{}, mergeRequest int, note int, opt *gitlab.UpdateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error)
+}
+
+type draftNoteService struct {
+	data
+	client DraftNoteManager
+}
+
 /* draftNoteHandler creates, edits, and deletes draft notes */
-func (a *Api) draftNoteHandler(w http.ResponseWriter, r *http.Request) {
+func (a draftNoteService) handler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	switch r.Method {
 	case http.MethodGet:
@@ -69,54 +81,29 @@ func (a *Api) draftNoteHandler(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)
-		handleError(w, InvalidRequestError{}, "Expected POST", http.StatusMethodNotAllowed)
-		return
-	}
+/* listDraftNotes lists all draft notes for the currently authenticated user */
+func (a draftNoteService) listDraftNotes(w http.ResponseWriter, _ *http.Request) {
 
-	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 draftNotePublishRequest DraftNotePublishRequest
-	err = json.Unmarshal(body, &draftNotePublishRequest)
+	opt := gitlab.ListDraftNotesOptions{}
+	draftNotes, res, err := a.client.ListDraftNotes(a.projectInfo.ProjectId, a.projectInfo.MergeId, &opt)
 
 	if err != nil {
-		handleError(w, err, "Could not read JSON from request", http.StatusBadRequest)
-		return
-	}
-
-	var res *gitlab.Response
-	if draftNotePublishRequest.PublishAll {
-		res, err = a.client.PublishAllDraftNotes(a.projectInfo.ProjectId, a.projectInfo.MergeId)
-	} else {
-		if draftNotePublishRequest.Note == 0 {
-			handleError(w, errors.New("No ID provided"), "Must provide Note ID", http.StatusBadRequest)
-			return
-		}
-		res, err = a.client.PublishDraftNote(a.projectInfo.ProjectId, a.projectInfo.MergeId, draftNotePublishRequest.Note)
-	}
-
-	if err != nil {
-		handleError(w, err, "Could not publish draft note(s)", http.StatusInternalServerError)
+		handleError(w, err, "Could not get draft notes", http.StatusInternalServerError)
 		return
 	}
 
 	if res.StatusCode >= 300 {
-		handleError(w, GenericError{endpoint: "/mr/draft_notes/publish"}, "Could not publish dfaft note", res.StatusCode)
+		handleError(w, GenericError{endpoint: "/mr/draft_notes/"}, "Could not get draft notes", res.StatusCode)
 		return
 	}
 
 	w.WriteHeader(http.StatusOK)
-	response := SuccessResponse{
-		Message: "Draft note(s) published",
-		Status:  http.StatusOK,
+	response := ListDraftNotesResponse{
+		SuccessResponse: SuccessResponse{
+			Message: "Draft notes fetched successfully",
+			Status:  http.StatusOK,
+		},
+		DraftNotes: draftNotes,
 	}
 
 	err = json.NewEncoder(w).Encode(response)
@@ -126,7 +113,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 draftNoteService) 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 +171,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 draftNoteService) deleteDraftNote(w http.ResponseWriter, r *http.Request) {
 	suffix := strings.TrimPrefix(r.URL.Path, "/mr/draft_notes/")
 	id, err := strconv.Atoi(suffix)
 	if err != nil {
@@ -200,7 +187,7 @@ func (a *Api) deleteDraftNote(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if res.StatusCode >= 300 {
-		handleError(w, GenericError{endpoint: "/mr/draft_notes/"}, "Could not delete draft note", res.StatusCode)
+		handleError(w, GenericError{endpoint: fmt.Sprintf("/mr/draft_notes/%d", id)}, "Could not delete draft note", res.StatusCode)
 		return
 	}
 
@@ -217,7 +204,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 draftNoteService) updateDraftNote(w http.ResponseWriter, r *http.Request) {
 	suffix := strings.TrimPrefix(r.URL.Path, "/mr/draft_notes/")
 	id, err := strconv.Atoi(suffix)
 	if err != nil {
@@ -258,7 +245,7 @@ func (a *Api) updateDraftNote(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if res.StatusCode >= 300 {
-		handleError(w, GenericError{endpoint: "/mr/draft_notes/"}, "Could not update draft note", res.StatusCode)
+		handleError(w, GenericError{endpoint: fmt.Sprintf("/mr/draft_notes/%d", id)}, "Could not update draft note", res.StatusCode)
 		return
 	}
 
@@ -276,34 +263,3 @@ func (a *Api) updateDraftNote(w http.ResponseWriter, r *http.Request) {
 		handleError(w, err, "Could not encode response", http.StatusInternalServerError)
 	}
 }
-
-/* listDraftNotes lists all draft notes for the currently authenticated user */
-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)
-
-	if err != nil {
-		handleError(w, err, "Could not get draft notes", http.StatusInternalServerError)
-		return
-	}
-
-	if res.StatusCode >= 300 {
-		handleError(w, GenericError{endpoint: "/mr/draft/comment"}, "Could not get draft notes", res.StatusCode)
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
-	response := ListDraftNotesResponse{
-		SuccessResponse: SuccessResponse{
-			Message: "Draft notes fetched successfully",
-			Status:  http.StatusOK,
-		},
-		DraftNotes: draftNotes,
-	}
-
-	err = json.NewEncoder(w).Encode(response)
-	if err != nil {
-		handleError(w, err, "Could not encode response", http.StatusInternalServerError)
-	}
-}

cmd/app/draft_notes_test.go

@@ -0,0 +1,153 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeDraftNoteManager struct {
+	testBase
+}
+
+func (f fakeDraftNoteManager) ListDraftNotes(pid interface{}, mergeRequest int, opt *gitlab.ListDraftNotesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.DraftNote, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	return []*gitlab.DraftNote{}, resp, err
+}
+
+func (f fakeDraftNoteManager) CreateDraftNote(pid interface{}, mergeRequest int, opt *gitlab.CreateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	return &gitlab.DraftNote{}, resp, err
+}
+
+func (f fakeDraftNoteManager) DeleteDraftNote(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
+	return f.handleGitlabError()
+}
+
+func (f fakeDraftNoteManager) UpdateDraftNote(pid interface{}, mergeRequest int, note int, opt *gitlab.UpdateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	return &gitlab.DraftNote{}, resp, err
+}
+
+func TestListDraftNotes(t *testing.T) {
+	t.Run("Lists all draft notes", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/draft_notes/", nil)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Status, http.StatusOK)
+		assert(t, data.Message, "Draft notes fetched successfully")
+	})
+	t.Run("Handles error from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/draft_notes/", nil)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not get draft notes")
+	})
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/draft_notes/", nil)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not get draft notes", "/mr/draft_notes/")
+	})
+}
+
+func TestPostDraftNote(t *testing.T) {
+	var testPostDraftNoteRequestData = PostDraftNoteRequest{Comment: "Some comment"}
+	t.Run("Posts new draft note", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/", testPostDraftNoteRequestData)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Status, http.StatusOK)
+		assert(t, data.Message, "Draft note created successfully")
+	})
+	t.Run("Handles error from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/", testPostDraftNoteRequestData)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not create draft note")
+	})
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/draft_notes/", testPostDraftNoteRequestData)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not create draft note", "/mr/draft_notes/")
+	})
+}
+
+func TestDeleteDraftNote(t *testing.T) {
+	t.Run("Deletes new draft note", func(t *testing.T) {
+		request := makeRequest(t, http.MethodDelete, "/mr/draft_notes/3", nil)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Status, http.StatusOK)
+		assert(t, data.Message, "Draft note deleted")
+	})
+	t.Run("Handles error from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodDelete, "/mr/draft_notes/3", nil)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not delete draft note")
+	})
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodDelete, "/mr/draft_notes/3", nil)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not delete draft note", "/mr/draft_notes/3")
+	})
+	t.Run("Handles bad ID", func(t *testing.T) {
+		request := makeRequest(t, http.MethodDelete, "/mr/draft_notes/blah", nil)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Message, "Could not parse draft note ID")
+		assert(t, data.Status, http.StatusBadRequest)
+	})
+}
+
+func TestEditDraftNote(t *testing.T) {
+	var testUpdateDraftNoteRequest = UpdateDraftNoteRequest{Note: "Some new note"}
+	t.Run("Edits new draft note", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPatch, "/mr/draft_notes/3", testUpdateDraftNoteRequest)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Status, http.StatusOK)
+		assert(t, data.Message, "Draft note updated")
+	})
+	t.Run("Handles error from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPatch, "/mr/draft_notes/3", testUpdateDraftNoteRequest)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not update draft note")
+	})
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPatch, "/mr/draft_notes/3", testUpdateDraftNoteRequest)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not update draft note", "/mr/draft_notes/3")
+	})
+	t.Run("Handles bad ID", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPatch, "/mr/draft_notes/blah", testUpdateDraftNoteRequest)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		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) {
+		requestData := testUpdateDraftNoteRequest
+		requestData.Note = ""
+		request := makeRequest(t, http.MethodPatch, "/mr/draft_notes/3", requestData)
+		svc := draftNoteService{testProjectData, fakeDraftNoteManager{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Message, "Must provide draft note text")
+		assert(t, data.Status, http.StatusBadRequest)
+	})
+}

cmd/app/emoji.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -10,7 +10,6 @@ import (
 	"path"
 	"strconv"
 	"strings"
-	"sync"
 
 	"github.com/xanzy/go-gitlab"
 )
@@ -39,99 +38,17 @@ type CreateEmojiResponse struct {
 	Emoji *gitlab.AwardEmoji
 }
 
-/*
-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 {
-
-	e, err := os.Executable()
-	if err != nil {
-		return err
-	}
-
-	binPath := path.Dir(e)
-	filePath := fmt.Sprintf("%s/config/emojis.json", binPath)
-
-	reader, err := a.fileReader.ReadFile(filePath)
-
-	if err != nil {
-		return fmt.Errorf("Could not find emojis at %s", filePath)
-	}
-
-	bytes, err := io.ReadAll(reader)
-	if err != nil {
-		return errors.New("Could not read emoji file")
-	}
-
-	var emojiMap EmojiMap
-	err = json.Unmarshal(bytes, &emojiMap)
-	if err != nil {
-		return errors.New("Could not unmarshal emojis")
-	}
-
-	a.emojiMap = emojiMap
-	return nil
+type EmojiManager interface {
+	DeleteMergeRequestAwardEmojiOnNote(pid interface{}, mergeRequestIID int, noteID int, awardID int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
+	CreateMergeRequestAwardEmojiOnNote(pid interface{}, mergeRequestIID int, noteID int, opt *gitlab.CreateAwardEmojiOptions, options ...gitlab.RequestOptionFunc) (*gitlab.AwardEmoji, *gitlab.Response, 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) {
-	var wg sync.WaitGroup
-
-	emojis := make(map[int][]*gitlab.AwardEmoji)
-	mu := &sync.Mutex{}
-	errs := make(chan error, len(noteIDs))
-	emojiChan := make(chan struct {
-		noteID int
-		emojis []*gitlab.AwardEmoji
-	}, len(noteIDs))
-
-	for _, noteID := range noteIDs {
-		wg.Add(1)
-		go func(noteID int) {
-			defer wg.Done()
-			emojis, _, err := a.client.ListMergeRequestAwardEmojiOnNote(a.projectInfo.ProjectId, a.projectInfo.MergeId, noteID, &gitlab.ListAwardEmojiOptions{})
-			if err != nil {
-				errs <- err
-				return
-			}
-			emojiChan <- struct {
-				noteID int
-				emojis []*gitlab.AwardEmoji
-			}{noteID, emojis}
-		}(noteID)
-	}
-
-	/* Close the channels when all goroutines finish */
-	go func() {
-		wg.Wait()
-		close(errs)
-		close(emojiChan)
-	}()
-
-	/* Collect emojis */
-	for e := range emojiChan {
-		mu.Lock()
-		emojis[e.noteID] = e.emojis
-		mu.Unlock()
-	}
-
-	/* Check if any errors occurred */
-	if len(errs) > 0 {
-		for err := range errs {
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	return emojis, nil
+type emojiService struct {
+	data
+	client EmojiManager
 }
 
-func (a *Api) emojiNoteHandler(w http.ResponseWriter, r *http.Request) {
+func (a emojiService) handler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	switch r.Method {
 	case http.MethodPost:
@@ -145,7 +62,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 emojiService) deleteEmojiFromNote(w http.ResponseWriter, r *http.Request) {
 
 	suffix := strings.TrimPrefix(r.URL.Path, "/mr/awardable/note/")
 	ids := strings.Split(suffix, "/")
@@ -187,7 +104,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 emojiService) 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)
@@ -232,3 +149,38 @@ func (a *Api) postEmojiOnNote(w http.ResponseWriter, r *http.Request) {
 		handleError(w, err, "Could not encode response", http.StatusInternalServerError)
 	}
 }
+
+/*
+attachEmojis reads the emojis from our external JSON file
+and attaches them to the data so that they can be looked up later
+*/
+func attachEmojis(a *data, fr FileReader) error {
+
+	e, err := os.Executable()
+	if err != nil {
+		return err
+	}
+
+	binPath := path.Dir(e)
+	filePath := fmt.Sprintf("%s/config/emojis.json", binPath)
+
+	reader, err := fr.ReadFile(filePath)
+
+	if err != nil {
+		return fmt.Errorf("Could not find emojis at %s", filePath)
+	}
+
+	bytes, err := io.ReadAll(reader)
+	if err != nil {
+		return errors.New("Could not read emoji file")
+	}
+
+	var emojiMap EmojiMap
+	err = json.Unmarshal(bytes, &emojiMap)
+	if err != nil {
+		return errors.New("Could not unmarshal emojis")
+	}
+
+	a.emojiMap = emojiMap
+	return nil
+}

cmd/app/git/git.go

@@ -1,4 +1,4 @@
-package main
+package git
 
 import (
 	"fmt"
@@ -7,19 +7,27 @@ import (
 	"strings"
 )
 
-type GitProjectInfo struct {
-	RemoteUrl               string
-	Namespace               string
-	ProjectName             string
-	BranchName              string
-	GetLatestCommitOnRemote func(a *Api) (string, error)
+type GitManager interface {
+	RefreshProjectInfo(remote string) error
+	GetProjectUrlFromNativeGitCmd(remote string) (url string, err error)
+	GetCurrentBranchNameFromNativeGitCmd() (string, error)
+	GetLatestCommitOnRemote(remote string, branchName string) (string, error)
 }
 
+type GitData struct {
+	RemoteUrl   string
+	Namespace   string
+	ProjectName string
+	BranchName  string
+}
+
+type Git struct{}
+
 /*
 projectPath returns the Gitlab project full path, which isn't necessarily the same as its name.
 See https://docs.gitlab.com/ee/api/rest/index.html#namespaced-path-encoding for more information.
 */
-func (g GitProjectInfo) projectPath() string {
+func (g GitData) ProjectPath() string {
 	return g.Namespace + "/" + g.ProjectName
 }
 
@@ -28,15 +36,15 @@ Extracts information about the current repository and returns
 it to the client for initialization. The current directory must be a valid
 Gitlab project and the branch must be a feature branch
 */
-func extractGitInfo(refreshGitInfo func() error, getProjectRemoteUrl func() (string, error), getCurrentBranchName func() (string, error)) (GitProjectInfo, error) {
-	err := refreshGitInfo()
+func NewGitData(remote string, g GitManager) (GitData, error) {
+	err := g.RefreshProjectInfo(remote)
 	if err != nil {
-		return GitProjectInfo{}, fmt.Errorf("Could not get latest information from remote: %v", err)
+		return GitData{}, fmt.Errorf("Could not get latest information from remote: %v", err)
 	}
 
-	url, err := getProjectRemoteUrl()
+	url, err := g.GetProjectUrlFromNativeGitCmd(remote)
 	if err != nil {
-		return GitProjectInfo{}, fmt.Errorf("Could not get project Url: %v", err)
+		return GitData{}, fmt.Errorf("Could not get project Url: %v", err)
 	}
 
 	/*
@@ -54,18 +62,18 @@ func extractGitInfo(refreshGitInfo func() error, getProjectRemoteUrl func() (str
 	re := regexp.MustCompile(`(?:^https?:\/\/|^ssh:\/\/|^git@)(?:[^\/:]+)(?::\d+)?[\/:](.*)\/([^\/]+?)(?:\.git)?$`)
 	matches := re.FindStringSubmatch(url)
 	if len(matches) != 3 {
-		return GitProjectInfo{}, fmt.Errorf("Invalid Git URL format: %s", url)
+		return GitData{}, fmt.Errorf("Invalid Git URL format: %s", url)
 	}
 
 	namespace := matches[1]
 	projectName := matches[2]
 
-	branchName, err := getCurrentBranchName()
+	branchName, err := g.GetCurrentBranchNameFromNativeGitCmd()
 	if err != nil {
-		return GitProjectInfo{}, fmt.Errorf("Failed to get current branch: %v", err)
+		return GitData{}, fmt.Errorf("Failed to get current branch: %v", err)
 	}
 
-	return GitProjectInfo{
+	return GitData{
 			RemoteUrl:   url,
 			Namespace:   namespace,
 			ProjectName: projectName,
@@ -75,7 +83,7 @@ func extractGitInfo(refreshGitInfo func() error, getProjectRemoteUrl func() (str
 }
 
 /* Gets the current branch name */
-func GetCurrentBranchNameFromNativeGitCmd() (res string, e error) {
+func (g Git) GetCurrentBranchNameFromNativeGitCmd() (res string, e error) {
 	gitCmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
 
 	output, err := gitCmd.Output()
@@ -89,8 +97,8 @@ func GetCurrentBranchNameFromNativeGitCmd() (res string, e error) {
 }
 
 /* Gets the project SSH or HTTPS url */
-func GetProjectUrlFromNativeGitCmd() (string, error) {
-	cmd := exec.Command("git", "remote", "get-url", pluginOptions.ConnectionSettings.Remote)
+func (g Git) GetProjectUrlFromNativeGitCmd(remote string) (string, error) {
+	cmd := exec.Command("git", "remote", "get-url", remote)
 	url, err := cmd.Output()
 	if err != nil {
 		return "", fmt.Errorf("Could not get remote")
@@ -100,25 +108,22 @@ func GetProjectUrlFromNativeGitCmd() (string, error) {
 }
 
 /* Pulls down latest commit information from Gitlab */
-func RefreshProjectInfo() error {
-	cmd := exec.Command("git", "fetch", pluginOptions.ConnectionSettings.Remote)
+func (g Git) RefreshProjectInfo(remote string) error {
+	cmd := exec.Command("git", "fetch", remote)
 	_, err := cmd.Output()
 	if err != nil {
-		return fmt.Errorf("Failed to run `git fetch %s`: %v", pluginOptions.ConnectionSettings.Remote, err)
+		return fmt.Errorf("Failed to run `git fetch %s`: %v", 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.
-*/
-func GetLatestCommitOnRemote(a *Api) (string, error) {
-	cmd := exec.Command("git", "log", "-1", "--format=%H", fmt.Sprintf("%s/%s", pluginOptions.ConnectionSettings.Remote, a.gitInfo.BranchName))
+func (g Git) GetLatestCommitOnRemote(remote string, branchName string) (string, error) {
+	cmd := exec.Command("git", "log", "-1", "--format=%H", fmt.Sprintf("%s/%s", remote, branchName))
 
 	out, err := cmd.Output()
 	if err != nil {
-		return "", fmt.Errorf("Failed to run `git log -1 --format=%%H " + fmt.Sprintf("%s/%s", pluginOptions.ConnectionSettings.Remote, a.gitInfo.BranchName))
+		return "", fmt.Errorf("Failed to run `git log -1 --format=%%H " + fmt.Sprintf("%s/%s", remote, branchName))
 	}
 
 	commit := strings.TrimSpace(string(out))

cmd/app/git/git_test.go

@@ -0,0 +1,219 @@
+package git
+
+import (
+	"errors"
+	"testing"
+)
+
+type FakeGitManager struct {
+	RemoteUrl   string
+	BranchName  string
+	ProjectName string
+	Namespace   string
+}
+
+func (f FakeGitManager) RefreshProjectInfo(remote string) error {
+	return nil
+}
+
+func (f FakeGitManager) GetCurrentBranchNameFromNativeGitCmd() (string, error) {
+	return f.BranchName, nil
+}
+
+func (f FakeGitManager) GetLatestCommitOnRemote(remote string, branchName string) (string, error) {
+	return "", nil
+}
+
+func (f FakeGitManager) GetProjectUrlFromNativeGitCmd(string) (url string, err error) {
+	return f.RemoteUrl, nil
+}
+
+type TestCase struct {
+	desc        string
+	branch      string
+	projectName string
+	namespace   string
+	remote      string
+}
+
+func TestExtractGitInfo_Success(t *testing.T) {
+	testCases := []TestCase{
+		{
+			desc:        "Project configured in SSH under a single folder",
+			remote:      "git@custom-gitlab.com:namespace-1/project-name.git",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1",
+		},
+		{
+			desc:        "Project configured in SSH under a single folder without .git extension",
+			remote:      "git@custom-gitlab.com:namespace-1/project-name",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1",
+		},
+		{
+			desc:        "Project configured in SSH under one nested folder",
+			remote:      "git@custom-gitlab.com:namespace-1/namespace-2/project-name.git",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1/namespace-2",
+		},
+		{
+			desc:        "Project configured in SSH under two nested folders",
+			remote:      "git@custom-gitlab.com:namespace-1/namespace-2/namespace-3/project-name.git",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1/namespace-2/namespace-3",
+		},
+		{
+			desc:        "Project configured in SSH:// under a single folder",
+			remote:      "ssh://custom-gitlab.com/namespace-1/project-name.git",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1",
+		},
+		{
+			desc:        "Project configured in SSH:// under a single folder without .git extension",
+			remote:      "ssh://custom-gitlab.com/namespace-1/project-name",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1",
+		},
+		{
+			desc:        "Project configured in SSH:// under two nested folders",
+			remote:      "ssh://custom-gitlab.com/namespace-1/namespace-2/namespace-3/project-name.git",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1/namespace-2/namespace-3",
+		},
+		{
+			desc:        "Project configured in SSH:// and have a custom port",
+			remote:      "ssh://custom-gitlab.com:2222/namespace-1/project-name",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1",
+		},
+		{
+			desc:        "Project configured in HTTP and under a single folder without .git extension",
+			remote:      "http://custom-gitlab.com/namespace-1/project-name",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1",
+		},
+		{
+			desc:        "Project configured in HTTPS and under a single folder",
+			remote:      "https://custom-gitlab.com/namespace-1/project-name.git",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1",
+		},
+		{
+			desc:        "Project configured in HTTPS and under a nested folder",
+			remote:      "https://custom-gitlab.com/namespace-1/namespace-2/project-name.git",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1/namespace-2",
+		},
+		{
+			desc:        "Project configured in HTTPS and under two nested folders",
+			remote:      "https://custom-gitlab.com/namespace-1/namespace-2/namespace-3/project-name.git",
+			branch:      "feature/abc",
+			projectName: "project-name",
+			namespace:   "namespace-1/namespace-2/namespace-3",
+		},
+	}
+	for _, tC := range testCases {
+		t.Run(tC.desc, func(t *testing.T) {
+			g := FakeGitManager{
+				Namespace:   tC.namespace,
+				ProjectName: tC.projectName,
+				BranchName:  tC.branch,
+				RemoteUrl:   tC.remote,
+			}
+			data, err := NewGitData(tC.remote, g)
+			if err != nil {
+				t.Errorf("No error was expected, got %s", err)
+			}
+			if data.RemoteUrl != tC.remote {
+				t.Errorf("\nExpected Remote URL: %s\nActual:   %s", tC.remote, data.RemoteUrl)
+			}
+			if data.BranchName != tC.branch {
+				t.Errorf("\nExpected Branch Name: %s\nActual:   %s", tC.branch, data.BranchName)
+			}
+			if data.ProjectName != tC.projectName {
+				t.Errorf("\nExpected Project Name: %s\nActual:   %s", tC.projectName, data.ProjectName)
+			}
+			if data.Namespace != tC.namespace {
+				t.Errorf("\nExpected Namespace: %s\nActual:   %s", tC.namespace, data.Namespace)
+			}
+		})
+	}
+}
+
+type FailTestCase struct {
+	desc        string
+	errMsg      string
+	expectedErr string
+}
+
+type failingUrlManager struct {
+	errMsg string
+	FakeGitManager
+}
+
+func (f failingUrlManager) GetProjectUrlFromNativeGitCmd(string) (string, error) {
+	return "", errors.New(f.errMsg)
+}
+
+func TestExtractGitInfo_FailToGetProjectRemoteUrl(t *testing.T) {
+	tC := FailTestCase{
+		desc:        "Error returned by function to get the project remote url",
+		errMsg:      "Some error",
+		expectedErr: "Could not get project Url: Some error",
+	}
+	t.Run(tC.desc, func(t *testing.T) {
+		g := failingUrlManager{
+			errMsg: tC.errMsg,
+		}
+		_, err := NewGitData("", g)
+		if err == nil {
+			t.Errorf("Expected an error, got none")
+		}
+		if err.Error() != tC.expectedErr {
+			t.Errorf("\nExpected: %s\nActual:   %s", tC.expectedErr, err.Error())
+		}
+	})
+}
+
+type failingBranchManager struct {
+	errMsg string
+	FakeGitManager
+}
+
+func (f failingBranchManager) GetCurrentBranchNameFromNativeGitCmd() (string, error) {
+	return "", errors.New(f.errMsg)
+}
+
+func TestExtractGitInfo_FailToGetCurrentBranchName(t *testing.T) {
+	tC := FailTestCase{
+		desc:        "Error returned by function to get the project remote url",
+		errMsg:      "Some error",
+		expectedErr: "Failed to get current branch: Some error",
+	}
+	t.Run(tC.desc, func(t *testing.T) {
+		g := failingBranchManager{
+			FakeGitManager: FakeGitManager{
+				RemoteUrl: "git@custom-gitlab.com:namespace-1/project-name.git",
+			},
+			errMsg: tC.errMsg,
+		}
+		_, err := NewGitData("", g)
+		if err == nil {
+			t.Errorf("Expected an error, got none")
+		}
+		if err.Error() != tC.expectedErr {
+			t.Errorf("\nExpected: %s\nActual:   %s", tC.expectedErr, err.Error())
+		}
+	})
+}

cmd/app/info.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -12,8 +12,17 @@ type InfoResponse struct {
 	Info *gitlab.MergeRequest `json:"info"`
 }
 
+type MergeRequestGetter interface {
+	GetMergeRequest(pid interface{}, mergeRequest int, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
+}
+
+type infoService struct {
+	data
+	client MergeRequestGetter
+}
+
 /* 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 infoService) handler(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/app/info_test.go

@@ -0,0 +1,49 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeMergeRequestGetter struct {
+	testBase
+}
+
+func (f fakeMergeRequestGetter) GetMergeRequest(pid interface{}, mergeRequest int, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &gitlab.MergeRequest{}, resp, err
+}
+
+func TestInfoHandler(t *testing.T) {
+	t.Run("Returns normal information", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/info", nil)
+		svc := infoService{testProjectData, fakeMergeRequestGetter{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Merge requests retrieved")
+		assert(t, data.Status, http.StatusOK)
+	})
+	t.Run("Disallows non-GET methods", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/info", nil)
+		svc := infoService{testProjectData, fakeMergeRequestGetter{}}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodGet)
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/info", nil)
+		svc := infoService{testProjectData, fakeMergeRequestGetter{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not get project info")
+	})
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/info", nil)
+		svc := infoService{testProjectData, fakeMergeRequestGetter{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not get project info", "/mr/info")
+	})
+}

cmd/app/job.go

@@ -1,9 +1,12 @@
-package main
+package app
 
 import (
+	"bytes"
 	"encoding/json"
 	"io"
 	"net/http"
+
+	"github.com/xanzy/go-gitlab"
 )
 
 type JobTraceRequest struct {
@@ -15,8 +18,17 @@ type JobTraceResponse struct {
 	File string `json:"file"`
 }
 
+type TraceFileGetter interface {
+	GetTraceFile(pid interface{}, jobID int, options ...gitlab.RequestOptionFunc) (*bytes.Reader, *gitlab.Response, error)
+}
+
+type traceFileService struct {
+	data
+	client TraceFileGetter
+}
+
 /* 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 traceFileService) handler(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/app/job_test.go

@@ -0,0 +1,71 @@
+package app
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeTraceFileGetter struct {
+	testBase
+}
+
+func getTraceFileData(t *testing.T, svc ServiceWithHandler, request *http.Request) JobTraceResponse {
+	res := httptest.NewRecorder()
+	svc.handler(res, request)
+
+	var data JobTraceResponse
+	err := json.Unmarshal(res.Body.Bytes(), &data)
+	if err != nil {
+		t.Error(err)
+	}
+	return data
+}
+
+func (f fakeTraceFileGetter) GetTraceFile(pid interface{}, jobID int, options ...gitlab.RequestOptionFunc) (*bytes.Reader, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	re := bytes.NewReader([]byte("Some data"))
+	return re, resp, err
+}
+
+// var jobId = 0
+func TestJobHandler(t *testing.T) {
+	t.Run("Should read a job trace file", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/job", JobTraceRequest{})
+		client := fakeTraceFileGetter{}
+		svc := traceFileService{testProjectData, client}
+		data := getTraceFileData(t, svc, request)
+		assert(t, data.Message, "Log file read")
+		assert(t, data.Status, http.StatusOK)
+		assert(t, data.File, "Some data")
+	})
+	t.Run("Disallows non-GET methods", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/job", JobTraceRequest{})
+		client := fakeTraceFileGetter{}
+		svc := traceFileService{testProjectData, client}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodGet)
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/job", JobTraceRequest{})
+		client := fakeTraceFileGetter{testBase{errFromGitlab: true}}
+		svc := traceFileService{testProjectData, client}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not get trace file for job")
+	})
+
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/job", JobTraceRequest{})
+		client := fakeTraceFileGetter{testBase{status: http.StatusSeeOther}}
+		svc := traceFileService{testProjectData, client}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not get trace file for job", "/job")
+	})
+}

cmd/app/label.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -28,8 +28,18 @@ type LabelsRequestResponse struct {
 	Labels []Label `json:"labels"`
 }
 
+type LabelManager interface {
+	UpdateMergeRequest(interface{}, int, *gitlab.UpdateMergeRequestOptions, ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
+	ListLabels(interface{}, *gitlab.ListLabelsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Label, *gitlab.Response, error)
+}
+
+type labelService struct {
+	data
+	client LabelManager
+}
+
 /* 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 labelService) handler(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
 		a.getLabels(w, r)
@@ -42,7 +52,7 @@ func (a *Api) labelHandler(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (a *Api) getLabels(w http.ResponseWriter, r *http.Request) {
+func (a labelService) getLabels(w http.ResponseWriter, _ *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	labels, res, err := a.client.ListLabels(a.projectInfo.ProjectId, &gitlab.ListLabelsOptions{})
@@ -82,7 +92,7 @@ func (a *Api) getLabels(w http.ResponseWriter, r *http.Request) {
 
 }
 
-func (a *Api) updateLabels(w http.ResponseWriter, r *http.Request) {
+func (a labelService) updateLabels(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	body, err := io.ReadAll(r.Body)
 	if err != nil {

cmd/app/list_discussions.go

@@ -1,15 +1,25 @@
-package main
+package app
 
 import (
 	"io"
 	"net/http"
 	"sort"
+	"sync"
 
 	"encoding/json"
 
 	"github.com/xanzy/go-gitlab"
 )
 
+func Contains[T comparable](elems []T, v T) bool {
+	for _, s := range elems {
+		if v == s {
+			return true
+		}
+	}
+	return false
+}
+
 type DiscussionsRequest struct {
 	Blacklist []string `json:"blacklist"`
 }
@@ -37,11 +47,21 @@ func (n SortableDiscussions) Swap(i, j int) {
 	n[i], n[j] = n[j], n[i]
 }
 
+type DiscussionsLister interface {
+	ListMergeRequestDiscussions(pid interface{}, mergeRequest int, opt *gitlab.ListMergeRequestDiscussionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error)
+	ListMergeRequestAwardEmojiOnNote(pid interface{}, mergeRequestIID int, noteID int, opt *gitlab.ListAwardEmojiOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.AwardEmoji, *gitlab.Response, error)
+}
+
+type discussionsListerService struct {
+	data
+	client DiscussionsLister
+}
+
 /*
 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 discussionsListerService) handler(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)
@@ -86,7 +106,7 @@ func (a *Api) listDiscussionsHandler(w http.ResponseWriter, r *http.Request) {
 	var linkedDiscussions []*gitlab.Discussion
 
 	for _, discussion := range discussions {
-		if discussion.Notes == nil || len(discussion.Notes) == 0 || Contains(requestBody.Blacklist, discussion.Notes[0].Author.Username) > -1 {
+		if discussion.Notes == nil || len(discussion.Notes) == 0 || Contains(requestBody.Blacklist, discussion.Notes[0].Author.Username) {
 			continue
 		}
 		for _, note := range discussion.Notes {
@@ -136,3 +156,60 @@ func (a *Api) listDiscussionsHandler(w http.ResponseWriter, r *http.Request) {
 		handleError(w, err, "Could not encode response", http.StatusInternalServerError)
 	}
 }
+
+/*
+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 discussionsListerService) fetchEmojisForNotesAndComments(noteIDs []int) (map[int][]*gitlab.AwardEmoji, error) {
+	var wg sync.WaitGroup
+
+	emojis := make(map[int][]*gitlab.AwardEmoji)
+	mu := &sync.Mutex{}
+	errs := make(chan error, len(noteIDs))
+	emojiChan := make(chan struct {
+		noteID int
+		emojis []*gitlab.AwardEmoji
+	}, len(noteIDs))
+
+	for _, noteID := range noteIDs {
+		wg.Add(1)
+		go func(noteID int) {
+			defer wg.Done()
+			emojis, _, err := a.client.ListMergeRequestAwardEmojiOnNote(a.projectInfo.ProjectId, a.projectInfo.MergeId, noteID, &gitlab.ListAwardEmojiOptions{})
+			if err != nil {
+				errs <- err
+				return
+			}
+			emojiChan <- struct {
+				noteID int
+				emojis []*gitlab.AwardEmoji
+			}{noteID, emojis}
+		}(noteID)
+	}
+
+	/* Close the channels when all goroutines finish */
+	go func() {
+		wg.Wait()
+		close(errs)
+		close(emojiChan)
+	}()
+
+	/* Collect emojis */
+	for e := range emojiChan {
+		mu.Lock()
+		emojis[e.noteID] = e.emojis
+		mu.Unlock()
+	}
+
+	/* Check if any errors occurred */
+	if len(errs) > 0 {
+		for err := range errs {
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return emojis, nil
+}

cmd/app/list_discussions_test.go

@@ -0,0 +1,113 @@
+package app
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeDiscussionsLister struct {
+	testBase
+	badEmojiResponse bool
+}
+
+func (f fakeDiscussionsLister) ListMergeRequestDiscussions(pid interface{}, mergeRequest int, opt *gitlab.ListMergeRequestDiscussionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	now := time.Now()
+	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"`
+	}
+
+	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"}}}},
+	}
+	return testListDiscussionsResponse, resp, err
+}
+
+func (f fakeDiscussionsLister) ListMergeRequestAwardEmojiOnNote(pid interface{}, mergeRequestIID int, noteID int, opt *gitlab.ListAwardEmojiOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.AwardEmoji, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if f.badEmojiResponse {
+		return nil, nil, errors.New("Some error from emoji service")
+	}
+	return []*gitlab.AwardEmoji{}, resp, err
+}
+
+func getDiscussionsList(t *testing.T, svc ServiceWithHandler, request *http.Request) DiscussionsResponse {
+	res := httptest.NewRecorder()
+	svc.handler(res, request)
+
+	var data DiscussionsResponse
+	err := json.Unmarshal(res.Body.Bytes(), &data)
+	if err != nil {
+		t.Error(err)
+	}
+	return data
+}
+
+func TestListDiscussions(t *testing.T) {
+	t.Run("Returns sorted discussions", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/discussions/list", DiscussionsRequest{})
+		svc := discussionsListerService{testProjectData, fakeDiscussionsLister{}}
+		data := getDiscussionsList(t, svc, request)
+		assert(t, data.Message, "Discussions retrieved")
+		assert(t, data.SuccessResponse.Status, http.StatusOK)
+		assert(t, data.Discussions[0].Notes[0].Author.Username, "hcramer2") /* Sorting applied */
+		assert(t, data.Discussions[1].Notes[0].Author.Username, "hcramer")
+	})
+
+	t.Run("Uses blacklist to filter unwanted authors", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/discussions/list", DiscussionsRequest{Blacklist: []string{"hcramer"}})
+		svc := discussionsListerService{testProjectData, fakeDiscussionsLister{}}
+		data := getDiscussionsList(t, svc, request)
+		assert(t, data.SuccessResponse.Message, "Discussions retrieved")
+		assert(t, data.SuccessResponse.Status, http.StatusOK)
+		assert(t, len(data.Discussions), 1)
+		assert(t, data.Discussions[0].Notes[0].Author.Username, "hcramer2")
+	})
+	t.Run("Disallows non-GET methods", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/mr/discussions/list", DiscussionsRequest{})
+		svc := discussionsListerService{testProjectData, fakeDiscussionsLister{}}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodPost)
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/discussions/list", DiscussionsRequest{})
+		svc := discussionsListerService{testProjectData, fakeDiscussionsLister{testBase: testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not list discussions")
+	})
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/discussions/list", DiscussionsRequest{})
+		svc := discussionsListerService{testProjectData, fakeDiscussionsLister{testBase: testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not list discussions", "/mr/discussions/list")
+	})
+	t.Run("Handles error from emoji service", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/discussions/list", DiscussionsRequest{})
+		svc := discussionsListerService{testProjectData, fakeDiscussionsLister{badEmojiResponse: true}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Message, "Could not fetch emojis")
+		assert(t, data.Details, "Some error from emoji service")
+	})
+}

cmd/app/members.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -12,8 +12,17 @@ type ProjectMembersResponse struct {
 	ProjectMembers []*gitlab.ProjectMember
 }
 
+type ProjectMemberLister interface {
+	ListAllProjectMembers(pid interface{}, opt *gitlab.ListProjectMembersOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.ProjectMember, *gitlab.Response, error)
+}
+
+type projectMemberService struct {
+	data
+	client ProjectMemberLister
+}
+
 /* projectMembersHandler returns all members of the current Gitlab project */
-func (a *Api) projectMembersHandler(w http.ResponseWriter, r *http.Request) {
+func (a projectMemberService) handler(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/app/members_test.go

@@ -0,0 +1,48 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeMemberLister struct {
+	testBase
+}
+
+func (f fakeMemberLister) ListAllProjectMembers(pid interface{}, opt *gitlab.ListProjectMembersOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.ProjectMember, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	return []*gitlab.ProjectMember{}, resp, err
+}
+
+func TestMembersHandler(t *testing.T) {
+	t.Run("Returns project members", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/project/members", nil)
+		svc := projectMemberService{testProjectData, fakeMemberLister{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Status, http.StatusOK)
+		assert(t, data.Message, "Project members retrieved")
+	})
+	t.Run("Disallows non-GET methods", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/project/members", nil)
+		svc := projectMemberService{testProjectData, fakeMemberLister{}}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodGet)
+	})
+	t.Run("Handles error from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/project/members", nil)
+		svc := projectMemberService{testProjectData, fakeMemberLister{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not retrieve project members")
+	})
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/project/members", nil)
+		svc := projectMemberService{testProjectData, fakeMemberLister{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not retrieve project members", "/project/members")
+	})
+}

cmd/app/merge_mr.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -14,8 +14,17 @@ type AcceptMergeRequestRequest struct {
 	DeleteBranch  bool   `json:"delete_branch"`
 }
 
+type MergeRequestAccepter interface {
+	AcceptMergeRequest(pid interface{}, mergeRequest int, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
+}
+
+type mergeRequestAccepterService struct {
+	data
+	client MergeRequestAccepter
+}
+
 /* acceptAndMergeHandler merges a given merge request into the target branch */
-func (a *Api) acceptAndMergeHandler(w http.ResponseWriter, r *http.Request) {
+func (a mergeRequestAccepterService) handler(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/app/merge_mr_test.go

@@ -0,0 +1,50 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeMergeRequestAccepter struct {
+	testBase
+}
+
+func (f fakeMergeRequestAccepter) AcceptMergeRequest(pid interface{}, mergeRequest int, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &gitlab.MergeRequest{}, resp, err
+}
+
+func TestAcceptAndMergeHandler(t *testing.T) {
+	var testAcceptMergeRequestPayload = AcceptMergeRequestRequest{Squash: false, SquashMessage: "Squash me!", DeleteBranch: false}
+	t.Run("Accepts and merges a merge request", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/merge", testAcceptMergeRequestPayload)
+		svc := mergeRequestAccepterService{testProjectData, fakeMergeRequestAccepter{}}
+		data := getSuccessData(t, svc, request)
+		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.MethodPut, "/mr/merge", testAcceptMergeRequestPayload)
+		svc := mergeRequestAccepterService{testProjectData, fakeMergeRequestAccepter{}}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodPost)
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/merge", testAcceptMergeRequestPayload)
+		svc := mergeRequestAccepterService{testProjectData, fakeMergeRequestAccepter{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not merge MR")
+	})
+	t.Run("Handles non-200s from Gitlab", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/merge", testAcceptMergeRequestPayload)
+		svc := mergeRequestAccepterService{testProjectData, fakeMergeRequestAccepter{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not merge MR", "/mr/merge")
+	})
+}

cmd/app/merge_requests.go

@@ -1,26 +1,29 @@
-package main
+package app
 
 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) {
+type MergeRequestLister interface {
+	ListProjectMergeRequests(pid interface{}, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error)
+}
+
+type mergeRequestListerService struct {
+	data
+	client MergeRequestLister
+}
+
+func (a mergeRequestListerService) handler(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)
@@ -35,24 +38,25 @@ func (a *Api) mergeRequestsHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	defer r.Body.Close()
-	var listMergeRequestRequest ListMergeRequestRequest
+	var listMergeRequestRequest gitlab.ListProjectMergeRequestsOptions
 	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"),
-		Labels:    (*gitlab.LabelOptions)(&listMergeRequestRequest.Label),
-		NotLabels: (*gitlab.LabelOptions)(&listMergeRequestRequest.NotLabel),
+	if listMergeRequestRequest.State == nil {
+		listMergeRequestRequest.State = gitlab.Ptr("opened")
 	}
 
-	mergeRequests, res, err := a.client.ListProjectMergeRequests(a.projectInfo.ProjectId, &options)
+	if listMergeRequestRequest.Scope == nil {
+		listMergeRequestRequest.Scope = gitlab.Ptr("all")
+	}
+
+	mergeRequests, res, err := a.client.ListProjectMergeRequests(a.projectInfo.ProjectId, &listMergeRequestRequest)
 
 	if err != nil {
-		handleError(w, fmt.Errorf("Failed to list merge requests: %w", err), "Failed to list merge requests", http.StatusInternalServerError)
+		handleError(w, err, "Failed to list merge requests", http.StatusInternalServerError)
 		return
 	}
 

cmd/app/merge_requests_by_username.go

@@ -0,0 +1,162 @@
+package app
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"sync"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type MergeRequestListerByUsername interface {
+	ListProjectMergeRequests(pid interface{}, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error)
+}
+
+type mergeRequestListerByUsernameService struct {
+	data
+	client MergeRequestListerByUsername
+}
+
+type MergeRequestByUsernameRequest struct {
+	UserId   int    `json:"user_id"`
+	Username string `json:"username"`
+	State    string `json:"state,omitempty"`
+}
+
+func (a mergeRequestListerByUsernameService) handler(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
+	}
+
+	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 request MergeRequestByUsernameRequest
+	err = json.Unmarshal(body, &request)
+	if err != nil {
+		handleError(w, err, "Could not read JSON from request", http.StatusBadRequest)
+		return
+	}
+
+	if request.Username == "" {
+		handleError(w, errors.New("username is a required payload field"), "username is required", http.StatusBadRequest)
+		return
+	}
+
+	if request.UserId == 0 {
+		handleError(w, errors.New("user_id is a required payload field"), "user_id is required", http.StatusBadRequest)
+		return
+	}
+
+	if request.State == "" {
+		request.State = "opened"
+	}
+
+	payloads := []gitlab.ListProjectMergeRequestsOptions{
+		{
+			AuthorUsername: gitlab.Ptr(request.Username),
+			State:          gitlab.Ptr(request.State),
+			Scope:          gitlab.Ptr("all"),
+		},
+		{
+			ReviewerUsername: gitlab.Ptr(request.Username),
+			State:            gitlab.Ptr(request.State),
+			Scope:            gitlab.Ptr("all"),
+		},
+		{
+			AssigneeID: gitlab.AssigneeID(request.UserId),
+			State:      gitlab.Ptr(request.State),
+			Scope:      gitlab.Ptr("all"),
+		},
+	}
+
+	type apiResponse struct {
+		mrs []*gitlab.MergeRequest
+		err error
+	}
+
+	mrChan := make(chan apiResponse, len(payloads))
+	wg := sync.WaitGroup{}
+	go func() {
+		wg.Wait()
+		close(mrChan)
+	}()
+
+	for _, payload := range payloads {
+		wg.Add(1)
+		go func(p gitlab.ListProjectMergeRequestsOptions) {
+			defer wg.Done()
+			mrs, err := a.getMrs(&p)
+			mrChan <- apiResponse{mrs, err}
+		}(payload)
+	}
+
+	var mergeRequests []*gitlab.MergeRequest
+	existingIds := make(map[int]bool)
+	var errs []error
+	for res := range mrChan {
+		if res.err != nil {
+			errs = append(errs, res.err)
+		} else {
+			for _, mr := range res.mrs {
+				if !existingIds[mr.ID] {
+					mergeRequests = append(mergeRequests, mr)
+					existingIds[mr.ID] = true
+				}
+			}
+		}
+	}
+
+	if len(errs) > 0 {
+		combinedErr := ""
+		for _, err := range errs {
+			combinedErr += err.Error() + "; "
+		}
+		handleError(w, errors.New(combinedErr), "An error occurred", http.StatusInternalServerError)
+		return
+	}
+
+	if len(mergeRequests) == 0 {
+		handleError(w, fmt.Errorf("%s did not have any MRs", request.Username), "No MRs found", http.StatusNotFound)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	response := ListMergeRequestResponse{
+		SuccessResponse: SuccessResponse{
+			Message: fmt.Sprintf("Merge requests fetched for %s", request.Username),
+			Status:  http.StatusOK,
+		},
+		MergeRequests: mergeRequests,
+	}
+
+	err = json.NewEncoder(w).Encode(response)
+	if err != nil {
+		handleError(w, err, "Could not encode response", http.StatusInternalServerError)
+	}
+}
+
+func (a mergeRequestListerByUsernameService) getMrs(payload *gitlab.ListProjectMergeRequestsOptions) ([]*gitlab.MergeRequest, error) {
+	mrs, res, err := a.client.ListProjectMergeRequests(a.projectInfo.ProjectId, payload)
+	if err != nil {
+		return []*gitlab.MergeRequest{}, err
+	}
+
+	if res.StatusCode >= 300 {
+		return []*gitlab.MergeRequest{}, GenericError{endpoint: "/merge_requests_by_username"}
+	}
+
+	defer res.Body.Close()
+
+	return mrs, err
+}

cmd/app/merge_requests_by_username_test.go

@@ -0,0 +1,87 @@
+package app
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeMergeRequestListerByUsername struct {
+	testBase
+	emptyResponse bool
+}
+
+func (f fakeMergeRequestListerByUsername) ListProjectMergeRequests(pid interface{}, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if f.emptyResponse {
+		return []*gitlab.MergeRequest{}, resp, err
+	}
+
+	return []*gitlab.MergeRequest{{IID: 10}}, resp, err
+}
+
+func TestListMergeRequestByUsername(t *testing.T) {
+	var testListMrsByUsernamePayload = MergeRequestByUsernameRequest{Username: "hcramer", UserId: 1234, State: "opened"}
+	t.Run("Gets merge requests by username", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/merge_requests_by_username", testListMrsByUsernamePayload)
+		svc := mergeRequestListerByUsernameService{testProjectData, fakeMergeRequestListerByUsername{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Merge requests fetched for hcramer")
+		assert(t, data.Status, http.StatusOK)
+	})
+
+	t.Run("Should handle no merge requests", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/merge_requests_by_username", testListMrsByUsernamePayload)
+		svc := mergeRequestListerByUsernameService{testProjectData, fakeMergeRequestListerByUsername{emptyResponse: true}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Message, "No MRs found")
+		assert(t, data.Details, "hcramer did not have any MRs")
+		assert(t, data.Status, http.StatusNotFound)
+	})
+
+	t.Run("Should require username", func(t *testing.T) {
+		missingUsernamePayload := testListMrsByUsernamePayload
+		missingUsernamePayload.Username = ""
+		request := makeRequest(t, http.MethodPost, "/merge_requests_by_username", missingUsernamePayload)
+		svc := mergeRequestListerByUsernameService{testProjectData, fakeMergeRequestListerByUsername{}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Message, "username is required")
+		assert(t, data.Details, "username is a required payload field")
+		assert(t, data.Status, http.StatusBadRequest)
+	})
+
+	t.Run("Should require User ID for assignee call", func(t *testing.T) {
+		missingUsernamePayload := testListMrsByUsernamePayload
+		missingUsernamePayload.UserId = 0
+		request := makeRequest(t, http.MethodPost, "/merge_requests_by_username", missingUsernamePayload)
+		svc := mergeRequestListerByUsernameService{testProjectData, fakeMergeRequestListerByUsername{}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Message, "user_id is required")
+		assert(t, data.Details, "user_id is a required payload field")
+		assert(t, data.Status, http.StatusBadRequest)
+	})
+
+	t.Run("Should handle error from Gitlab", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/merge_requests_by_username", testListMrsByUsernamePayload)
+		svc := mergeRequestListerByUsernameService{testProjectData, fakeMergeRequestListerByUsername{testBase: testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Message, "An error occurred")
+		assert(t, data.Details, strings.Repeat("Some error from Gitlab; ", 3))
+		assert(t, data.Status, http.StatusInternalServerError)
+	})
+
+	t.Run("Handles non-200 from Gitlab", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/merge_requests_by_username", testListMrsByUsernamePayload)
+		svc := mergeRequestListerByUsernameService{testProjectData, fakeMergeRequestListerByUsername{testBase: testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Message, "An error occurred")
+		assert(t, data.Details, strings.Repeat("An error occurred on the /merge_requests_by_username endpoint; ", 3))
+		assert(t, data.Status, http.StatusInternalServerError)
+	})
+}

cmd/app/merge_requests_test.go

@@ -0,0 +1,58 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeMergeRequestLister struct {
+	testBase
+	emptyResponse bool
+}
+
+func (f fakeMergeRequestLister) ListProjectMergeRequests(pid interface{}, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if f.emptyResponse {
+		return []*gitlab.MergeRequest{}, resp, err
+	}
+
+	return []*gitlab.MergeRequest{{IID: 10}}, resp, err
+}
+
+func TestMergeRequestHandler(t *testing.T) {
+	var testListMergeRequestsRequest = gitlab.ListProjectMergeRequestsOptions{}
+	t.Run("Should fetch merge requests", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/merge_requests", testListMergeRequestsRequest)
+		svc := mergeRequestListerService{testProjectData, fakeMergeRequestLister{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Status, http.StatusOK)
+		assert(t, data.Message, "Merge requests fetched successfully")
+	})
+	t.Run("Handles error from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/merge_requests", testListMergeRequestsRequest)
+		svc := mergeRequestListerService{testProjectData, fakeMergeRequestLister{testBase: testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Failed to list merge requests")
+		assert(t, data.Status, http.StatusInternalServerError)
+	})
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/merge_requests", testListMergeRequestsRequest)
+		svc := mergeRequestListerService{testProjectData, fakeMergeRequestLister{testBase: testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Failed to list merge requests", "/merge_requests")
+		assert(t, data.Status, http.StatusSeeOther)
+	})
+	t.Run("Should handle not having any merge requests with 404", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/merge_requests", testListMergeRequestsRequest)
+		svc := mergeRequestListerService{testProjectData, fakeMergeRequestLister{emptyResponse: true}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Message, "No merge requests found")
+		assert(t, data.Status, http.StatusNotFound)
+	})
+}

cmd/app/pipeline.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -8,6 +8,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/harrisoncramer/gitlab.nvim/cmd/app/git"
 	"github.com/xanzy/go-gitlab"
 )
 
@@ -26,11 +27,23 @@ type GetPipelineAndJobsResponse struct {
 	Pipeline PipelineWithJobs `json:"latest_pipeline"`
 }
 
+type PipelineManager interface {
+	ListProjectPipelines(pid interface{}, opt *gitlab.ListProjectPipelinesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.PipelineInfo, *gitlab.Response, error)
+	ListPipelineJobs(pid interface{}, pipelineID int, opts *gitlab.ListJobsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Job, *gitlab.Response, error)
+	RetryPipelineBuild(pid interface{}, pipeline int, options ...gitlab.RequestOptionFunc) (*gitlab.Pipeline, *gitlab.Response, error)
+}
+
+type pipelineService struct {
+	data
+	client     PipelineManager
+	gitService git.GitManager
+}
+
 /*
 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 pipelineService) handler(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
 		a.GetPipelineAndJobs(w, r)
@@ -44,7 +57,7 @@ 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 pipelineService) GetLastPipeline(commit string) (*gitlab.PipelineInfo, error) {
 
 	l := &gitlab.ListProjectPipelinesOptions{
 		SHA:  gitlab.Ptr(commit),
@@ -69,10 +82,10 @@ 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 pipelineService) GetPipelineAndJobs(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
-	commit, err := a.gitInfo.GetLatestCommitOnRemote(a)
+	commit, err := a.gitService.GetLatestCommitOnRemote(pluginOptions.ConnectionSettings.Remote, a.gitInfo.BranchName)
 
 	if err != nil {
 		handleError(w, err, "Error getting commit on remote branch", http.StatusInternalServerError)
@@ -82,7 +95,7 @@ func (a *Api) GetPipelineAndJobs(w http.ResponseWriter, r *http.Request) {
 	pipeline, err := a.GetLastPipeline(commit)
 
 	if err != nil {
-		handleError(w, err, fmt.Sprintf("Gitlab failed to get latest pipeline for %s branch", a.gitInfo.BranchName), http.StatusInternalServerError)
+		handleError(w, err, fmt.Sprintf("Failed to get latest pipeline for %s branch", a.gitInfo.BranchName), http.StatusInternalServerError)
 		return
 	}
 
@@ -121,7 +134,7 @@ func (a *Api) GetPipelineAndJobs(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (a *Api) RetriggerPipeline(w http.ResponseWriter, r *http.Request) {
+func (a pipelineService) RetriggerPipeline(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	id := strings.TrimPrefix(r.URL.Path, "/pipeline/trigger/")

cmd/app/pipeline_test.go

@@ -0,0 +1,86 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakePipelineManager struct {
+	testBase
+}
+
+func (f fakePipelineManager) ListProjectPipelines(pid interface{}, opt *gitlab.ListProjectPipelinesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.PipelineInfo, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	return []*gitlab.PipelineInfo{{ID: 1234}}, resp, err
+}
+
+func (f fakePipelineManager) ListPipelineJobs(pid interface{}, pipelineID int, opts *gitlab.ListJobsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Job, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	return []*gitlab.Job{}, resp, err
+}
+
+func (f fakePipelineManager) RetryPipelineBuild(pid interface{}, pipeline int, options ...gitlab.RequestOptionFunc) (*gitlab.Pipeline, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+	return &gitlab.Pipeline{}, resp, err
+}
+
+func TestPipelineGetter(t *testing.T) {
+	t.Run("Gets all pipeline jobs", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/pipeline", nil)
+		svc := pipelineService{testProjectData, fakePipelineManager{}, FakeGitManager{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Pipeline retrieved")
+		assert(t, data.Status, http.StatusOK)
+	})
+	t.Run("Disallows non-GET, non-POST methods", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPatch, "/pipeline", nil)
+		svc := pipelineService{testProjectData, fakePipelineManager{}, FakeGitManager{}}
+		data := getFailData(t, svc, request)
+		checkBadMethod(t, data, http.MethodGet, http.MethodPost)
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/pipeline", nil)
+		svc := pipelineService{testProjectData, fakePipelineManager{testBase{errFromGitlab: true}}, FakeGitManager{}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Failed to get latest pipeline for some-branch branch")
+	})
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodGet, "/pipeline", nil)
+		svc := pipelineService{testProjectData, fakePipelineManager{testBase: testBase{status: http.StatusSeeOther}}, FakeGitManager{}}
+		data := getFailData(t, svc, request)
+		assert(t, data.Message, "Failed to get latest pipeline for some-branch branch") // Expected, we treat this as an error
+	})
+}
+
+func TestPipelineTrigger(t *testing.T) {
+	t.Run("Retriggers pipeline", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/pipeline/trigger/3", nil)
+		svc := pipelineService{testProjectData, fakePipelineManager{}, FakeGitManager{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Pipeline retriggered")
+		assert(t, data.Status, http.StatusOK)
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/pipeline/trigger/3", nil)
+		svc := pipelineService{testProjectData, fakePipelineManager{testBase{errFromGitlab: true}}, FakeGitManager{}}
+		data := getFailData(t, svc, request)
+		checkErrorFromGitlab(t, data, "Could not retrigger pipeline")
+	})
+	t.Run("Handles non-200s from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/pipeline/trigger/3", nil)
+		svc := pipelineService{testProjectData, fakePipelineManager{testBase: testBase{status: http.StatusSeeOther}}, FakeGitManager{}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not retrigger pipeline", "/pipeline")
+	})
+}

cmd/app/reply.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -20,8 +20,17 @@ type ReplyResponse struct {
 	Note *gitlab.Note `json:"note"`
 }
 
+type ReplyManager interface {
+	AddMergeRequestDiscussionNote(interface{}, int, string, *gitlab.AddMergeRequestDiscussionNoteOptions, ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error)
+}
+
+type replyService struct {
+	data
+	client ReplyManager
+}
+
 /* replyHandler sends a reply to a note or comment */
-func (a *Api) replyHandler(w http.ResponseWriter, r *http.Request) {
+func (a replyService) handler(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/app/reply_test.go

@@ -0,0 +1,45 @@
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/xanzy/go-gitlab"
+)
+
+type fakeReplyManager struct {
+	testBase
+}
+
+func (f fakeReplyManager) AddMergeRequestDiscussionNote(interface{}, int, string, *gitlab.AddMergeRequestDiscussionNoteOptions, ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error) {
+	resp, err := f.handleGitlabError()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &gitlab.Note{}, resp, err
+}
+
+func TestReplyHandler(t *testing.T) {
+	var testReplyRequest = ReplyRequest{DiscussionId: "abc123", Reply: "Some Reply", IsDraft: false}
+	t.Run("Sends a reply", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/reply", testReplyRequest)
+		svc := replyService{testProjectData, fakeReplyManager{}}
+		data := getSuccessData(t, svc, request)
+		assert(t, data.Message, "Replied to comment")
+		assert(t, data.Status, http.StatusOK)
+	})
+	t.Run("Handles errors from Gitlab client", func(t *testing.T) {
+		request := makeRequest(t, http.MethodPost, "/mr/reply", testReplyRequest)
+		svc := replyService{testProjectData, fakeReplyManager{testBase{errFromGitlab: true}}}
+		data := getFailData(t, svc, request)
+		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", testReplyRequest)
+		svc := replyService{testProjectData, fakeReplyManager{testBase{status: http.StatusSeeOther}}}
+		data := getFailData(t, svc, request)
+		checkNon200(t, data, "Could not leave reply", "/mr/reply")
+	})
+}

cmd/app/resolve_discussion.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -14,8 +14,17 @@ type DiscussionResolveRequest struct {
 	Resolved     bool   `json:"resolved"`
 }
 
+type DiscussionResolver interface {
+	ResolveMergeRequestDiscussion(pid interface{}, mergeRequest int, discussion string, opt *gitlab.ResolveMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error)
+}
+
+type discussionsResolutionService struct {
+	data
+	client DiscussionResolver
+}
+
 /* 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 discussionsResolutionService) handler(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/app/response_types.go

@@ -0,0 +1,30 @@
+package app
+
+import (
+	"fmt"
+)
+
+type ErrorResponse struct {
+	Message string `json:"message"`
+	Details string `json:"details"`
+	Status  int    `json:"status"`
+}
+
+type SuccessResponse struct {
+	Message string `json:"message"`
+	Status  int    `json:"status"`
+}
+
+type GenericError struct {
+	endpoint string
+}
+
+func (e GenericError) Error() string {
+	return fmt.Sprintf("An error occurred on the %s endpoint", e.endpoint)
+}
+
+type InvalidRequestError struct{}
+
+func (e InvalidRequestError) Error() string {
+	return "Invalid request type"
+}

cmd/app/reviewer.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -22,8 +22,17 @@ type ReviewersRequestResponse struct {
 	Reviewers []int `json:"reviewers"`
 }
 
+type MergeRequestUpdater interface {
+	UpdateMergeRequest(pid interface{}, mergeRequest int, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
+}
+
+type reviewerService struct {
+	data
+	client MergeRequestUpdater
+}
+
 /* reviewersHandler adds or removes reviewers from an MR */
-func (a *Api) reviewersHandler(w http.ResponseWriter, r *http.Request) {
+func (a reviewerService) handler(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/app/revisions.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -12,11 +12,20 @@ type RevisionsResponse struct {
 	Revisions []*gitlab.MergeRequestDiffVersion
 }
 
+type RevisionsGetter interface {
+	GetMergeRequestDiffVersions(pid interface{}, mergeRequest int, opt *gitlab.GetMergeRequestDiffVersionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiffVersion, *gitlab.Response, error)
+}
+
+type revisionsService struct {
+	data
+	client RevisionsGetter
+}
+
 /*
 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 revisionsService) handler(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/app/revoke.go

@@ -1,12 +1,23 @@
-package main
+package app
 
 import (
 	"encoding/json"
 	"net/http"
+
+	"github.com/xanzy/go-gitlab"
 )
 
+type MergeRequestRevoker interface {
+	UnapproveMergeRequest(interface{}, int, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
+}
+
+type mergeRequestRevokerService struct {
+	data
+	client MergeRequestRevoker
+}
+
 /* revokeHandler revokes approval for the current merge request */
-func (a *Api) revokeHandler(w http.ResponseWriter, r *http.Request) {
+func (a mergeRequestRevokerService) handler(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/app/server.go

@@ -0,0 +1,199 @@
+package app
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/harrisoncramer/gitlab.nvim/cmd/app/git"
+	"github.com/xanzy/go-gitlab"
+)
+
+/*
+startSever starts the server and runs concurrent goroutines
+to handle potential shutdown requests and incoming HTTP requests.
+*/
+func StartServer(client *Client, projectInfo *ProjectInfo, GitInfo git.GitData) {
+
+	s := shutdown{
+		sigCh: make(chan os.Signal, 1),
+	}
+
+	fr := attachmentReader{}
+	r := CreateRouter(
+		client,
+		projectInfo,
+		s,
+		func(a *data) error { a.projectInfo = projectInfo; return nil },
+		func(a *data) error { a.gitInfo = &GitInfo; return nil },
+		func(a *data) error { err := attachEmojis(a, fr); return err },
+	)
+	l := createListener()
+
+	server := &http.Server{Handler: r}
+
+	/* Starts the Go server */
+	go func() {
+		err := server.Serve(l)
+		if err != nil {
+			if errors.Is(err, http.ErrServerClosed) {
+				os.Exit(0)
+			} else {
+				fmt.Fprintf(os.Stderr, "Server did not respond: %s\n", err)
+				os.Exit(1)
+			}
+		}
+	}()
+
+	port := l.Addr().(*net.TCPAddr).Port
+	err := checkServer(port)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Server did not respond: %s\n", err)
+		os.Exit(1)
+	}
+
+	/* This print is detected by the Lua code */
+	fmt.Println("Server started on port: ", port)
+
+	/* Handles shutdown requests */
+	s.WatchForShutdown(server)
+}
+
+/*
+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
+*/
+
+type data struct {
+	projectInfo *ProjectInfo
+	gitInfo     *git.GitData
+	emojiMap    EmojiMap
+}
+
+type optFunc func(a *data) error
+
+func CreateRouter(gitlabClient *Client, projectInfo *ProjectInfo, s ShutdownHandler, optFuncs ...optFunc) *http.ServeMux {
+	m := http.NewServeMux()
+
+	d := data{
+		projectInfo: &ProjectInfo{},
+		gitInfo:     &git.GitData{},
+	}
+
+	/* Mutates the API struct as necessary with configuration functions */
+	for _, optFunc := range optFuncs {
+		err := optFunc(&d)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	m.HandleFunc("/mr/approve", withMr(mergeRequestApproverService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/comment", withMr(commentService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/merge", withMr(mergeRequestAccepterService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/discussions/list", withMr(discussionsListerService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/discussions/resolve", withMr(discussionsResolutionService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/info", withMr(infoService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/assignee", withMr(assigneesService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/summary", withMr(summaryService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/reviewer", withMr(reviewerService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/revisions", withMr(revisionsService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/reply", withMr(replyService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/label", withMr(labelService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/revoke", withMr(mergeRequestRevokerService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/awardable/note/", withMr(emojiService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/draft_notes/", withMr(draftNoteService{d, gitlabClient}, d, gitlabClient))
+	m.HandleFunc("/mr/draft_notes/publish", withMr(draftNotePublisherService{d, gitlabClient}, d, gitlabClient))
+
+	m.HandleFunc("/pipeline", pipelineService{d, gitlabClient, git.Git{}}.handler)
+	m.HandleFunc("/pipeline/trigger/", pipelineService{d, gitlabClient, git.Git{}}.handler)
+	m.HandleFunc("/users/me", meService{d, gitlabClient}.handler)
+	m.HandleFunc("/attachment", attachmentService{data: d, client: gitlabClient, fileReader: attachmentReader{}}.handler)
+	m.HandleFunc("/create_mr", mergeRequestCreatorService{d, gitlabClient}.handler)
+	m.HandleFunc("/job", traceFileService{d, gitlabClient}.handler)
+	m.HandleFunc("/project/members", projectMemberService{d, gitlabClient}.handler)
+	m.HandleFunc("/merge_requests", mergeRequestListerService{d, gitlabClient}.handler)
+	m.HandleFunc("/merge_requests_by_username", mergeRequestListerByUsernameService{d, gitlabClient}.handler)
+
+	m.HandleFunc("/shutdown", s.shutdownHandler)
+	m.Handle("/ping", http.HandlerFunc(pingHandler))
+
+	return m
+}
+
+/* Used to check whether the server has started yet */
+func pingHandler(w http.ResponseWriter, _ *http.Request) {
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprintln(w, "pong")
+}
+
+/* checkServer pings the server repeatedly for 1 full second after startup in order to notify the plugin that the server is ready */
+func checkServer(port int) error {
+	for i := 0; i < 10; i++ {
+		resp, err := http.Get("http://localhost:" + fmt.Sprintf("%d", port) + "/ping")
+		if resp.StatusCode == 200 && err == nil {
+			return nil
+		}
+		time.Sleep(100 * time.Microsecond)
+	}
+
+	return errors.New("Could not start server!")
+}
+
+/* Creates a TCP listener on the port specified by the user or a random port */
+func createListener() (l net.Listener) {
+	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)
+		os.Exit(1)
+	}
+
+	return l
+}
+
+type ServiceWithHandler interface {
+	handler(http.ResponseWriter, *http.Request)
+}
+
+/* withMr is a Middlware that gets the current merge request ID and attaches it to the projectInfo */
+func withMr(svc ServiceWithHandler, c data, client MergeRequestLister) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// If the merge request is already attached, skip the middleware logic
+		if c.projectInfo.MergeId == 0 {
+			options := gitlab.ListProjectMergeRequestsOptions{
+				Scope:        gitlab.Ptr("all"),
+				SourceBranch: &c.gitInfo.BranchName,
+				TargetBranch: pluginOptions.ChosenTargetBranch,
+			}
+
+			mergeRequests, _, err := client.ListProjectMergeRequests(c.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 len(mergeRequests) == 0 {
+				err := fmt.Errorf("No merge requests found for branch '%s'", c.gitInfo.BranchName)
+				handleError(w, err, "No merge requests found", http.StatusBadRequest)
+				return
+			}
+
+			if len(mergeRequests) > 1 {
+				err := errors.New("Please call gitlab.choose_merge_request()")
+				handleError(w, err, "Multiple MRs found", http.StatusBadRequest)
+				return
+			}
+
+			mergeIdInt := mergeRequests[0].IID
+			c.projectInfo.MergeId = mergeIdInt
+		}
+
+		// Call the next handler if middleware succeeds
+		svc.handler(w, r)
+	}
+}

cmd/app/shutdown.go

@@ -1,10 +1,13 @@
-package main
+package app
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io"
 	"net/http"
+	"os"
 )
 
 type killer struct{}
@@ -14,12 +17,33 @@ func (k killer) String() string {
 	return "0"
 }
 
+type ShutdownHandler interface {
+	WatchForShutdown(server *http.Server)
+	shutdownHandler(w http.ResponseWriter, r *http.Request)
+}
+
+type shutdown struct {
+	sigCh chan os.Signal
+}
+
+func (s shutdown) WatchForShutdown(server *http.Server) {
+	/* Handles shutdown requests */
+	<-s.sigCh
+	err := server.Shutdown(context.Background())
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Server could not shut down gracefully: %s\n", err)
+		os.Exit(1)
+	} else {
+		os.Exit(0)
+	}
+}
+
 type ShutdownRequest struct {
 	Restart bool `json:"restart"`
 }
 
 /* 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 (s shutdown) 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)
@@ -54,6 +78,6 @@ func (a *Api) shutdownHandler(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		handleError(w, err, "Could not encode response", http.StatusInternalServerError)
 	} else {
-		a.sigCh <- killer{}
+		s.sigCh <- killer{}
 	}
 }

cmd/app/summary.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -18,7 +18,12 @@ type SummaryUpdateResponse struct {
 	MergeRequest *gitlab.MergeRequest `json:"mr"`
 }
 
-func (a *Api) summaryHandler(w http.ResponseWriter, r *http.Request) {
+type summaryService struct {
+	data
+	client MergeRequestUpdater
+}
+
+func (a summaryService) handler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	if r.Method != http.MethodPut {

cmd/app/test_helpers.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"bytes"
@@ -11,13 +11,10 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/harrisoncramer/gitlab.nvim/cmd/app/git"
 	"github.com/xanzy/go-gitlab"
 )
 
-/*
-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
-*/
-
 var errorFromGitlab = errors.New("Some error from Gitlab")
 
 /* The assert function is a helper function used to check two comparables */
@@ -49,31 +46,63 @@ func makeRequest(t *testing.T, method string, endpoint string, body any) *http.R
 	return request
 }
 
-/* Serves and parses the JSON from an endpoint into the given type */
-func serveRequest[T any](t *testing.T, s *http.ServeMux, request *http.Request, i T) *T {
-	t.Helper()
-	recorder := httptest.NewRecorder()
-	s.ServeHTTP(recorder, request)
-	result := recorder.Result()
-	decoder := json.NewDecoder(result.Body)
-	err := decoder.Decode(&i)
-	if err != nil {
-		t.Fatal(err)
-		return nil
-	}
-
-	return &i
-}
-
 /* 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,
+			Body:       http.NoBody,
 		},
 	}
 }
 
+var testProjectData = data{
+	projectInfo: &ProjectInfo{},
+	gitInfo: &git.GitData{
+		BranchName: "some-branch",
+	},
+}
+
+func getSuccessData(t *testing.T, svc ServiceWithHandler, request *http.Request) SuccessResponse {
+	res := httptest.NewRecorder()
+	svc.handler(res, request)
+
+	var data SuccessResponse
+	err := json.Unmarshal(res.Body.Bytes(), &data)
+	if err != nil {
+		t.Error(err)
+	}
+	return data
+}
+
+func getFailData(t *testing.T, svc ServiceWithHandler, request *http.Request) ErrorResponse {
+	res := httptest.NewRecorder()
+	svc.handler(res, request)
+
+	var data ErrorResponse
+	err := json.Unmarshal(res.Body.Bytes(), &data)
+	if err != nil {
+		t.Error(err)
+	}
+	return data
+}
+
+type testBase struct {
+	errFromGitlab bool
+	status        int
+}
+
+// Helper for easily mocking bad responses or errors from Gitlab
+func (f *testBase) handleGitlabError() (*gitlab.Response, error) {
+	if f.errFromGitlab {
+		return nil, errorFromGitlab
+	}
+	if f.status == 0 {
+		f.status = 200
+	}
+	return makeResponse(f.status), nil
+}
+
 func checkErrorFromGitlab(t *testing.T, data ErrorResponse, msg string) {
 	t.Helper()
 	assert(t, data.Status, http.StatusInternalServerError)
@@ -95,3 +124,26 @@ func checkNon200(t *testing.T, data ErrorResponse, msg, endpoint string) {
 	assert(t, data.Message, msg)
 	assert(t, data.Details, fmt.Sprintf("An error occurred on the %s endpoint", endpoint))
 }
+
+type FakeGitManager struct {
+	RemoteUrl   string
+	BranchName  string
+	ProjectName string
+	Namespace   string
+}
+
+func (f FakeGitManager) RefreshProjectInfo(remote string) error {
+	return nil
+}
+
+func (f FakeGitManager) GetCurrentBranchNameFromNativeGitCmd() (string, error) {
+	return f.BranchName, nil
+}
+
+func (f FakeGitManager) GetLatestCommitOnRemote(remote string, branchName string) (string, error) {
+	return "", nil
+}
+
+func (f FakeGitManager) GetProjectUrlFromNativeGitCmd(string) (url string, err error) {
+	return f.RemoteUrl, nil
+}

cmd/app/user.go

@@ -1,4 +1,4 @@
-package main
+package app
 
 import (
 	"encoding/json"
@@ -12,7 +12,16 @@ type UserResponse struct {
 	User *gitlab.User `json:"user"`
 }
 
-func (a *Api) meHandler(w http.ResponseWriter, r *http.Request) {
+type MeGetter interface {
+	CurrentUser(options ...gitlab.RequestOptionFunc) (*gitlab.User, *gitlab.Response, error)
+}
+
+type meService struct {
+	data
+	client MeGetter
+}
+
+func (a meService) handler(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/approve_test.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-)
-
-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(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(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(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(client)
-		data := serveRequest(t, server, request, ErrorResponse{})
-
-		checkNon200(t, *data, "Could not approve merge request", "/mr/approve")
-	})
-}

cmd/assignee_test.go

@@ -1,69 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-	"go.uber.org/mock/gomock"
-)
-
-var updatePayload = AssigneeUpdateRequest{Ids: []int{1, 2}}
-
-func TestAssigneeHandler(t *testing.T) {
-	t.Run("Updates assignees", 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.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(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) {
-		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) {
-		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_test.go

@@ -1,69 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-)
-
-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) {
-		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) {
-		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) {
-		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) {
-		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/comment_test.go

@@ -1,182 +0,0 @@
-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"
-)
-
-var testCommentCreationData = PostCommentRequest{
-	Comment: "Some comment",
-}
-
-var testCommentDeletionData = DeleteCommentRequest{
-	NoteId:       3,
-	DiscussionId: "abc123",
-}
-
-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) {
-		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) {
-		// Re-create comment creation data to avoid mutating this variable in other tests
-		testCommentCreationData := PostCommentRequest{
-			Comment: "Some comment",
-			PositionData: PositionData{
-				FileName: "file.txt",
-			},
-		}
-
-		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) {
-		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) {
-		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 TestDeleteComment(t *testing.T) {
-	t.Run("Deletes a comment", func(t *testing.T) {
-		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) {
-		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) {
-		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 TestEditComment(t *testing.T) {
-	t.Run("Edits a comment", func(t *testing.T) {
-		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) {
-		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) {
-		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_test.go

@@ -1,99 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-	"go.uber.org/mock/gomock"
-)
-
-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)
-
-		request := makeRequest(t, http.MethodPost, "/create_mr", testCreateMrRequestData)
-		server, _ := CreateRouterAndApi(client)
-
-		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) {
-		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) {
-		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) {
-		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) {
-		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) {
-		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_test.go

@@ -1,247 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-	"go.uber.org/mock/gomock"
-)
-
-var testPostDraftNoteRequestData = PostDraftNoteRequest{
-	Comment: "Some comment",
-}
-
-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(client)
-		data := serveRequest(t, server, request, ListDraftNotesResponse{})
-
-		assert(t, data.SuccessResponse.Message, "Draft notes fetched successfully")
-		assert(t, data.SuccessResponse.Status, http.StatusOK)
-	})
-
-	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(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, errorFromGitlab.Error())
-	})
-}
-
-func TestPostDraftNote(t *testing.T) {
-	t.Run("Posts new draft note", func(t *testing.T) {
-		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")
-		assert(t, data.SuccessResponse.Status, http.StatusOK)
-	})
-
-	t.Run("Handles errors on draft note creation", func(t *testing.T) {
-		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, errorFromGitlab.Error())
-	})
-}
-
-func TestDeleteDraftNote(t *testing.T) {
-	t.Run("Deletes draft note", func(t *testing.T) {
-		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) {
-		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) {
-		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 TestEditDraftNote(t *testing.T) {
-	t.Run("Edits draft note", func(t *testing.T) {
-		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) {
-		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) {
-		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 TestPublishDraftNote(t *testing.T) {
-	t.Run("Should publish a draft note", func(t *testing.T) {
-		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) {
-		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) {
-		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 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(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(client)
-
-		data := serveRequest(t, server, request, ErrorResponse{})
-		assert(t, data.Message, "Could not publish draft note(s)")
-		assert(t, data.Status, http.StatusInternalServerError)
-	})
-}

cmd/git_test.go

@@ -1,272 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"testing"
-)
-
-func TestExtractGitInfo_Success(t *testing.T) {
-	getCurrentBranchName := func() (string, error) {
-		return "feature/abc", nil
-	}
-	refreshGitInfo := func() error {
-		return nil
-	}
-	testCases := []struct {
-		getProjectRemoteUrl func() (string, error)
-		expected            GitProjectInfo
-		desc                string
-	}{
-		{
-			desc: "Project configured in SSH under a single folder",
-			getProjectRemoteUrl: func() (string, error) {
-				return "git@custom-gitlab.com:namespace-1/project-name.git", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "git@custom-gitlab.com:namespace-1/project-name.git",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1",
-			},
-		},
-		{
-			desc: "Project configured in SSH under a single folder without .git extension",
-			getProjectRemoteUrl: func() (string, error) {
-				return "git@custom-gitlab.com:namespace-1/project-name", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "git@custom-gitlab.com:namespace-1/project-name",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1",
-			},
-		},
-		{
-			desc: "Project configured in SSH under one nested folder",
-			getProjectRemoteUrl: func() (string, error) {
-				return "git@custom-gitlab.com:namespace-1/namespace-2/project-name.git", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "git@custom-gitlab.com:namespace-1/namespace-2/project-name.git",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1/namespace-2",
-			},
-		},
-		{
-			desc: "Project configured in SSH under two nested folders",
-			getProjectRemoteUrl: func() (string, error) {
-				return "git@custom-gitlab.com:namespace-1/namespace-2/namespace-3/project-name.git", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "git@custom-gitlab.com:namespace-1/namespace-2/namespace-3/project-name.git",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1/namespace-2/namespace-3",
-			},
-		},
-		{
-			desc: "Project configured in SSH:// under a single folder",
-			getProjectRemoteUrl: func() (string, error) {
-				return "ssh://custom-gitlab.com/namespace-1/project-name.git", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "ssh://custom-gitlab.com/namespace-1/project-name.git",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1",
-			},
-		},
-		{
-			desc: "Project configured in SSH:// under a single folder without .git extension",
-			getProjectRemoteUrl: func() (string, error) {
-				return "ssh://custom-gitlab.com/namespace-1/project-name", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "ssh://custom-gitlab.com/namespace-1/project-name",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1",
-			},
-		},
-		{
-			desc: "Project configured in SSH:// under two nested folders",
-			getProjectRemoteUrl: func() (string, error) {
-				return "ssh://custom-gitlab.com/namespace-1/namespace-2/namespace-3/project-name.git", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "ssh://custom-gitlab.com/namespace-1/namespace-2/namespace-3/project-name.git",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1/namespace-2/namespace-3",
-			},
-		},
-		{
-			desc: "Project configured in SSH:// and have a custom port",
-			getProjectRemoteUrl: func() (string, error) {
-				return "ssh://custom-gitlab.com:2222/namespace-1/project-name", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "ssh://custom-gitlab.com:2222/namespace-1/project-name",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1",
-			},
-		},
-		{
-			desc: "Project configured in HTTP and under a single folder without .git extension",
-			getProjectRemoteUrl: func() (string, error) {
-				return "http://custom-gitlab.com/namespace-1/project-name", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "http://custom-gitlab.com/namespace-1/project-name",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1",
-			},
-		},
-		{
-			desc: "Project configured in HTTPS and under a single folder",
-			getProjectRemoteUrl: func() (string, error) {
-				return "https://custom-gitlab.com/namespace-1/project-name.git", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "https://custom-gitlab.com/namespace-1/project-name.git",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1",
-			},
-		},
-		{
-			desc: "Project configured in HTTPS and under a nested folder",
-			getProjectRemoteUrl: func() (string, error) {
-				return "https://custom-gitlab.com/namespace-1/namespace-2/project-name.git", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "https://custom-gitlab.com/namespace-1/namespace-2/project-name.git",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1/namespace-2",
-			},
-		},
-		{
-			desc: "Project configured in HTTPS and under two nested folders",
-			getProjectRemoteUrl: func() (string, error) {
-				return "https://custom-gitlab.com/namespace-1/namespace-2/namespace-3/project-name.git", nil
-			},
-			expected: GitProjectInfo{
-				RemoteUrl:   "https://custom-gitlab.com/namespace-1/namespace-2/namespace-3/project-name.git",
-				BranchName:  "feature/abc",
-				ProjectName: "project-name",
-				Namespace:   "namespace-1/namespace-2/namespace-3",
-			},
-		},
-	}
-	for _, tC := range testCases {
-		t.Run(tC.desc, func(t *testing.T) {
-			actual, err := extractGitInfo(refreshGitInfo, tC.getProjectRemoteUrl, getCurrentBranchName)
-			if err != nil {
-				t.Errorf("No error was expected, got %s", err)
-			}
-			if actual.RemoteUrl != tC.expected.RemoteUrl {
-				t.Errorf("\nExpected Remote URL: %s\nActual:   %s", tC.expected.RemoteUrl, actual.RemoteUrl)
-			}
-			if actual.BranchName != tC.expected.BranchName {
-				t.Errorf("\nExpected Branch Name: %s\nActual:   %s", tC.expected.BranchName, actual.BranchName)
-			}
-			if actual.ProjectName != tC.expected.ProjectName {
-				t.Errorf("\nExpected Project Name: %s\nActual:   %s", tC.expected.ProjectName, actual.ProjectName)
-			}
-			if actual.Namespace != tC.expected.Namespace {
-				t.Errorf("\nExpected Namespace: %s\nActual:   %s", tC.expected.Namespace, actual.Namespace)
-			}
-		})
-	}
-}
-
-func TestExtractGitInfo_FailToGetProjectRemoteUrl(t *testing.T) {
-	getCurrentBranchName := func() (string, error) {
-		return "feature/abc", nil
-	}
-	refreshGitInfo := func() error {
-		return nil
-	}
-	testCases := []struct {
-		getProjectRemoteUrl  func() (string, error)
-		expectedErrorMessage string
-		desc                 string
-	}{
-		{
-			desc: "Error returned by function to get the project remote url",
-			getProjectRemoteUrl: func() (string, error) {
-				return "", errors.New("error when getting project remote url")
-			},
-			expectedErrorMessage: "Could not get project Url: error when getting project remote url",
-		},
-		{
-			desc: "Invalid project remote url",
-			getProjectRemoteUrl: func() (string, error) {
-				return "git@invalid", nil
-			},
-			expectedErrorMessage: "Invalid Git URL format: git@invalid",
-		},
-	}
-	for _, tC := range testCases {
-		t.Run(tC.desc, func(t *testing.T) {
-			_, actualErr := extractGitInfo(refreshGitInfo, tC.getProjectRemoteUrl, getCurrentBranchName)
-			if actualErr == nil {
-				t.Errorf("Expected an error, got none")
-			}
-			if actualErr.Error() != tC.expectedErrorMessage {
-				t.Errorf("\nExpected: %s\nActual:   %s", tC.expectedErrorMessage, actualErr.Error())
-			}
-		})
-	}
-}
-
-func TestExtractGitInfo_FailToGetCurrentBranchName(t *testing.T) {
-	expectedErrNestedMsg := "error when getting current branch name"
-
-	refreshGitInfo := func() error {
-		return nil
-	}
-	_, actualErr := extractGitInfo(refreshGitInfo,
-		func() (string, error) {
-			return "git@custom-gitlab.com:namespace/project.git", nil
-		},
-		func() (string, error) {
-			return "", errors.New(expectedErrNestedMsg)
-		})
-
-	if actualErr == nil {
-		t.Errorf("Expected an error, got none")
-	}
-	expectedErr := fmt.Errorf("Failed to get current branch: %s", expectedErrNestedMsg)
-	if actualErr.Error() != expectedErr.Error() {
-		t.Errorf("\nExpected: %s\nActual:   %s", expectedErr, actualErr)
-	}
-}
-
-func TestRefreshGitRemote_FailToRefreshRemote(t *testing.T) {
-	expectedErrNestedMsg := "error when fetching commits"
-	_, actualErr := extractGitInfo(
-		func() error {
-			return errors.New(expectedErrNestedMsg)
-		},
-		func() (string, error) {
-			return "git@custom-gitlab.com:namespace/project.git", nil
-		},
-		func() (string, error) {
-			return "feature/abc", nil
-		},
-	)
-
-	if actualErr == nil {
-		t.Errorf("Expected an error, got none")
-	}
-	expectedErr := fmt.Errorf("Could not get latest information from remote: %s", expectedErrNestedMsg)
-	if actualErr.Error() != expectedErr.Error() {
-		t.Errorf("\nExpected: %s\nActual:   %s", expectedErr, actualErr)
-	}
-}

cmd/info_test.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-)
-
-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)
-		data := serveRequest(t, server, request, InfoResponse{})
-
-		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)
-
-		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)
-
-		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)
-
-		data := serveRequest(t, server, request, ErrorResponse{})
-		checkNon200(t, *data, "Could not get project info", "/mr/info")
-	})
-}

cmd/job_test.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"net/http"
-	"testing"
-
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-)
-
-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(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(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(client)
-		data := serveRequest(t, server, request, ErrorResponse{})
-
-		checkErrorFromGitlab(t, *data, "Could not get trace file for job")
-	})
-
-	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(client)
-		data := serveRequest(t, server, request, ErrorResponse{})
-
-		checkNon200(t, *data, "Could not get trace file for job", "/job")
-	})
-}

cmd/list_discussions_test.go

@@ -1,132 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-	"go.uber.org/mock/gomock"
-)
-
-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",
-				},
-			},
-		},
-	},
-}
-
-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(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 */
-		assert(t, data.Discussions[1].Notes[0].Author.Username, "hcramer")
-	})
-
-	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(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)
-		assert(t, data.Discussions[0].Notes[0].Author.Username, "hcramer2")
-	})
-
-	t.Run("Disallows non-POST method", func(t *testing.T) {
-		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(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(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(client)
-		data := serveRequest(t, server, request, ErrorResponse{})
-
-		checkErrorFromGitlab(t, *data, "Could not fetch emojis")
-
-	})
-}

cmd/main.go

@@ -4,47 +4,39 @@ import (
 	"encoding/json"
 	"log"
 	"os"
+
+	"github.com/harrisoncramer/gitlab.nvim/cmd/app"
+	"github.com/harrisoncramer/gitlab.nvim/cmd/app/git"
 )
 
-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
+var pluginOptions app.PluginOptions
 
 func main() {
 	log.SetFlags(0)
 
 	err := json.Unmarshal([]byte(os.Args[1]), &pluginOptions)
+	app.SetPluginOptions(pluginOptions)
+
 	if err != nil {
 		log.Fatalf("Failure parsing plugin settings: %v", err)
 	}
 
-	gitInfo, err := extractGitInfo(RefreshProjectInfo, GetProjectUrlFromNativeGitCmd, GetCurrentBranchNameFromNativeGitCmd)
+	gitManager := git.Git{}
+	gitData, err := git.NewGitData(pluginOptions.ConnectionSettings.Remote, gitManager)
+
 	if err != nil {
 		log.Fatalf("Failure initializing plugin: %v", err)
 	}
 
-	err, client := initGitlabClient()
+	err, client := app.NewClient()
 	if err != nil {
 		log.Fatalf("Failed to initialize Gitlab client: %v", err)
 	}
 
-	err, projectInfo := initProjectSettings(client, gitInfo)
+	err, projectInfo := app.InitProjectSettings(client, gitData)
 	if err != nil {
 		log.Fatalf("Failed to initialize project settings: %v", err)
 	}
 
-	startServer(client, projectInfo, gitInfo)
+	app.StartServer(client, projectInfo, gitData)
 }

cmd/members_test.go

@@ -1,56 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-	"go.uber.org/mock/gomock"
-)
-
-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(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(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(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(client)
-		data := serveRequest(t, server, request, ErrorResponse{})
-
-		checkNon200(t, *data, "Could not retrieve project members", "/project/members")
-	})
-}

cmd/merge_requests_test.go

@@ -1,73 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-	"go.uber.org/mock/gomock"
-)
-
-var testListMergeRequestsRequest = ListMergeRequestRequest{
-	Label:    []string{},
-	NotLabel: []string{},
-}
-
-func TestMergeRequestHandler(t *testing.T) {
-	t.Run("Should fetch merge requests", func(t *testing.T) {
-		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 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 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,67 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-	"go.uber.org/mock/gomock"
-)
-
-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) {
-		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) {
-		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) {
-		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) {
-		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

@@ -1,686 +0,0 @@
-// 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

@@ -1,60 +0,0 @@
-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_test.go

@@ -1,106 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-	"go.uber.org/mock/gomock"
-)
-
-var testPipelineId = 12435
-var testPipelineCommit = "abc123"
-var fakeProjectPipelines = []*gitlab.PipelineInfo{{ID: testPipelineId}}
-
-/* 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
-}
-
-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(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(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(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(client, withGitInfo)
-
-		data := serveRequest(t, server, request, ErrorResponse{})
-		checkNon200(t, *data, "Could not get pipeline jobs", "/pipeline")
-	})
-
-	t.Run("Retriggers pipeline", func(t *testing.T) {
-		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) {
-		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_test.go

@@ -1,81 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/xanzy/go-gitlab"
-	mock_main "gitlab.com/harrisoncramer/gitlab.nvim/cmd/mocks"
-	"go.uber.org/mock/gomock"
-)
-
-var testReplyRequest = ReplyRequest{
-	DiscussionId: "abc123",
-	Reply:        "Some Reply",
-	IsDraft:      false,
-}
-
-func TestReplyHandler(t *testing.T) {
-	t.Run("Sends a reply", func(t *testing.T) {
-		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) {
-		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) {
-		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) {
-		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/server.go

@@ -1,222 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net"
-	"net/http"
-	"os"
-	"strconv"
-	"time"
-
-	"github.com/xanzy/go-gitlab"
-)
-
-/*
-startSever starts the server and runs concurrent goroutines
-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 {
-			a.projectInfo = projectInfo
-			return nil
-		},
-		func(a *Api) error {
-			a.fileReader = attachmentReader{}
-			return nil
-		},
-		func(a *Api) error {
-			a.gitInfo = &gitInfo
-			return nil
-		},
-		func(a *Api) error {
-			err := attachEmojisToApi(a)
-			return err
-		},
-		func(a *Api) error {
-			a.gitInfo.GetLatestCommitOnRemote = GetLatestCommitOnRemote
-			return nil
-		})
-	l := createListener()
-	server := &http.Server{Handler: m}
-
-	/* Starts the Go server */
-	go func() {
-		err := server.Serve(l)
-		if err != nil {
-			if errors.Is(err, http.ErrServerClosed) {
-				os.Exit(0)
-			} else {
-				fmt.Fprintf(os.Stderr, "Server did not respond: %s\n", err)
-				os.Exit(1)
-			}
-		}
-	}()
-
-	port := l.Addr().(*net.TCPAddr).Port
-	err := checkServer(port)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Server did not respond: %s\n", err)
-		os.Exit(1)
-	}
-
-	/* This print is detected by the Lua code */
-	fmt.Println("Server started on port: ", port)
-
-	/* Handles shutdown requests */
-	<-a.sigCh
-	err = server.Shutdown(context.Background())
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Server could not shut down gracefully: %s\n", err)
-		os.Exit(1)
-	} else {
-		os.Exit(0)
-	}
-}
-
-/*
-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
-with the client value, which is a go-gitlab client.
-*/
-type Api struct {
-	client      ClientInterface
-	projectInfo *ProjectInfo
-	gitInfo     *GitProjectInfo
-	fileReader  FileReader
-	emojiMap    EmojiMap
-	sigCh       chan os.Signal
-}
-
-type optFunc func(a *Api) error
-
-/*
-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) {
-	m := http.NewServeMux()
-	a := Api{
-		client:      client,
-		projectInfo: &ProjectInfo{},
-		gitInfo:     &GitProjectInfo{},
-		fileReader:  nil,
-		emojiMap:    EmojiMap{},
-		sigCh:       make(chan os.Signal, 1),
-	}
-
-	/* Mutates the API struct as necessary with configuration functions */
-	for _, optFunc := range optFuncs {
-		err := optFunc(&a)
-		if err != nil {
-			panic(err)
-		}
-	}
-
-	m.HandleFunc("/mr/approve", a.withMr(a.approveHandler))
-	m.HandleFunc("/mr/comment", a.withMr(a.commentHandler))
-	m.HandleFunc("/mr/merge", a.withMr(a.acceptAndMergeHandler))
-	m.HandleFunc("/mr/discussions/list", a.withMr(a.listDiscussionsHandler))
-	m.HandleFunc("/mr/discussions/resolve", a.withMr(a.discussionsResolveHandler))
-	m.HandleFunc("/mr/info", a.withMr(a.infoHandler))
-	m.HandleFunc("/mr/assignee", a.withMr(a.assigneesHandler))
-	m.HandleFunc("/mr/summary", a.withMr(a.summaryHandler))
-	m.HandleFunc("/mr/reviewer", a.withMr(a.reviewersHandler))
-	m.HandleFunc("/mr/revisions", a.withMr(a.revisionsHandler))
-	m.HandleFunc("/mr/reply", a.withMr(a.replyHandler))
-	m.HandleFunc("/mr/label", a.withMr(a.labelHandler))
-	m.HandleFunc("/mr/revoke", a.withMr(a.revokeHandler))
-	m.HandleFunc("/mr/awardable/note/", a.withMr(a.emojiNoteHandler))
-	m.HandleFunc("/mr/draft_notes/", a.withMr(a.draftNoteHandler))
-	m.HandleFunc("/mr/draft_notes/publish", a.withMr(a.draftNotePublisher))
-
-	m.HandleFunc("/pipeline", a.pipelineHandler)
-	m.HandleFunc("/pipeline/trigger/", a.pipelineHandler)
-	m.HandleFunc("/users/me", a.meHandler)
-	m.HandleFunc("/attachment", a.attachmentHandler)
-	m.HandleFunc("/create_mr", a.createMr)
-	m.HandleFunc("/job", a.jobHandler)
-	m.HandleFunc("/project/members", a.projectMembersHandler)
-	m.HandleFunc("/shutdown", a.shutdownHandler)
-	m.HandleFunc("/merge_requests", a.mergeRequestsHandler)
-
-	m.Handle("/ping", http.HandlerFunc(pingHandler))
-
-	return m, a
-}
-
-/* Used to check whether the server has started yet */
-func pingHandler(w http.ResponseWriter, _ *http.Request) {
-	w.WriteHeader(http.StatusOK)
-	fmt.Fprintln(w, "pong")
-}
-
-/* checkServer pings the server repeatedly for 1 full second after startup in order to notify the plugin that the server is ready */
-func checkServer(port int) error {
-	for i := 0; i < 10; i++ {
-		resp, err := http.Get("http://localhost:" + fmt.Sprintf("%d", port) + "/ping")
-		if resp.StatusCode == 200 && err == nil {
-			return nil
-		}
-		time.Sleep(100 * time.Microsecond)
-	}
-
-	return errors.New("Could not start server!")
-}
-
-/* Creates a TCP listener on the port specified by the user or a random port */
-func createListener() (l net.Listener) {
-	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)
-		os.Exit(1)
-	}
-
-	return l
-}
-
-/* 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) {
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		if a.projectInfo.MergeId != 0 {
-			f(w, r)
-			return
-		}
-
-		options := gitlab.ListProjectMergeRequestsOptions{
-			Scope:        gitlab.Ptr("all"),
-			State:        gitlab.Ptr("opened"),
-			SourceBranch: &a.gitInfo.BranchName,
-		}
-
-		mergeRequests, _, 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 len(mergeRequests) == 0 {
-			handleError(w, fmt.Errorf("No merge requests found for branch '%s'", a.gitInfo.BranchName), "No merge requests found", http.StatusBadRequest)
-			return
-		}
-
-		mergeId := strconv.Itoa(mergeRequests[0].IID)
-		mergeIdInt, err := strconv.Atoi(mergeId)
-		if err != nil {
-			handleError(w, err, "Could not convert merge ID to integer", http.StatusBadRequest)
-			return
-		}
-
-		a.projectInfo.MergeId = mergeIdInt
-		f(w, r)
-	}
-}

cmd/types.go

@@ -1,69 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-
-	"github.com/xanzy/go-gitlab"
-)
-
-type ErrorResponse struct {
-	Message string `json:"message"`
-	Details string `json:"details"`
-	Status  int    `json:"status"`
-}
-
-type SuccessResponse struct {
-	Message string `json:"message"`
-	Status  int    `json:"status"`
-}
-
-type GenericError struct {
-	endpoint string
-}
-
-func (e GenericError) Error() string {
-	return fmt.Sprintf("An error occurred on the %s endpoint", e.endpoint)
-}
-
-type InvalidRequestError struct{}
-
-func (e InvalidRequestError) Error() string {
-	return "Invalid request type"
-}
-
-/* The ClientInterface interface implements all the methods that our handlers need */
-type ClientInterface interface {
-	CreateMergeRequest(pid interface{}, opt *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
-	ListProjectMergeRequests(pid interface{}, opt *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequest, *gitlab.Response, error)
-	GetMergeRequest(pid interface{}, mergeRequestIID int, opt *gitlab.GetMergeRequestsOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
-	AcceptMergeRequest(pid interface{}, mergeRequestIID int, opt *gitlab.AcceptMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
-	UpdateMergeRequest(pid interface{}, mergeRequestIID int, opt *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error)
-	UploadFile(pid interface{}, content io.Reader, filename string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectFile, *gitlab.Response, error)
-	GetMergeRequestDiffVersions(pid interface{}, mergeRequestIID int, opt *gitlab.GetMergeRequestDiffVersionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.MergeRequestDiffVersion, *gitlab.Response, error)
-	ApproveMergeRequest(pid interface{}, mergeRequestIID int, opt *gitlab.ApproveMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequestApprovals, *gitlab.Response, error)
-	UnapproveMergeRequest(pid interface{}, mergeRequestIID int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	ListMergeRequestDiscussions(pid interface{}, mergeRequestIID int, opt *gitlab.ListMergeRequestDiscussionsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Discussion, *gitlab.Response, error)
-	ResolveMergeRequestDiscussion(pid interface{}, mergeRequestIID int, discussion string, opt *gitlab.ResolveMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error)
-	CreateMergeRequestDiscussion(pid interface{}, mergeRequestIID int, opt *gitlab.CreateMergeRequestDiscussionOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Discussion, *gitlab.Response, error)
-	UpdateMergeRequestDiscussionNote(pid interface{}, mergeRequestIID int, discussion string, note int, opt *gitlab.UpdateMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error)
-	DeleteMergeRequestDiscussionNote(pid interface{}, mergeRequestIID int, discussion string, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	CreateDraftNote(pid interface{}, mergeRequestIID int, opt *gitlab.CreateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error)
-	ListDraftNotes(pid interface{}, mergeRequest int, opt *gitlab.ListDraftNotesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.DraftNote, *gitlab.Response, error)
-	DeleteDraftNote(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	UpdateDraftNote(pid interface{}, mergeRequest int, note int, opt *gitlab.UpdateDraftNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.DraftNote, *gitlab.Response, error)
-	PublishDraftNote(pid interface{}, mergeRequest int, note int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	PublishAllDraftNotes(pid interface{}, mergeRequest int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	AddMergeRequestDiscussionNote(pid interface{}, mergeRequestIID int, discussion string, opt *gitlab.AddMergeRequestDiscussionNoteOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Note, *gitlab.Response, error)
-	ListAllProjectMembers(pid interface{}, opt *gitlab.ListProjectMembersOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.ProjectMember, *gitlab.Response, error)
-	RetryPipelineBuild(pid interface{}, pipeline int, options ...gitlab.RequestOptionFunc) (*gitlab.Pipeline, *gitlab.Response, error)
-	ListPipelineJobs(pid interface{}, pipelineID int, opts *gitlab.ListJobsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Job, *gitlab.Response, error)
-	ListProjectPipelines(pid interface{}, opt *gitlab.ListProjectPipelinesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.PipelineInfo, *gitlab.Response, error)
-	GetTraceFile(pid interface{}, jobID int, options ...gitlab.RequestOptionFunc) (*bytes.Reader, *gitlab.Response, error)
-	ListLabels(pid interface{}, opt *gitlab.ListLabelsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Label, *gitlab.Response, error)
-	ListMergeRequestAwardEmojiOnNote(pid interface{}, mergeRequestIID int, noteID int, opt *gitlab.ListAwardEmojiOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.AwardEmoji, *gitlab.Response, error)
-	CreateMergeRequestAwardEmojiOnNote(pid interface{}, mergeRequestIID int, noteID int, opt *gitlab.CreateAwardEmojiOptions, options ...gitlab.RequestOptionFunc) (*gitlab.AwardEmoji, *gitlab.Response, error)
-	DeleteMergeRequestAwardEmojiOnNote(pid interface{}, mergeRequestIID, noteID, awardID int, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error)
-	CurrentUser(options ...gitlab.RequestOptionFunc) (*gitlab.User, *gitlab.Response, error)
-}

cmd/utils.go

@@ -1,10 +0,0 @@
-package main
-
-func Contains[T comparable](elems []T, v T) int {
-	for i, s := range elems {
-		if v == s {
-			return i
-		}
-	}
-	return -1
-}