This change migrates to a new version of the AzDO SDK that uses interfaces. (#117)

* This change migrates to a new version of the SDK that uses interfaces.

This change avoids the need to create new interfaces by hand whenver we
need to test additional APIs in the provider. This includes the
following:
 - Update documentation for generating mocks
 - Remove `mock_config.go` file that has all the generated mocks
 - Remove the hand-created interfaces from `config.go`
 - Update `./scripts/generate-mocks.sh` so that it discovers the azdo GO
   SDKs pulled into the project, and programatically generate mocks for
   those SDKs

8 files changed, 5041 insertions, 0 deletions

diff --git a/azdosdkmocks/build_sdk_mock.go b/azdosdkmocks/build_sdk_mock.go
new file mode 100644
index 00000000..df23d53e
--- /dev/null
+++ b/azdosdkmocks/build_sdk_mock.go
@@ -0,0 +1,1202 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/microsoft/azure-devops-go-api/azuredevops/build (interfaces: Client)
+
+// Package azdosdkmocks is a generated GoMock package.
+package azdosdkmocks
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	build "github.com/microsoft/azure-devops-go-api/azuredevops/build"
+	webapi "github.com/microsoft/azure-devops-go-api/azuredevops/webapi"
+	io "io"
+	reflect "reflect"
+)
+
+// MockBuildClient is a mock of Client interface
+type MockBuildClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockBuildClientMockRecorder
+}
+
+// MockBuildClientMockRecorder is the mock recorder for MockBuildClient
+type MockBuildClientMockRecorder struct {
+	mock *MockBuildClient
+}
+
+// NewMockBuildClient creates a new mock instance
+func NewMockBuildClient(ctrl *gomock.Controller) *MockBuildClient {
+	mock := &MockBuildClient{ctrl: ctrl}
+	mock.recorder = &MockBuildClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockBuildClient) EXPECT() *MockBuildClientMockRecorder {
+	return m.recorder
+}
+
+// AddBuildTag mocks base method
+func (m *MockBuildClient) AddBuildTag(arg0 context.Context, arg1 build.AddBuildTagArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddBuildTag", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddBuildTag indicates an expected call of AddBuildTag
+func (mr *MockBuildClientMockRecorder) AddBuildTag(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBuildTag", reflect.TypeOf((*MockBuildClient)(nil).AddBuildTag), arg0, arg1)
+}
+
+// AddBuildTags mocks base method
+func (m *MockBuildClient) AddBuildTags(arg0 context.Context, arg1 build.AddBuildTagsArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddBuildTags", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddBuildTags indicates an expected call of AddBuildTags
+func (mr *MockBuildClientMockRecorder) AddBuildTags(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBuildTags", reflect.TypeOf((*MockBuildClient)(nil).AddBuildTags), arg0, arg1)
+}
+
+// AddDefinitionTag mocks base method
+func (m *MockBuildClient) AddDefinitionTag(arg0 context.Context, arg1 build.AddDefinitionTagArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddDefinitionTag", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddDefinitionTag indicates an expected call of AddDefinitionTag
+func (mr *MockBuildClientMockRecorder) AddDefinitionTag(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDefinitionTag", reflect.TypeOf((*MockBuildClient)(nil).AddDefinitionTag), arg0, arg1)
+}
+
+// AddDefinitionTags mocks base method
+func (m *MockBuildClient) AddDefinitionTags(arg0 context.Context, arg1 build.AddDefinitionTagsArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddDefinitionTags", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddDefinitionTags indicates an expected call of AddDefinitionTags
+func (mr *MockBuildClientMockRecorder) AddDefinitionTags(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDefinitionTags", reflect.TypeOf((*MockBuildClient)(nil).AddDefinitionTags), arg0, arg1)
+}
+
+// AuthorizeDefinitionResources mocks base method
+func (m *MockBuildClient) AuthorizeDefinitionResources(arg0 context.Context, arg1 build.AuthorizeDefinitionResourcesArgs) (*[]build.DefinitionResourceReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AuthorizeDefinitionResources", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.DefinitionResourceReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AuthorizeDefinitionResources indicates an expected call of AuthorizeDefinitionResources
+func (mr *MockBuildClientMockRecorder) AuthorizeDefinitionResources(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeDefinitionResources", reflect.TypeOf((*MockBuildClient)(nil).AuthorizeDefinitionResources), arg0, arg1)
+}
+
+// AuthorizeProjectResources mocks base method
+func (m *MockBuildClient) AuthorizeProjectResources(arg0 context.Context, arg1 build.AuthorizeProjectResourcesArgs) (*[]build.DefinitionResourceReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AuthorizeProjectResources", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.DefinitionResourceReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AuthorizeProjectResources indicates an expected call of AuthorizeProjectResources
+func (mr *MockBuildClientMockRecorder) AuthorizeProjectResources(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeProjectResources", reflect.TypeOf((*MockBuildClient)(nil).AuthorizeProjectResources), arg0, arg1)
+}
+
+// CreateArtifact mocks base method
+func (m *MockBuildClient) CreateArtifact(arg0 context.Context, arg1 build.CreateArtifactArgs) (*build.BuildArtifact, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateArtifact", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildArtifact)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateArtifact indicates an expected call of CreateArtifact
+func (mr *MockBuildClientMockRecorder) CreateArtifact(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateArtifact", reflect.TypeOf((*MockBuildClient)(nil).CreateArtifact), arg0, arg1)
+}
+
+// CreateDefinition mocks base method
+func (m *MockBuildClient) CreateDefinition(arg0 context.Context, arg1 build.CreateDefinitionArgs) (*build.BuildDefinition, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateDefinition", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildDefinition)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateDefinition indicates an expected call of CreateDefinition
+func (mr *MockBuildClientMockRecorder) CreateDefinition(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefinition", reflect.TypeOf((*MockBuildClient)(nil).CreateDefinition), arg0, arg1)
+}
+
+// CreateFolder mocks base method
+func (m *MockBuildClient) CreateFolder(arg0 context.Context, arg1 build.CreateFolderArgs) (*build.Folder, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateFolder", arg0, arg1)
+	ret0, _ := ret[0].(*build.Folder)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateFolder indicates an expected call of CreateFolder
+func (mr *MockBuildClientMockRecorder) CreateFolder(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFolder", reflect.TypeOf((*MockBuildClient)(nil).CreateFolder), arg0, arg1)
+}
+
+// DeleteBuild mocks base method
+func (m *MockBuildClient) DeleteBuild(arg0 context.Context, arg1 build.DeleteBuildArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteBuild", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteBuild indicates an expected call of DeleteBuild
+func (mr *MockBuildClientMockRecorder) DeleteBuild(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBuild", reflect.TypeOf((*MockBuildClient)(nil).DeleteBuild), arg0, arg1)
+}
+
+// DeleteBuildTag mocks base method
+func (m *MockBuildClient) DeleteBuildTag(arg0 context.Context, arg1 build.DeleteBuildTagArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteBuildTag", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteBuildTag indicates an expected call of DeleteBuildTag
+func (mr *MockBuildClientMockRecorder) DeleteBuildTag(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBuildTag", reflect.TypeOf((*MockBuildClient)(nil).DeleteBuildTag), arg0, arg1)
+}
+
+// DeleteDefinition mocks base method
+func (m *MockBuildClient) DeleteDefinition(arg0 context.Context, arg1 build.DeleteDefinitionArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteDefinition", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteDefinition indicates an expected call of DeleteDefinition
+func (mr *MockBuildClientMockRecorder) DeleteDefinition(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDefinition", reflect.TypeOf((*MockBuildClient)(nil).DeleteDefinition), arg0, arg1)
+}
+
+// DeleteDefinitionTag mocks base method
+func (m *MockBuildClient) DeleteDefinitionTag(arg0 context.Context, arg1 build.DeleteDefinitionTagArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteDefinitionTag", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDefinitionTag indicates an expected call of DeleteDefinitionTag
+func (mr *MockBuildClientMockRecorder) DeleteDefinitionTag(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDefinitionTag", reflect.TypeOf((*MockBuildClient)(nil).DeleteDefinitionTag), arg0, arg1)
+}
+
+// DeleteFolder mocks base method
+func (m *MockBuildClient) DeleteFolder(arg0 context.Context, arg1 build.DeleteFolderArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteFolder", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteFolder indicates an expected call of DeleteFolder
+func (mr *MockBuildClientMockRecorder) DeleteFolder(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFolder", reflect.TypeOf((*MockBuildClient)(nil).DeleteFolder), arg0, arg1)
+}
+
+// DeleteTemplate mocks base method
+func (m *MockBuildClient) DeleteTemplate(arg0 context.Context, arg1 build.DeleteTemplateArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteTemplate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteTemplate indicates an expected call of DeleteTemplate
+func (mr *MockBuildClientMockRecorder) DeleteTemplate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTemplate", reflect.TypeOf((*MockBuildClient)(nil).DeleteTemplate), arg0, arg1)
+}
+
+// GetArtifact mocks base method
+func (m *MockBuildClient) GetArtifact(arg0 context.Context, arg1 build.GetArtifactArgs) (*build.BuildArtifact, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetArtifact", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildArtifact)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetArtifact indicates an expected call of GetArtifact
+func (mr *MockBuildClientMockRecorder) GetArtifact(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifact", reflect.TypeOf((*MockBuildClient)(nil).GetArtifact), arg0, arg1)
+}
+
+// GetArtifactContentZip mocks base method
+func (m *MockBuildClient) GetArtifactContentZip(arg0 context.Context, arg1 build.GetArtifactContentZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetArtifactContentZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetArtifactContentZip indicates an expected call of GetArtifactContentZip
+func (mr *MockBuildClientMockRecorder) GetArtifactContentZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifactContentZip", reflect.TypeOf((*MockBuildClient)(nil).GetArtifactContentZip), arg0, arg1)
+}
+
+// GetArtifacts mocks base method
+func (m *MockBuildClient) GetArtifacts(arg0 context.Context, arg1 build.GetArtifactsArgs) (*[]build.BuildArtifact, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetArtifacts", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.BuildArtifact)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetArtifacts indicates an expected call of GetArtifacts
+func (mr *MockBuildClientMockRecorder) GetArtifacts(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifacts", reflect.TypeOf((*MockBuildClient)(nil).GetArtifacts), arg0, arg1)
+}
+
+// GetAttachment mocks base method
+func (m *MockBuildClient) GetAttachment(arg0 context.Context, arg1 build.GetAttachmentArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAttachment", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAttachment indicates an expected call of GetAttachment
+func (mr *MockBuildClientMockRecorder) GetAttachment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttachment", reflect.TypeOf((*MockBuildClient)(nil).GetAttachment), arg0, arg1)
+}
+
+// GetAttachments mocks base method
+func (m *MockBuildClient) GetAttachments(arg0 context.Context, arg1 build.GetAttachmentsArgs) (*[]build.Attachment, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAttachments", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.Attachment)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAttachments indicates an expected call of GetAttachments
+func (mr *MockBuildClientMockRecorder) GetAttachments(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttachments", reflect.TypeOf((*MockBuildClient)(nil).GetAttachments), arg0, arg1)
+}
+
+// GetBuild mocks base method
+func (m *MockBuildClient) GetBuild(arg0 context.Context, arg1 build.GetBuildArgs) (*build.Build, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuild", arg0, arg1)
+	ret0, _ := ret[0].(*build.Build)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuild indicates an expected call of GetBuild
+func (mr *MockBuildClientMockRecorder) GetBuild(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuild", reflect.TypeOf((*MockBuildClient)(nil).GetBuild), arg0, arg1)
+}
+
+// GetBuildBadge mocks base method
+func (m *MockBuildClient) GetBuildBadge(arg0 context.Context, arg1 build.GetBuildBadgeArgs) (*build.BuildBadge, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildBadge", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildBadge)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildBadge indicates an expected call of GetBuildBadge
+func (mr *MockBuildClientMockRecorder) GetBuildBadge(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildBadge", reflect.TypeOf((*MockBuildClient)(nil).GetBuildBadge), arg0, arg1)
+}
+
+// GetBuildBadgeData mocks base method
+func (m *MockBuildClient) GetBuildBadgeData(arg0 context.Context, arg1 build.GetBuildBadgeDataArgs) (*string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildBadgeData", arg0, arg1)
+	ret0, _ := ret[0].(*string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildBadgeData indicates an expected call of GetBuildBadgeData
+func (mr *MockBuildClientMockRecorder) GetBuildBadgeData(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildBadgeData", reflect.TypeOf((*MockBuildClient)(nil).GetBuildBadgeData), arg0, arg1)
+}
+
+// GetBuildChanges mocks base method
+func (m *MockBuildClient) GetBuildChanges(arg0 context.Context, arg1 build.GetBuildChangesArgs) (*build.GetBuildChangesResponseValue, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildChanges", arg0, arg1)
+	ret0, _ := ret[0].(*build.GetBuildChangesResponseValue)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildChanges indicates an expected call of GetBuildChanges
+func (mr *MockBuildClientMockRecorder) GetBuildChanges(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildChanges", reflect.TypeOf((*MockBuildClient)(nil).GetBuildChanges), arg0, arg1)
+}
+
+// GetBuildController mocks base method
+func (m *MockBuildClient) GetBuildController(arg0 context.Context, arg1 build.GetBuildControllerArgs) (*build.BuildController, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildController", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildController)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildController indicates an expected call of GetBuildController
+func (mr *MockBuildClientMockRecorder) GetBuildController(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildController", reflect.TypeOf((*MockBuildClient)(nil).GetBuildController), arg0, arg1)
+}
+
+// GetBuildControllers mocks base method
+func (m *MockBuildClient) GetBuildControllers(arg0 context.Context, arg1 build.GetBuildControllersArgs) (*[]build.BuildController, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildControllers", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.BuildController)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildControllers indicates an expected call of GetBuildControllers
+func (mr *MockBuildClientMockRecorder) GetBuildControllers(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildControllers", reflect.TypeOf((*MockBuildClient)(nil).GetBuildControllers), arg0, arg1)
+}
+
+// GetBuildLog mocks base method
+func (m *MockBuildClient) GetBuildLog(arg0 context.Context, arg1 build.GetBuildLogArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildLog", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildLog indicates an expected call of GetBuildLog
+func (mr *MockBuildClientMockRecorder) GetBuildLog(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildLog", reflect.TypeOf((*MockBuildClient)(nil).GetBuildLog), arg0, arg1)
+}
+
+// GetBuildLogLines mocks base method
+func (m *MockBuildClient) GetBuildLogLines(arg0 context.Context, arg1 build.GetBuildLogLinesArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildLogLines", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildLogLines indicates an expected call of GetBuildLogLines
+func (mr *MockBuildClientMockRecorder) GetBuildLogLines(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildLogLines", reflect.TypeOf((*MockBuildClient)(nil).GetBuildLogLines), arg0, arg1)
+}
+
+// GetBuildLogZip mocks base method
+func (m *MockBuildClient) GetBuildLogZip(arg0 context.Context, arg1 build.GetBuildLogZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildLogZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildLogZip indicates an expected call of GetBuildLogZip
+func (mr *MockBuildClientMockRecorder) GetBuildLogZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildLogZip", reflect.TypeOf((*MockBuildClient)(nil).GetBuildLogZip), arg0, arg1)
+}
+
+// GetBuildLogs mocks base method
+func (m *MockBuildClient) GetBuildLogs(arg0 context.Context, arg1 build.GetBuildLogsArgs) (*[]build.BuildLog, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildLogs", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.BuildLog)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildLogs indicates an expected call of GetBuildLogs
+func (mr *MockBuildClientMockRecorder) GetBuildLogs(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildLogs", reflect.TypeOf((*MockBuildClient)(nil).GetBuildLogs), arg0, arg1)
+}
+
+// GetBuildLogsZip mocks base method
+func (m *MockBuildClient) GetBuildLogsZip(arg0 context.Context, arg1 build.GetBuildLogsZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildLogsZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildLogsZip indicates an expected call of GetBuildLogsZip
+func (mr *MockBuildClientMockRecorder) GetBuildLogsZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildLogsZip", reflect.TypeOf((*MockBuildClient)(nil).GetBuildLogsZip), arg0, arg1)
+}
+
+// GetBuildOptionDefinitions mocks base method
+func (m *MockBuildClient) GetBuildOptionDefinitions(arg0 context.Context, arg1 build.GetBuildOptionDefinitionsArgs) (*[]build.BuildOptionDefinition, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildOptionDefinitions", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.BuildOptionDefinition)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildOptionDefinitions indicates an expected call of GetBuildOptionDefinitions
+func (mr *MockBuildClientMockRecorder) GetBuildOptionDefinitions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildOptionDefinitions", reflect.TypeOf((*MockBuildClient)(nil).GetBuildOptionDefinitions), arg0, arg1)
+}
+
+// GetBuildProperties mocks base method
+func (m *MockBuildClient) GetBuildProperties(arg0 context.Context, arg1 build.GetBuildPropertiesArgs) (interface{}, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildProperties", arg0, arg1)
+	ret0, _ := ret[0].(interface{})
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildProperties indicates an expected call of GetBuildProperties
+func (mr *MockBuildClientMockRecorder) GetBuildProperties(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildProperties", reflect.TypeOf((*MockBuildClient)(nil).GetBuildProperties), arg0, arg1)
+}
+
+// GetBuildReport mocks base method
+func (m *MockBuildClient) GetBuildReport(arg0 context.Context, arg1 build.GetBuildReportArgs) (*build.BuildReportMetadata, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildReport", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildReportMetadata)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildReport indicates an expected call of GetBuildReport
+func (mr *MockBuildClientMockRecorder) GetBuildReport(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildReport", reflect.TypeOf((*MockBuildClient)(nil).GetBuildReport), arg0, arg1)
+}
+
+// GetBuildReportHtmlContent mocks base method
+func (m *MockBuildClient) GetBuildReportHtmlContent(arg0 context.Context, arg1 build.GetBuildReportHtmlContentArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildReportHtmlContent", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildReportHtmlContent indicates an expected call of GetBuildReportHtmlContent
+func (mr *MockBuildClientMockRecorder) GetBuildReportHtmlContent(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildReportHtmlContent", reflect.TypeOf((*MockBuildClient)(nil).GetBuildReportHtmlContent), arg0, arg1)
+}
+
+// GetBuildSettings mocks base method
+func (m *MockBuildClient) GetBuildSettings(arg0 context.Context, arg1 build.GetBuildSettingsArgs) (*build.BuildSettings, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildSettings", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildSettings indicates an expected call of GetBuildSettings
+func (mr *MockBuildClientMockRecorder) GetBuildSettings(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildSettings", reflect.TypeOf((*MockBuildClient)(nil).GetBuildSettings), arg0, arg1)
+}
+
+// GetBuildTags mocks base method
+func (m *MockBuildClient) GetBuildTags(arg0 context.Context, arg1 build.GetBuildTagsArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildTags", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildTags indicates an expected call of GetBuildTags
+func (mr *MockBuildClientMockRecorder) GetBuildTags(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildTags", reflect.TypeOf((*MockBuildClient)(nil).GetBuildTags), arg0, arg1)
+}
+
+// GetBuildTimeline mocks base method
+func (m *MockBuildClient) GetBuildTimeline(arg0 context.Context, arg1 build.GetBuildTimelineArgs) (*build.Timeline, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildTimeline", arg0, arg1)
+	ret0, _ := ret[0].(*build.Timeline)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildTimeline indicates an expected call of GetBuildTimeline
+func (mr *MockBuildClientMockRecorder) GetBuildTimeline(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildTimeline", reflect.TypeOf((*MockBuildClient)(nil).GetBuildTimeline), arg0, arg1)
+}
+
+// GetBuildWorkItemsRefs mocks base method
+func (m *MockBuildClient) GetBuildWorkItemsRefs(arg0 context.Context, arg1 build.GetBuildWorkItemsRefsArgs) (*[]webapi.ResourceRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildWorkItemsRefs", arg0, arg1)
+	ret0, _ := ret[0].(*[]webapi.ResourceRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildWorkItemsRefs indicates an expected call of GetBuildWorkItemsRefs
+func (mr *MockBuildClientMockRecorder) GetBuildWorkItemsRefs(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildWorkItemsRefs", reflect.TypeOf((*MockBuildClient)(nil).GetBuildWorkItemsRefs), arg0, arg1)
+}
+
+// GetBuildWorkItemsRefsFromCommits mocks base method
+func (m *MockBuildClient) GetBuildWorkItemsRefsFromCommits(arg0 context.Context, arg1 build.GetBuildWorkItemsRefsFromCommitsArgs) (*[]webapi.ResourceRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildWorkItemsRefsFromCommits", arg0, arg1)
+	ret0, _ := ret[0].(*[]webapi.ResourceRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildWorkItemsRefsFromCommits indicates an expected call of GetBuildWorkItemsRefsFromCommits
+func (mr *MockBuildClientMockRecorder) GetBuildWorkItemsRefsFromCommits(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildWorkItemsRefsFromCommits", reflect.TypeOf((*MockBuildClient)(nil).GetBuildWorkItemsRefsFromCommits), arg0, arg1)
+}
+
+// GetBuilds mocks base method
+func (m *MockBuildClient) GetBuilds(arg0 context.Context, arg1 build.GetBuildsArgs) (*build.GetBuildsResponseValue, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuilds", arg0, arg1)
+	ret0, _ := ret[0].(*build.GetBuildsResponseValue)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuilds indicates an expected call of GetBuilds
+func (mr *MockBuildClientMockRecorder) GetBuilds(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuilds", reflect.TypeOf((*MockBuildClient)(nil).GetBuilds), arg0, arg1)
+}
+
+// GetChangesBetweenBuilds mocks base method
+func (m *MockBuildClient) GetChangesBetweenBuilds(arg0 context.Context, arg1 build.GetChangesBetweenBuildsArgs) (*[]build.Change, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetChangesBetweenBuilds", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.Change)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetChangesBetweenBuilds indicates an expected call of GetChangesBetweenBuilds
+func (mr *MockBuildClientMockRecorder) GetChangesBetweenBuilds(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangesBetweenBuilds", reflect.TypeOf((*MockBuildClient)(nil).GetChangesBetweenBuilds), arg0, arg1)
+}
+
+// GetDefinition mocks base method
+func (m *MockBuildClient) GetDefinition(arg0 context.Context, arg1 build.GetDefinitionArgs) (*build.BuildDefinition, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDefinition", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildDefinition)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDefinition indicates an expected call of GetDefinition
+func (mr *MockBuildClientMockRecorder) GetDefinition(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinition", reflect.TypeOf((*MockBuildClient)(nil).GetDefinition), arg0, arg1)
+}
+
+// GetDefinitionMetrics mocks base method
+func (m *MockBuildClient) GetDefinitionMetrics(arg0 context.Context, arg1 build.GetDefinitionMetricsArgs) (*[]build.BuildMetric, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDefinitionMetrics", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.BuildMetric)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDefinitionMetrics indicates an expected call of GetDefinitionMetrics
+func (mr *MockBuildClientMockRecorder) GetDefinitionMetrics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitionMetrics", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitionMetrics), arg0, arg1)
+}
+
+// GetDefinitionProperties mocks base method
+func (m *MockBuildClient) GetDefinitionProperties(arg0 context.Context, arg1 build.GetDefinitionPropertiesArgs) (interface{}, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDefinitionProperties", arg0, arg1)
+	ret0, _ := ret[0].(interface{})
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDefinitionProperties indicates an expected call of GetDefinitionProperties
+func (mr *MockBuildClientMockRecorder) GetDefinitionProperties(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitionProperties", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitionProperties), arg0, arg1)
+}
+
+// GetDefinitionResources mocks base method
+func (m *MockBuildClient) GetDefinitionResources(arg0 context.Context, arg1 build.GetDefinitionResourcesArgs) (*[]build.DefinitionResourceReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDefinitionResources", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.DefinitionResourceReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDefinitionResources indicates an expected call of GetDefinitionResources
+func (mr *MockBuildClientMockRecorder) GetDefinitionResources(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitionResources", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitionResources), arg0, arg1)
+}
+
+// GetDefinitionRevisions mocks base method
+func (m *MockBuildClient) GetDefinitionRevisions(arg0 context.Context, arg1 build.GetDefinitionRevisionsArgs) (*[]build.BuildDefinitionRevision, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDefinitionRevisions", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.BuildDefinitionRevision)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDefinitionRevisions indicates an expected call of GetDefinitionRevisions
+func (mr *MockBuildClientMockRecorder) GetDefinitionRevisions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitionRevisions", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitionRevisions), arg0, arg1)
+}
+
+// GetDefinitionTags mocks base method
+func (m *MockBuildClient) GetDefinitionTags(arg0 context.Context, arg1 build.GetDefinitionTagsArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDefinitionTags", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDefinitionTags indicates an expected call of GetDefinitionTags
+func (mr *MockBuildClientMockRecorder) GetDefinitionTags(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitionTags", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitionTags), arg0, arg1)
+}
+
+// GetDefinitions mocks base method
+func (m *MockBuildClient) GetDefinitions(arg0 context.Context, arg1 build.GetDefinitionsArgs) (*build.GetDefinitionsResponseValue, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDefinitions", arg0, arg1)
+	ret0, _ := ret[0].(*build.GetDefinitionsResponseValue)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDefinitions indicates an expected call of GetDefinitions
+func (mr *MockBuildClientMockRecorder) GetDefinitions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitions", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitions), arg0, arg1)
+}
+
+// GetFile mocks base method
+func (m *MockBuildClient) GetFile(arg0 context.Context, arg1 build.GetFileArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFile", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFile indicates an expected call of GetFile
+func (mr *MockBuildClientMockRecorder) GetFile(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFile", reflect.TypeOf((*MockBuildClient)(nil).GetFile), arg0, arg1)
+}
+
+// GetFileContents mocks base method
+func (m *MockBuildClient) GetFileContents(arg0 context.Context, arg1 build.GetFileContentsArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFileContents", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFileContents indicates an expected call of GetFileContents
+func (mr *MockBuildClientMockRecorder) GetFileContents(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileContents", reflect.TypeOf((*MockBuildClient)(nil).GetFileContents), arg0, arg1)
+}
+
+// GetFolders mocks base method
+func (m *MockBuildClient) GetFolders(arg0 context.Context, arg1 build.GetFoldersArgs) (*[]build.Folder, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFolders", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.Folder)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFolders indicates an expected call of GetFolders
+func (mr *MockBuildClientMockRecorder) GetFolders(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFolders", reflect.TypeOf((*MockBuildClient)(nil).GetFolders), arg0, arg1)
+}
+
+// GetLatestBuild mocks base method
+func (m *MockBuildClient) GetLatestBuild(arg0 context.Context, arg1 build.GetLatestBuildArgs) (*build.Build, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLatestBuild", arg0, arg1)
+	ret0, _ := ret[0].(*build.Build)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLatestBuild indicates an expected call of GetLatestBuild
+func (mr *MockBuildClientMockRecorder) GetLatestBuild(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestBuild", reflect.TypeOf((*MockBuildClient)(nil).GetLatestBuild), arg0, arg1)
+}
+
+// GetPathContents mocks base method
+func (m *MockBuildClient) GetPathContents(arg0 context.Context, arg1 build.GetPathContentsArgs) (*[]build.SourceRepositoryItem, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPathContents", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.SourceRepositoryItem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPathContents indicates an expected call of GetPathContents
+func (mr *MockBuildClientMockRecorder) GetPathContents(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPathContents", reflect.TypeOf((*MockBuildClient)(nil).GetPathContents), arg0, arg1)
+}
+
+// GetProjectMetrics mocks base method
+func (m *MockBuildClient) GetProjectMetrics(arg0 context.Context, arg1 build.GetProjectMetricsArgs) (*[]build.BuildMetric, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProjectMetrics", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.BuildMetric)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProjectMetrics indicates an expected call of GetProjectMetrics
+func (mr *MockBuildClientMockRecorder) GetProjectMetrics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectMetrics", reflect.TypeOf((*MockBuildClient)(nil).GetProjectMetrics), arg0, arg1)
+}
+
+// GetProjectResources mocks base method
+func (m *MockBuildClient) GetProjectResources(arg0 context.Context, arg1 build.GetProjectResourcesArgs) (*[]build.DefinitionResourceReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProjectResources", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.DefinitionResourceReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProjectResources indicates an expected call of GetProjectResources
+func (mr *MockBuildClientMockRecorder) GetProjectResources(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectResources", reflect.TypeOf((*MockBuildClient)(nil).GetProjectResources), arg0, arg1)
+}
+
+// GetPullRequest mocks base method
+func (m *MockBuildClient) GetPullRequest(arg0 context.Context, arg1 build.GetPullRequestArgs) (*build.PullRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequest", arg0, arg1)
+	ret0, _ := ret[0].(*build.PullRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequest indicates an expected call of GetPullRequest
+func (mr *MockBuildClientMockRecorder) GetPullRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockBuildClient)(nil).GetPullRequest), arg0, arg1)
+}
+
+// GetResourceUsage mocks base method
+func (m *MockBuildClient) GetResourceUsage(arg0 context.Context, arg1 build.GetResourceUsageArgs) (*build.BuildResourceUsage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetResourceUsage", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildResourceUsage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetResourceUsage indicates an expected call of GetResourceUsage
+func (mr *MockBuildClientMockRecorder) GetResourceUsage(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceUsage", reflect.TypeOf((*MockBuildClient)(nil).GetResourceUsage), arg0, arg1)
+}
+
+// GetStatusBadge mocks base method
+func (m *MockBuildClient) GetStatusBadge(arg0 context.Context, arg1 build.GetStatusBadgeArgs) (*string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStatusBadge", arg0, arg1)
+	ret0, _ := ret[0].(*string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStatusBadge indicates an expected call of GetStatusBadge
+func (mr *MockBuildClientMockRecorder) GetStatusBadge(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatusBadge", reflect.TypeOf((*MockBuildClient)(nil).GetStatusBadge), arg0, arg1)
+}
+
+// GetTags mocks base method
+func (m *MockBuildClient) GetTags(arg0 context.Context, arg1 build.GetTagsArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTags", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTags indicates an expected call of GetTags
+func (mr *MockBuildClientMockRecorder) GetTags(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTags", reflect.TypeOf((*MockBuildClient)(nil).GetTags), arg0, arg1)
+}
+
+// GetTemplate mocks base method
+func (m *MockBuildClient) GetTemplate(arg0 context.Context, arg1 build.GetTemplateArgs) (*build.BuildDefinitionTemplate, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTemplate", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildDefinitionTemplate)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTemplate indicates an expected call of GetTemplate
+func (mr *MockBuildClientMockRecorder) GetTemplate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplate", reflect.TypeOf((*MockBuildClient)(nil).GetTemplate), arg0, arg1)
+}
+
+// GetTemplates mocks base method
+func (m *MockBuildClient) GetTemplates(arg0 context.Context, arg1 build.GetTemplatesArgs) (*[]build.BuildDefinitionTemplate, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTemplates", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.BuildDefinitionTemplate)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTemplates indicates an expected call of GetTemplates
+func (mr *MockBuildClientMockRecorder) GetTemplates(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplates", reflect.TypeOf((*MockBuildClient)(nil).GetTemplates), arg0, arg1)
+}
+
+// GetWorkItemsBetweenBuilds mocks base method
+func (m *MockBuildClient) GetWorkItemsBetweenBuilds(arg0 context.Context, arg1 build.GetWorkItemsBetweenBuildsArgs) (*[]webapi.ResourceRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetWorkItemsBetweenBuilds", arg0, arg1)
+	ret0, _ := ret[0].(*[]webapi.ResourceRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetWorkItemsBetweenBuilds indicates an expected call of GetWorkItemsBetweenBuilds
+func (mr *MockBuildClientMockRecorder) GetWorkItemsBetweenBuilds(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkItemsBetweenBuilds", reflect.TypeOf((*MockBuildClient)(nil).GetWorkItemsBetweenBuilds), arg0, arg1)
+}
+
+// ListBranches mocks base method
+func (m *MockBuildClient) ListBranches(arg0 context.Context, arg1 build.ListBranchesArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListBranches", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListBranches indicates an expected call of ListBranches
+func (mr *MockBuildClientMockRecorder) ListBranches(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranches", reflect.TypeOf((*MockBuildClient)(nil).ListBranches), arg0, arg1)
+}
+
+// ListRepositories mocks base method
+func (m *MockBuildClient) ListRepositories(arg0 context.Context, arg1 build.ListRepositoriesArgs) (*build.SourceRepositories, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListRepositories", arg0, arg1)
+	ret0, _ := ret[0].(*build.SourceRepositories)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListRepositories indicates an expected call of ListRepositories
+func (mr *MockBuildClientMockRecorder) ListRepositories(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepositories", reflect.TypeOf((*MockBuildClient)(nil).ListRepositories), arg0, arg1)
+}
+
+// ListSourceProviders mocks base method
+func (m *MockBuildClient) ListSourceProviders(arg0 context.Context, arg1 build.ListSourceProvidersArgs) (*[]build.SourceProviderAttributes, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListSourceProviders", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.SourceProviderAttributes)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListSourceProviders indicates an expected call of ListSourceProviders
+func (mr *MockBuildClientMockRecorder) ListSourceProviders(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSourceProviders", reflect.TypeOf((*MockBuildClient)(nil).ListSourceProviders), arg0, arg1)
+}
+
+// ListWebhooks mocks base method
+func (m *MockBuildClient) ListWebhooks(arg0 context.Context, arg1 build.ListWebhooksArgs) (*[]build.RepositoryWebhook, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListWebhooks", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.RepositoryWebhook)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListWebhooks indicates an expected call of ListWebhooks
+func (mr *MockBuildClientMockRecorder) ListWebhooks(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWebhooks", reflect.TypeOf((*MockBuildClient)(nil).ListWebhooks), arg0, arg1)
+}
+
+// QueueBuild mocks base method
+func (m *MockBuildClient) QueueBuild(arg0 context.Context, arg1 build.QueueBuildArgs) (*build.Build, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "QueueBuild", arg0, arg1)
+	ret0, _ := ret[0].(*build.Build)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// QueueBuild indicates an expected call of QueueBuild
+func (mr *MockBuildClientMockRecorder) QueueBuild(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueBuild", reflect.TypeOf((*MockBuildClient)(nil).QueueBuild), arg0, arg1)
+}
+
+// RestoreDefinition mocks base method
+func (m *MockBuildClient) RestoreDefinition(arg0 context.Context, arg1 build.RestoreDefinitionArgs) (*build.BuildDefinition, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RestoreDefinition", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildDefinition)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RestoreDefinition indicates an expected call of RestoreDefinition
+func (mr *MockBuildClientMockRecorder) RestoreDefinition(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDefinition", reflect.TypeOf((*MockBuildClient)(nil).RestoreDefinition), arg0, arg1)
+}
+
+// RestoreWebhooks mocks base method
+func (m *MockBuildClient) RestoreWebhooks(arg0 context.Context, arg1 build.RestoreWebhooksArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RestoreWebhooks", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RestoreWebhooks indicates an expected call of RestoreWebhooks
+func (mr *MockBuildClientMockRecorder) RestoreWebhooks(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreWebhooks", reflect.TypeOf((*MockBuildClient)(nil).RestoreWebhooks), arg0, arg1)
+}
+
+// SaveTemplate mocks base method
+func (m *MockBuildClient) SaveTemplate(arg0 context.Context, arg1 build.SaveTemplateArgs) (*build.BuildDefinitionTemplate, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SaveTemplate", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildDefinitionTemplate)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SaveTemplate indicates an expected call of SaveTemplate
+func (mr *MockBuildClientMockRecorder) SaveTemplate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTemplate", reflect.TypeOf((*MockBuildClient)(nil).SaveTemplate), arg0, arg1)
+}
+
+// UpdateBuild mocks base method
+func (m *MockBuildClient) UpdateBuild(arg0 context.Context, arg1 build.UpdateBuildArgs) (*build.Build, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateBuild", arg0, arg1)
+	ret0, _ := ret[0].(*build.Build)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateBuild indicates an expected call of UpdateBuild
+func (mr *MockBuildClientMockRecorder) UpdateBuild(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuild", reflect.TypeOf((*MockBuildClient)(nil).UpdateBuild), arg0, arg1)
+}
+
+// UpdateBuildProperties mocks base method
+func (m *MockBuildClient) UpdateBuildProperties(arg0 context.Context, arg1 build.UpdateBuildPropertiesArgs) (interface{}, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateBuildProperties", arg0, arg1)
+	ret0, _ := ret[0].(interface{})
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateBuildProperties indicates an expected call of UpdateBuildProperties
+func (mr *MockBuildClientMockRecorder) UpdateBuildProperties(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuildProperties", reflect.TypeOf((*MockBuildClient)(nil).UpdateBuildProperties), arg0, arg1)
+}
+
+// UpdateBuildSettings mocks base method
+func (m *MockBuildClient) UpdateBuildSettings(arg0 context.Context, arg1 build.UpdateBuildSettingsArgs) (*build.BuildSettings, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateBuildSettings", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateBuildSettings indicates an expected call of UpdateBuildSettings
+func (mr *MockBuildClientMockRecorder) UpdateBuildSettings(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuildSettings", reflect.TypeOf((*MockBuildClient)(nil).UpdateBuildSettings), arg0, arg1)
+}
+
+// UpdateBuilds mocks base method
+func (m *MockBuildClient) UpdateBuilds(arg0 context.Context, arg1 build.UpdateBuildsArgs) (*[]build.Build, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateBuilds", arg0, arg1)
+	ret0, _ := ret[0].(*[]build.Build)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateBuilds indicates an expected call of UpdateBuilds
+func (mr *MockBuildClientMockRecorder) UpdateBuilds(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuilds", reflect.TypeOf((*MockBuildClient)(nil).UpdateBuilds), arg0, arg1)
+}
+
+// UpdateDefinition mocks base method
+func (m *MockBuildClient) UpdateDefinition(arg0 context.Context, arg1 build.UpdateDefinitionArgs) (*build.BuildDefinition, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDefinition", arg0, arg1)
+	ret0, _ := ret[0].(*build.BuildDefinition)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateDefinition indicates an expected call of UpdateDefinition
+func (mr *MockBuildClientMockRecorder) UpdateDefinition(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDefinition", reflect.TypeOf((*MockBuildClient)(nil).UpdateDefinition), arg0, arg1)
+}
+
+// UpdateDefinitionProperties mocks base method
+func (m *MockBuildClient) UpdateDefinitionProperties(arg0 context.Context, arg1 build.UpdateDefinitionPropertiesArgs) (interface{}, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDefinitionProperties", arg0, arg1)
+	ret0, _ := ret[0].(interface{})
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateDefinitionProperties indicates an expected call of UpdateDefinitionProperties
+func (mr *MockBuildClientMockRecorder) UpdateDefinitionProperties(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDefinitionProperties", reflect.TypeOf((*MockBuildClient)(nil).UpdateDefinitionProperties), arg0, arg1)
+}
+
+// UpdateFolder mocks base method
+func (m *MockBuildClient) UpdateFolder(arg0 context.Context, arg1 build.UpdateFolderArgs) (*build.Folder, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateFolder", arg0, arg1)
+	ret0, _ := ret[0].(*build.Folder)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateFolder indicates an expected call of UpdateFolder
+func (mr *MockBuildClientMockRecorder) UpdateFolder(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFolder", reflect.TypeOf((*MockBuildClient)(nil).UpdateFolder), arg0, arg1)
+}
diff --git a/azdosdkmocks/core_sdk_mock.go b/azdosdkmocks/core_sdk_mock.go
new file mode 100644
index 00000000..2aa9020d
--- /dev/null
+++ b/azdosdkmocks/core_sdk_mock.go
@@ -0,0 +1,422 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/microsoft/azure-devops-go-api/azuredevops/core (interfaces: Client)
+
+// Package azdosdkmocks is a generated GoMock package.
+package azdosdkmocks
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	core "github.com/microsoft/azure-devops-go-api/azuredevops/core"
+	operations "github.com/microsoft/azure-devops-go-api/azuredevops/operations"
+	webapi "github.com/microsoft/azure-devops-go-api/azuredevops/webapi"
+	reflect "reflect"
+)
+
+// MockCoreClient is a mock of Client interface
+type MockCoreClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockCoreClientMockRecorder
+}
+
+// MockCoreClientMockRecorder is the mock recorder for MockCoreClient
+type MockCoreClientMockRecorder struct {
+	mock *MockCoreClient
+}
+
+// NewMockCoreClient creates a new mock instance
+func NewMockCoreClient(ctrl *gomock.Controller) *MockCoreClient {
+	mock := &MockCoreClient{ctrl: ctrl}
+	mock.recorder = &MockCoreClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockCoreClient) EXPECT() *MockCoreClientMockRecorder {
+	return m.recorder
+}
+
+// CreateConnectedService mocks base method
+func (m *MockCoreClient) CreateConnectedService(arg0 context.Context, arg1 core.CreateConnectedServiceArgs) (*core.WebApiConnectedService, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateConnectedService", arg0, arg1)
+	ret0, _ := ret[0].(*core.WebApiConnectedService)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateConnectedService indicates an expected call of CreateConnectedService
+func (mr *MockCoreClientMockRecorder) CreateConnectedService(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConnectedService", reflect.TypeOf((*MockCoreClient)(nil).CreateConnectedService), arg0, arg1)
+}
+
+// CreateOrUpdateProxy mocks base method
+func (m *MockCoreClient) CreateOrUpdateProxy(arg0 context.Context, arg1 core.CreateOrUpdateProxyArgs) (*core.Proxy, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateProxy", arg0, arg1)
+	ret0, _ := ret[0].(*core.Proxy)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateOrUpdateProxy indicates an expected call of CreateOrUpdateProxy
+func (mr *MockCoreClientMockRecorder) CreateOrUpdateProxy(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateProxy", reflect.TypeOf((*MockCoreClient)(nil).CreateOrUpdateProxy), arg0, arg1)
+}
+
+// CreateTeam mocks base method
+func (m *MockCoreClient) CreateTeam(arg0 context.Context, arg1 core.CreateTeamArgs) (*core.WebApiTeam, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateTeam", arg0, arg1)
+	ret0, _ := ret[0].(*core.WebApiTeam)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateTeam indicates an expected call of CreateTeam
+func (mr *MockCoreClientMockRecorder) CreateTeam(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTeam", reflect.TypeOf((*MockCoreClient)(nil).CreateTeam), arg0, arg1)
+}
+
+// DeleteProxy mocks base method
+func (m *MockCoreClient) DeleteProxy(arg0 context.Context, arg1 core.DeleteProxyArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteProxy", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteProxy indicates an expected call of DeleteProxy
+func (mr *MockCoreClientMockRecorder) DeleteProxy(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProxy", reflect.TypeOf((*MockCoreClient)(nil).DeleteProxy), arg0, arg1)
+}
+
+// DeleteTeam mocks base method
+func (m *MockCoreClient) DeleteTeam(arg0 context.Context, arg1 core.DeleteTeamArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteTeam", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteTeam indicates an expected call of DeleteTeam
+func (mr *MockCoreClientMockRecorder) DeleteTeam(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTeam", reflect.TypeOf((*MockCoreClient)(nil).DeleteTeam), arg0, arg1)
+}
+
+// GetAllTeams mocks base method
+func (m *MockCoreClient) GetAllTeams(arg0 context.Context, arg1 core.GetAllTeamsArgs) (*[]core.WebApiTeam, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAllTeams", arg0, arg1)
+	ret0, _ := ret[0].(*[]core.WebApiTeam)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAllTeams indicates an expected call of GetAllTeams
+func (mr *MockCoreClientMockRecorder) GetAllTeams(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllTeams", reflect.TypeOf((*MockCoreClient)(nil).GetAllTeams), arg0, arg1)
+}
+
+// GetConnectedServiceDetails mocks base method
+func (m *MockCoreClient) GetConnectedServiceDetails(arg0 context.Context, arg1 core.GetConnectedServiceDetailsArgs) (*core.WebApiConnectedServiceDetails, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetConnectedServiceDetails", arg0, arg1)
+	ret0, _ := ret[0].(*core.WebApiConnectedServiceDetails)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetConnectedServiceDetails indicates an expected call of GetConnectedServiceDetails
+func (mr *MockCoreClientMockRecorder) GetConnectedServiceDetails(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectedServiceDetails", reflect.TypeOf((*MockCoreClient)(nil).GetConnectedServiceDetails), arg0, arg1)
+}
+
+// GetConnectedServices mocks base method
+func (m *MockCoreClient) GetConnectedServices(arg0 context.Context, arg1 core.GetConnectedServicesArgs) (*[]core.WebApiConnectedService, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetConnectedServices", arg0, arg1)
+	ret0, _ := ret[0].(*[]core.WebApiConnectedService)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetConnectedServices indicates an expected call of GetConnectedServices
+func (mr *MockCoreClientMockRecorder) GetConnectedServices(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectedServices", reflect.TypeOf((*MockCoreClient)(nil).GetConnectedServices), arg0, arg1)
+}
+
+// GetProcessById mocks base method
+func (m *MockCoreClient) GetProcessById(arg0 context.Context, arg1 core.GetProcessByIdArgs) (*core.Process, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProcessById", arg0, arg1)
+	ret0, _ := ret[0].(*core.Process)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProcessById indicates an expected call of GetProcessById
+func (mr *MockCoreClientMockRecorder) GetProcessById(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProcessById", reflect.TypeOf((*MockCoreClient)(nil).GetProcessById), arg0, arg1)
+}
+
+// GetProcesses mocks base method
+func (m *MockCoreClient) GetProcesses(arg0 context.Context, arg1 core.GetProcessesArgs) (*[]core.Process, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProcesses", arg0, arg1)
+	ret0, _ := ret[0].(*[]core.Process)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProcesses indicates an expected call of GetProcesses
+func (mr *MockCoreClientMockRecorder) GetProcesses(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProcesses", reflect.TypeOf((*MockCoreClient)(nil).GetProcesses), arg0, arg1)
+}
+
+// GetProject mocks base method
+func (m *MockCoreClient) GetProject(arg0 context.Context, arg1 core.GetProjectArgs) (*core.TeamProject, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProject", arg0, arg1)
+	ret0, _ := ret[0].(*core.TeamProject)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProject indicates an expected call of GetProject
+func (mr *MockCoreClientMockRecorder) GetProject(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProject", reflect.TypeOf((*MockCoreClient)(nil).GetProject), arg0, arg1)
+}
+
+// GetProjectCollection mocks base method
+func (m *MockCoreClient) GetProjectCollection(arg0 context.Context, arg1 core.GetProjectCollectionArgs) (*core.TeamProjectCollection, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProjectCollection", arg0, arg1)
+	ret0, _ := ret[0].(*core.TeamProjectCollection)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProjectCollection indicates an expected call of GetProjectCollection
+func (mr *MockCoreClientMockRecorder) GetProjectCollection(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectCollection", reflect.TypeOf((*MockCoreClient)(nil).GetProjectCollection), arg0, arg1)
+}
+
+// GetProjectCollections mocks base method
+func (m *MockCoreClient) GetProjectCollections(arg0 context.Context, arg1 core.GetProjectCollectionsArgs) (*[]core.TeamProjectCollectionReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProjectCollections", arg0, arg1)
+	ret0, _ := ret[0].(*[]core.TeamProjectCollectionReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProjectCollections indicates an expected call of GetProjectCollections
+func (mr *MockCoreClientMockRecorder) GetProjectCollections(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectCollections", reflect.TypeOf((*MockCoreClient)(nil).GetProjectCollections), arg0, arg1)
+}
+
+// GetProjectProperties mocks base method
+func (m *MockCoreClient) GetProjectProperties(arg0 context.Context, arg1 core.GetProjectPropertiesArgs) (*[]core.ProjectProperty, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProjectProperties", arg0, arg1)
+	ret0, _ := ret[0].(*[]core.ProjectProperty)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProjectProperties indicates an expected call of GetProjectProperties
+func (mr *MockCoreClientMockRecorder) GetProjectProperties(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectProperties", reflect.TypeOf((*MockCoreClient)(nil).GetProjectProperties), arg0, arg1)
+}
+
+// GetProjects mocks base method
+func (m *MockCoreClient) GetProjects(arg0 context.Context, arg1 core.GetProjectsArgs) (*core.GetProjectsResponseValue, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProjects", arg0, arg1)
+	ret0, _ := ret[0].(*core.GetProjectsResponseValue)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProjects indicates an expected call of GetProjects
+func (mr *MockCoreClientMockRecorder) GetProjects(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjects", reflect.TypeOf((*MockCoreClient)(nil).GetProjects), arg0, arg1)
+}
+
+// GetProxies mocks base method
+func (m *MockCoreClient) GetProxies(arg0 context.Context, arg1 core.GetProxiesArgs) (*[]core.Proxy, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProxies", arg0, arg1)
+	ret0, _ := ret[0].(*[]core.Proxy)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProxies indicates an expected call of GetProxies
+func (mr *MockCoreClientMockRecorder) GetProxies(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProxies", reflect.TypeOf((*MockCoreClient)(nil).GetProxies), arg0, arg1)
+}
+
+// GetTeam mocks base method
+func (m *MockCoreClient) GetTeam(arg0 context.Context, arg1 core.GetTeamArgs) (*core.WebApiTeam, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTeam", arg0, arg1)
+	ret0, _ := ret[0].(*core.WebApiTeam)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTeam indicates an expected call of GetTeam
+func (mr *MockCoreClientMockRecorder) GetTeam(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeam", reflect.TypeOf((*MockCoreClient)(nil).GetTeam), arg0, arg1)
+}
+
+// GetTeamMembersWithExtendedProperties mocks base method
+func (m *MockCoreClient) GetTeamMembersWithExtendedProperties(arg0 context.Context, arg1 core.GetTeamMembersWithExtendedPropertiesArgs) (*[]webapi.TeamMember, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTeamMembersWithExtendedProperties", arg0, arg1)
+	ret0, _ := ret[0].(*[]webapi.TeamMember)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTeamMembersWithExtendedProperties indicates an expected call of GetTeamMembersWithExtendedProperties
+func (mr *MockCoreClientMockRecorder) GetTeamMembersWithExtendedProperties(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamMembersWithExtendedProperties", reflect.TypeOf((*MockCoreClient)(nil).GetTeamMembersWithExtendedProperties), arg0, arg1)
+}
+
+// GetTeams mocks base method
+func (m *MockCoreClient) GetTeams(arg0 context.Context, arg1 core.GetTeamsArgs) (*[]core.WebApiTeam, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTeams", arg0, arg1)
+	ret0, _ := ret[0].(*[]core.WebApiTeam)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTeams indicates an expected call of GetTeams
+func (mr *MockCoreClientMockRecorder) GetTeams(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeams", reflect.TypeOf((*MockCoreClient)(nil).GetTeams), arg0, arg1)
+}
+
+// QueueCreateProject mocks base method
+func (m *MockCoreClient) QueueCreateProject(arg0 context.Context, arg1 core.QueueCreateProjectArgs) (*operations.OperationReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "QueueCreateProject", arg0, arg1)
+	ret0, _ := ret[0].(*operations.OperationReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// QueueCreateProject indicates an expected call of QueueCreateProject
+func (mr *MockCoreClientMockRecorder) QueueCreateProject(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueCreateProject", reflect.TypeOf((*MockCoreClient)(nil).QueueCreateProject), arg0, arg1)
+}
+
+// QueueDeleteProject mocks base method
+func (m *MockCoreClient) QueueDeleteProject(arg0 context.Context, arg1 core.QueueDeleteProjectArgs) (*operations.OperationReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "QueueDeleteProject", arg0, arg1)
+	ret0, _ := ret[0].(*operations.OperationReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// QueueDeleteProject indicates an expected call of QueueDeleteProject
+func (mr *MockCoreClientMockRecorder) QueueDeleteProject(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueDeleteProject", reflect.TypeOf((*MockCoreClient)(nil).QueueDeleteProject), arg0, arg1)
+}
+
+// RemoveProjectAvatar mocks base method
+func (m *MockCoreClient) RemoveProjectAvatar(arg0 context.Context, arg1 core.RemoveProjectAvatarArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RemoveProjectAvatar", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RemoveProjectAvatar indicates an expected call of RemoveProjectAvatar
+func (mr *MockCoreClientMockRecorder) RemoveProjectAvatar(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProjectAvatar", reflect.TypeOf((*MockCoreClient)(nil).RemoveProjectAvatar), arg0, arg1)
+}
+
+// SetProjectAvatar mocks base method
+func (m *MockCoreClient) SetProjectAvatar(arg0 context.Context, arg1 core.SetProjectAvatarArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetProjectAvatar", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SetProjectAvatar indicates an expected call of SetProjectAvatar
+func (mr *MockCoreClientMockRecorder) SetProjectAvatar(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProjectAvatar", reflect.TypeOf((*MockCoreClient)(nil).SetProjectAvatar), arg0, arg1)
+}
+
+// SetProjectProperties mocks base method
+func (m *MockCoreClient) SetProjectProperties(arg0 context.Context, arg1 core.SetProjectPropertiesArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetProjectProperties", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SetProjectProperties indicates an expected call of SetProjectProperties
+func (mr *MockCoreClientMockRecorder) SetProjectProperties(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProjectProperties", reflect.TypeOf((*MockCoreClient)(nil).SetProjectProperties), arg0, arg1)
+}
+
+// UpdateProject mocks base method
+func (m *MockCoreClient) UpdateProject(arg0 context.Context, arg1 core.UpdateProjectArgs) (*operations.OperationReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateProject", arg0, arg1)
+	ret0, _ := ret[0].(*operations.OperationReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateProject indicates an expected call of UpdateProject
+func (mr *MockCoreClientMockRecorder) UpdateProject(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProject", reflect.TypeOf((*MockCoreClient)(nil).UpdateProject), arg0, arg1)
+}
+
+// UpdateTeam mocks base method
+func (m *MockCoreClient) UpdateTeam(arg0 context.Context, arg1 core.UpdateTeamArgs) (*core.WebApiTeam, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateTeam", arg0, arg1)
+	ret0, _ := ret[0].(*core.WebApiTeam)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateTeam indicates an expected call of UpdateTeam
+func (mr *MockCoreClientMockRecorder) UpdateTeam(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTeam", reflect.TypeOf((*MockCoreClient)(nil).UpdateTeam), arg0, arg1)
+}
diff --git a/azdosdkmocks/git_sdk_mock.go b/azdosdkmocks/git_sdk_mock.go
new file mode 100644
index 00000000..a92617d4
--- /dev/null
+++ b/azdosdkmocks/git_sdk_mock.go
@@ -0,0 +1,1763 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/microsoft/azure-devops-go-api/azuredevops/git (interfaces: Client)
+
+// Package azdosdkmocks is a generated GoMock package.
+package azdosdkmocks
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	core "github.com/microsoft/azure-devops-go-api/azuredevops/core"
+	git "github.com/microsoft/azure-devops-go-api/azuredevops/git"
+	webapi "github.com/microsoft/azure-devops-go-api/azuredevops/webapi"
+	io "io"
+	reflect "reflect"
+)
+
+// MockGitClient is a mock of Client interface
+type MockGitClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockGitClientMockRecorder
+}
+
+// MockGitClientMockRecorder is the mock recorder for MockGitClient
+type MockGitClientMockRecorder struct {
+	mock *MockGitClient
+}
+
+// NewMockGitClient creates a new mock instance
+func NewMockGitClient(ctrl *gomock.Controller) *MockGitClient {
+	mock := &MockGitClient{ctrl: ctrl}
+	mock.recorder = &MockGitClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockGitClient) EXPECT() *MockGitClientMockRecorder {
+	return m.recorder
+}
+
+// CreateAnnotatedTag mocks base method
+func (m *MockGitClient) CreateAnnotatedTag(arg0 context.Context, arg1 git.CreateAnnotatedTagArgs) (*git.GitAnnotatedTag, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateAnnotatedTag", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitAnnotatedTag)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateAnnotatedTag indicates an expected call of CreateAnnotatedTag
+func (mr *MockGitClientMockRecorder) CreateAnnotatedTag(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAnnotatedTag", reflect.TypeOf((*MockGitClient)(nil).CreateAnnotatedTag), arg0, arg1)
+}
+
+// CreateAttachment mocks base method
+func (m *MockGitClient) CreateAttachment(arg0 context.Context, arg1 git.CreateAttachmentArgs) (*git.Attachment, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateAttachment", arg0, arg1)
+	ret0, _ := ret[0].(*git.Attachment)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateAttachment indicates an expected call of CreateAttachment
+func (mr *MockGitClientMockRecorder) CreateAttachment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAttachment", reflect.TypeOf((*MockGitClient)(nil).CreateAttachment), arg0, arg1)
+}
+
+// CreateCherryPick mocks base method
+func (m *MockGitClient) CreateCherryPick(arg0 context.Context, arg1 git.CreateCherryPickArgs) (*git.GitCherryPick, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateCherryPick", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitCherryPick)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateCherryPick indicates an expected call of CreateCherryPick
+func (mr *MockGitClientMockRecorder) CreateCherryPick(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCherryPick", reflect.TypeOf((*MockGitClient)(nil).CreateCherryPick), arg0, arg1)
+}
+
+// CreateComment mocks base method
+func (m *MockGitClient) CreateComment(arg0 context.Context, arg1 git.CreateCommentArgs) (*git.Comment, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateComment", arg0, arg1)
+	ret0, _ := ret[0].(*git.Comment)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateComment indicates an expected call of CreateComment
+func (mr *MockGitClientMockRecorder) CreateComment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateComment", reflect.TypeOf((*MockGitClient)(nil).CreateComment), arg0, arg1)
+}
+
+// CreateCommitStatus mocks base method
+func (m *MockGitClient) CreateCommitStatus(arg0 context.Context, arg1 git.CreateCommitStatusArgs) (*git.GitStatus, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateCommitStatus", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateCommitStatus indicates an expected call of CreateCommitStatus
+func (mr *MockGitClientMockRecorder) CreateCommitStatus(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCommitStatus", reflect.TypeOf((*MockGitClient)(nil).CreateCommitStatus), arg0, arg1)
+}
+
+// CreateFavorite mocks base method
+func (m *MockGitClient) CreateFavorite(arg0 context.Context, arg1 git.CreateFavoriteArgs) (*git.GitRefFavorite, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateFavorite", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRefFavorite)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateFavorite indicates an expected call of CreateFavorite
+func (mr *MockGitClientMockRecorder) CreateFavorite(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFavorite", reflect.TypeOf((*MockGitClient)(nil).CreateFavorite), arg0, arg1)
+}
+
+// CreateForkSyncRequest mocks base method
+func (m *MockGitClient) CreateForkSyncRequest(arg0 context.Context, arg1 git.CreateForkSyncRequestArgs) (*git.GitForkSyncRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateForkSyncRequest", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitForkSyncRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateForkSyncRequest indicates an expected call of CreateForkSyncRequest
+func (mr *MockGitClientMockRecorder) CreateForkSyncRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateForkSyncRequest", reflect.TypeOf((*MockGitClient)(nil).CreateForkSyncRequest), arg0, arg1)
+}
+
+// CreateImportRequest mocks base method
+func (m *MockGitClient) CreateImportRequest(arg0 context.Context, arg1 git.CreateImportRequestArgs) (*git.GitImportRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateImportRequest", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitImportRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateImportRequest indicates an expected call of CreateImportRequest
+func (mr *MockGitClientMockRecorder) CreateImportRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImportRequest", reflect.TypeOf((*MockGitClient)(nil).CreateImportRequest), arg0, arg1)
+}
+
+// CreateLike mocks base method
+func (m *MockGitClient) CreateLike(arg0 context.Context, arg1 git.CreateLikeArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateLike", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateLike indicates an expected call of CreateLike
+func (mr *MockGitClientMockRecorder) CreateLike(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLike", reflect.TypeOf((*MockGitClient)(nil).CreateLike), arg0, arg1)
+}
+
+// CreateMergeRequest mocks base method
+func (m *MockGitClient) CreateMergeRequest(arg0 context.Context, arg1 git.CreateMergeRequestArgs) (*git.GitMerge, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateMergeRequest", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitMerge)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateMergeRequest indicates an expected call of CreateMergeRequest
+func (mr *MockGitClientMockRecorder) CreateMergeRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMergeRequest", reflect.TypeOf((*MockGitClient)(nil).CreateMergeRequest), arg0, arg1)
+}
+
+// CreatePullRequest mocks base method
+func (m *MockGitClient) CreatePullRequest(arg0 context.Context, arg1 git.CreatePullRequestArgs) (*git.GitPullRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatePullRequest", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreatePullRequest indicates an expected call of CreatePullRequest
+func (mr *MockGitClientMockRecorder) CreatePullRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePullRequest", reflect.TypeOf((*MockGitClient)(nil).CreatePullRequest), arg0, arg1)
+}
+
+// CreatePullRequestIterationStatus mocks base method
+func (m *MockGitClient) CreatePullRequestIterationStatus(arg0 context.Context, arg1 git.CreatePullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatePullRequestIterationStatus", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequestStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreatePullRequestIterationStatus indicates an expected call of CreatePullRequestIterationStatus
+func (mr *MockGitClientMockRecorder) CreatePullRequestIterationStatus(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePullRequestIterationStatus", reflect.TypeOf((*MockGitClient)(nil).CreatePullRequestIterationStatus), arg0, arg1)
+}
+
+// CreatePullRequestLabel mocks base method
+func (m *MockGitClient) CreatePullRequestLabel(arg0 context.Context, arg1 git.CreatePullRequestLabelArgs) (*core.WebApiTagDefinition, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatePullRequestLabel", arg0, arg1)
+	ret0, _ := ret[0].(*core.WebApiTagDefinition)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreatePullRequestLabel indicates an expected call of CreatePullRequestLabel
+func (mr *MockGitClientMockRecorder) CreatePullRequestLabel(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePullRequestLabel", reflect.TypeOf((*MockGitClient)(nil).CreatePullRequestLabel), arg0, arg1)
+}
+
+// CreatePullRequestReviewer mocks base method
+func (m *MockGitClient) CreatePullRequestReviewer(arg0 context.Context, arg1 git.CreatePullRequestReviewerArgs) (*git.IdentityRefWithVote, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatePullRequestReviewer", arg0, arg1)
+	ret0, _ := ret[0].(*git.IdentityRefWithVote)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreatePullRequestReviewer indicates an expected call of CreatePullRequestReviewer
+func (mr *MockGitClientMockRecorder) CreatePullRequestReviewer(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePullRequestReviewer", reflect.TypeOf((*MockGitClient)(nil).CreatePullRequestReviewer), arg0, arg1)
+}
+
+// CreatePullRequestReviewers mocks base method
+func (m *MockGitClient) CreatePullRequestReviewers(arg0 context.Context, arg1 git.CreatePullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatePullRequestReviewers", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.IdentityRefWithVote)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreatePullRequestReviewers indicates an expected call of CreatePullRequestReviewers
+func (mr *MockGitClientMockRecorder) CreatePullRequestReviewers(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePullRequestReviewers", reflect.TypeOf((*MockGitClient)(nil).CreatePullRequestReviewers), arg0, arg1)
+}
+
+// CreatePullRequestStatus mocks base method
+func (m *MockGitClient) CreatePullRequestStatus(arg0 context.Context, arg1 git.CreatePullRequestStatusArgs) (*git.GitPullRequestStatus, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatePullRequestStatus", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequestStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreatePullRequestStatus indicates an expected call of CreatePullRequestStatus
+func (mr *MockGitClientMockRecorder) CreatePullRequestStatus(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePullRequestStatus", reflect.TypeOf((*MockGitClient)(nil).CreatePullRequestStatus), arg0, arg1)
+}
+
+// CreatePush mocks base method
+func (m *MockGitClient) CreatePush(arg0 context.Context, arg1 git.CreatePushArgs) (*git.GitPush, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatePush", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPush)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreatePush indicates an expected call of CreatePush
+func (mr *MockGitClientMockRecorder) CreatePush(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePush", reflect.TypeOf((*MockGitClient)(nil).CreatePush), arg0, arg1)
+}
+
+// CreateRepository mocks base method
+func (m *MockGitClient) CreateRepository(arg0 context.Context, arg1 git.CreateRepositoryArgs) (*git.GitRepository, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateRepository", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRepository)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateRepository indicates an expected call of CreateRepository
+func (mr *MockGitClientMockRecorder) CreateRepository(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRepository", reflect.TypeOf((*MockGitClient)(nil).CreateRepository), arg0, arg1)
+}
+
+// CreateRevert mocks base method
+func (m *MockGitClient) CreateRevert(arg0 context.Context, arg1 git.CreateRevertArgs) (*git.GitRevert, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateRevert", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRevert)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateRevert indicates an expected call of CreateRevert
+func (mr *MockGitClientMockRecorder) CreateRevert(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRevert", reflect.TypeOf((*MockGitClient)(nil).CreateRevert), arg0, arg1)
+}
+
+// CreateThread mocks base method
+func (m *MockGitClient) CreateThread(arg0 context.Context, arg1 git.CreateThreadArgs) (*git.GitPullRequestCommentThread, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateThread", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequestCommentThread)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateThread indicates an expected call of CreateThread
+func (mr *MockGitClientMockRecorder) CreateThread(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateThread", reflect.TypeOf((*MockGitClient)(nil).CreateThread), arg0, arg1)
+}
+
+// DeleteAttachment mocks base method
+func (m *MockGitClient) DeleteAttachment(arg0 context.Context, arg1 git.DeleteAttachmentArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteAttachment", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteAttachment indicates an expected call of DeleteAttachment
+func (mr *MockGitClientMockRecorder) DeleteAttachment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAttachment", reflect.TypeOf((*MockGitClient)(nil).DeleteAttachment), arg0, arg1)
+}
+
+// DeleteComment mocks base method
+func (m *MockGitClient) DeleteComment(arg0 context.Context, arg1 git.DeleteCommentArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteComment", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteComment indicates an expected call of DeleteComment
+func (mr *MockGitClientMockRecorder) DeleteComment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteComment", reflect.TypeOf((*MockGitClient)(nil).DeleteComment), arg0, arg1)
+}
+
+// DeleteLike mocks base method
+func (m *MockGitClient) DeleteLike(arg0 context.Context, arg1 git.DeleteLikeArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteLike", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteLike indicates an expected call of DeleteLike
+func (mr *MockGitClientMockRecorder) DeleteLike(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLike", reflect.TypeOf((*MockGitClient)(nil).DeleteLike), arg0, arg1)
+}
+
+// DeletePullRequestIterationStatus mocks base method
+func (m *MockGitClient) DeletePullRequestIterationStatus(arg0 context.Context, arg1 git.DeletePullRequestIterationStatusArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeletePullRequestIterationStatus", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeletePullRequestIterationStatus indicates an expected call of DeletePullRequestIterationStatus
+func (mr *MockGitClientMockRecorder) DeletePullRequestIterationStatus(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePullRequestIterationStatus", reflect.TypeOf((*MockGitClient)(nil).DeletePullRequestIterationStatus), arg0, arg1)
+}
+
+// DeletePullRequestLabels mocks base method
+func (m *MockGitClient) DeletePullRequestLabels(arg0 context.Context, arg1 git.DeletePullRequestLabelsArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeletePullRequestLabels", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeletePullRequestLabels indicates an expected call of DeletePullRequestLabels
+func (mr *MockGitClientMockRecorder) DeletePullRequestLabels(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePullRequestLabels", reflect.TypeOf((*MockGitClient)(nil).DeletePullRequestLabels), arg0, arg1)
+}
+
+// DeletePullRequestReviewer mocks base method
+func (m *MockGitClient) DeletePullRequestReviewer(arg0 context.Context, arg1 git.DeletePullRequestReviewerArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeletePullRequestReviewer", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeletePullRequestReviewer indicates an expected call of DeletePullRequestReviewer
+func (mr *MockGitClientMockRecorder) DeletePullRequestReviewer(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePullRequestReviewer", reflect.TypeOf((*MockGitClient)(nil).DeletePullRequestReviewer), arg0, arg1)
+}
+
+// DeletePullRequestStatus mocks base method
+func (m *MockGitClient) DeletePullRequestStatus(arg0 context.Context, arg1 git.DeletePullRequestStatusArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeletePullRequestStatus", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeletePullRequestStatus indicates an expected call of DeletePullRequestStatus
+func (mr *MockGitClientMockRecorder) DeletePullRequestStatus(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePullRequestStatus", reflect.TypeOf((*MockGitClient)(nil).DeletePullRequestStatus), arg0, arg1)
+}
+
+// DeleteRefFavorite mocks base method
+func (m *MockGitClient) DeleteRefFavorite(arg0 context.Context, arg1 git.DeleteRefFavoriteArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteRefFavorite", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteRefFavorite indicates an expected call of DeleteRefFavorite
+func (mr *MockGitClientMockRecorder) DeleteRefFavorite(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRefFavorite", reflect.TypeOf((*MockGitClient)(nil).DeleteRefFavorite), arg0, arg1)
+}
+
+// DeleteRepository mocks base method
+func (m *MockGitClient) DeleteRepository(arg0 context.Context, arg1 git.DeleteRepositoryArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteRepository", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteRepository indicates an expected call of DeleteRepository
+func (mr *MockGitClientMockRecorder) DeleteRepository(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRepository", reflect.TypeOf((*MockGitClient)(nil).DeleteRepository), arg0, arg1)
+}
+
+// DeleteRepositoryFromRecycleBin mocks base method
+func (m *MockGitClient) DeleteRepositoryFromRecycleBin(arg0 context.Context, arg1 git.DeleteRepositoryFromRecycleBinArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteRepositoryFromRecycleBin", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteRepositoryFromRecycleBin indicates an expected call of DeleteRepositoryFromRecycleBin
+func (mr *MockGitClientMockRecorder) DeleteRepositoryFromRecycleBin(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRepositoryFromRecycleBin", reflect.TypeOf((*MockGitClient)(nil).DeleteRepositoryFromRecycleBin), arg0, arg1)
+}
+
+// GetAnnotatedTag mocks base method
+func (m *MockGitClient) GetAnnotatedTag(arg0 context.Context, arg1 git.GetAnnotatedTagArgs) (*git.GitAnnotatedTag, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAnnotatedTag", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitAnnotatedTag)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAnnotatedTag indicates an expected call of GetAnnotatedTag
+func (mr *MockGitClientMockRecorder) GetAnnotatedTag(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAnnotatedTag", reflect.TypeOf((*MockGitClient)(nil).GetAnnotatedTag), arg0, arg1)
+}
+
+// GetAttachmentContent mocks base method
+func (m *MockGitClient) GetAttachmentContent(arg0 context.Context, arg1 git.GetAttachmentContentArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAttachmentContent", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAttachmentContent indicates an expected call of GetAttachmentContent
+func (mr *MockGitClientMockRecorder) GetAttachmentContent(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttachmentContent", reflect.TypeOf((*MockGitClient)(nil).GetAttachmentContent), arg0, arg1)
+}
+
+// GetAttachmentZip mocks base method
+func (m *MockGitClient) GetAttachmentZip(arg0 context.Context, arg1 git.GetAttachmentZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAttachmentZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAttachmentZip indicates an expected call of GetAttachmentZip
+func (mr *MockGitClientMockRecorder) GetAttachmentZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttachmentZip", reflect.TypeOf((*MockGitClient)(nil).GetAttachmentZip), arg0, arg1)
+}
+
+// GetAttachments mocks base method
+func (m *MockGitClient) GetAttachments(arg0 context.Context, arg1 git.GetAttachmentsArgs) (*[]git.Attachment, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAttachments", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.Attachment)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAttachments indicates an expected call of GetAttachments
+func (mr *MockGitClientMockRecorder) GetAttachments(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttachments", reflect.TypeOf((*MockGitClient)(nil).GetAttachments), arg0, arg1)
+}
+
+// GetBlob mocks base method
+func (m *MockGitClient) GetBlob(arg0 context.Context, arg1 git.GetBlobArgs) (*git.GitBlobRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBlob", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitBlobRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBlob indicates an expected call of GetBlob
+func (mr *MockGitClientMockRecorder) GetBlob(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlob", reflect.TypeOf((*MockGitClient)(nil).GetBlob), arg0, arg1)
+}
+
+// GetBlobContent mocks base method
+func (m *MockGitClient) GetBlobContent(arg0 context.Context, arg1 git.GetBlobContentArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBlobContent", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBlobContent indicates an expected call of GetBlobContent
+func (mr *MockGitClientMockRecorder) GetBlobContent(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlobContent", reflect.TypeOf((*MockGitClient)(nil).GetBlobContent), arg0, arg1)
+}
+
+// GetBlobZip mocks base method
+func (m *MockGitClient) GetBlobZip(arg0 context.Context, arg1 git.GetBlobZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBlobZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBlobZip indicates an expected call of GetBlobZip
+func (mr *MockGitClientMockRecorder) GetBlobZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlobZip", reflect.TypeOf((*MockGitClient)(nil).GetBlobZip), arg0, arg1)
+}
+
+// GetBlobsZip mocks base method
+func (m *MockGitClient) GetBlobsZip(arg0 context.Context, arg1 git.GetBlobsZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBlobsZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBlobsZip indicates an expected call of GetBlobsZip
+func (mr *MockGitClientMockRecorder) GetBlobsZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlobsZip", reflect.TypeOf((*MockGitClient)(nil).GetBlobsZip), arg0, arg1)
+}
+
+// GetBranch mocks base method
+func (m *MockGitClient) GetBranch(arg0 context.Context, arg1 git.GetBranchArgs) (*git.GitBranchStats, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBranch", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitBranchStats)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBranch indicates an expected call of GetBranch
+func (mr *MockGitClientMockRecorder) GetBranch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranch", reflect.TypeOf((*MockGitClient)(nil).GetBranch), arg0, arg1)
+}
+
+// GetBranches mocks base method
+func (m *MockGitClient) GetBranches(arg0 context.Context, arg1 git.GetBranchesArgs) (*[]git.GitBranchStats, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBranches", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitBranchStats)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBranches indicates an expected call of GetBranches
+func (mr *MockGitClientMockRecorder) GetBranches(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranches", reflect.TypeOf((*MockGitClient)(nil).GetBranches), arg0, arg1)
+}
+
+// GetChanges mocks base method
+func (m *MockGitClient) GetChanges(arg0 context.Context, arg1 git.GetChangesArgs) (*git.GitCommitChanges, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetChanges", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitCommitChanges)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetChanges indicates an expected call of GetChanges
+func (mr *MockGitClientMockRecorder) GetChanges(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChanges", reflect.TypeOf((*MockGitClient)(nil).GetChanges), arg0, arg1)
+}
+
+// GetCherryPick mocks base method
+func (m *MockGitClient) GetCherryPick(arg0 context.Context, arg1 git.GetCherryPickArgs) (*git.GitCherryPick, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCherryPick", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitCherryPick)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCherryPick indicates an expected call of GetCherryPick
+func (mr *MockGitClientMockRecorder) GetCherryPick(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCherryPick", reflect.TypeOf((*MockGitClient)(nil).GetCherryPick), arg0, arg1)
+}
+
+// GetCherryPickForRefName mocks base method
+func (m *MockGitClient) GetCherryPickForRefName(arg0 context.Context, arg1 git.GetCherryPickForRefNameArgs) (*git.GitCherryPick, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCherryPickForRefName", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitCherryPick)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCherryPickForRefName indicates an expected call of GetCherryPickForRefName
+func (mr *MockGitClientMockRecorder) GetCherryPickForRefName(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCherryPickForRefName", reflect.TypeOf((*MockGitClient)(nil).GetCherryPickForRefName), arg0, arg1)
+}
+
+// GetComment mocks base method
+func (m *MockGitClient) GetComment(arg0 context.Context, arg1 git.GetCommentArgs) (*git.Comment, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetComment", arg0, arg1)
+	ret0, _ := ret[0].(*git.Comment)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetComment indicates an expected call of GetComment
+func (mr *MockGitClientMockRecorder) GetComment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComment", reflect.TypeOf((*MockGitClient)(nil).GetComment), arg0, arg1)
+}
+
+// GetComments mocks base method
+func (m *MockGitClient) GetComments(arg0 context.Context, arg1 git.GetCommentsArgs) (*[]git.Comment, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetComments", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.Comment)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetComments indicates an expected call of GetComments
+func (mr *MockGitClientMockRecorder) GetComments(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComments", reflect.TypeOf((*MockGitClient)(nil).GetComments), arg0, arg1)
+}
+
+// GetCommit mocks base method
+func (m *MockGitClient) GetCommit(arg0 context.Context, arg1 git.GetCommitArgs) (*git.GitCommit, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCommit", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitCommit)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCommit indicates an expected call of GetCommit
+func (mr *MockGitClientMockRecorder) GetCommit(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockGitClient)(nil).GetCommit), arg0, arg1)
+}
+
+// GetCommitDiffs mocks base method
+func (m *MockGitClient) GetCommitDiffs(arg0 context.Context, arg1 git.GetCommitDiffsArgs) (*git.GitCommitDiffs, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCommitDiffs", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitCommitDiffs)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCommitDiffs indicates an expected call of GetCommitDiffs
+func (mr *MockGitClientMockRecorder) GetCommitDiffs(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitDiffs", reflect.TypeOf((*MockGitClient)(nil).GetCommitDiffs), arg0, arg1)
+}
+
+// GetCommits mocks base method
+func (m *MockGitClient) GetCommits(arg0 context.Context, arg1 git.GetCommitsArgs) (*[]git.GitCommitRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCommits", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitCommitRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCommits indicates an expected call of GetCommits
+func (mr *MockGitClientMockRecorder) GetCommits(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommits", reflect.TypeOf((*MockGitClient)(nil).GetCommits), arg0, arg1)
+}
+
+// GetCommitsBatch mocks base method
+func (m *MockGitClient) GetCommitsBatch(arg0 context.Context, arg1 git.GetCommitsBatchArgs) (*[]git.GitCommitRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCommitsBatch", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitCommitRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCommitsBatch indicates an expected call of GetCommitsBatch
+func (mr *MockGitClientMockRecorder) GetCommitsBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitsBatch", reflect.TypeOf((*MockGitClient)(nil).GetCommitsBatch), arg0, arg1)
+}
+
+// GetDeletedRepositories mocks base method
+func (m *MockGitClient) GetDeletedRepositories(arg0 context.Context, arg1 git.GetDeletedRepositoriesArgs) (*[]git.GitDeletedRepository, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDeletedRepositories", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitDeletedRepository)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDeletedRepositories indicates an expected call of GetDeletedRepositories
+func (mr *MockGitClientMockRecorder) GetDeletedRepositories(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeletedRepositories", reflect.TypeOf((*MockGitClient)(nil).GetDeletedRepositories), arg0, arg1)
+}
+
+// GetForkSyncRequest mocks base method
+func (m *MockGitClient) GetForkSyncRequest(arg0 context.Context, arg1 git.GetForkSyncRequestArgs) (*git.GitForkSyncRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetForkSyncRequest", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitForkSyncRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetForkSyncRequest indicates an expected call of GetForkSyncRequest
+func (mr *MockGitClientMockRecorder) GetForkSyncRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetForkSyncRequest", reflect.TypeOf((*MockGitClient)(nil).GetForkSyncRequest), arg0, arg1)
+}
+
+// GetForkSyncRequests mocks base method
+func (m *MockGitClient) GetForkSyncRequests(arg0 context.Context, arg1 git.GetForkSyncRequestsArgs) (*[]git.GitForkSyncRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetForkSyncRequests", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitForkSyncRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetForkSyncRequests indicates an expected call of GetForkSyncRequests
+func (mr *MockGitClientMockRecorder) GetForkSyncRequests(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetForkSyncRequests", reflect.TypeOf((*MockGitClient)(nil).GetForkSyncRequests), arg0, arg1)
+}
+
+// GetForks mocks base method
+func (m *MockGitClient) GetForks(arg0 context.Context, arg1 git.GetForksArgs) (*[]git.GitRepositoryRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetForks", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitRepositoryRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetForks indicates an expected call of GetForks
+func (mr *MockGitClientMockRecorder) GetForks(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetForks", reflect.TypeOf((*MockGitClient)(nil).GetForks), arg0, arg1)
+}
+
+// GetImportRequest mocks base method
+func (m *MockGitClient) GetImportRequest(arg0 context.Context, arg1 git.GetImportRequestArgs) (*git.GitImportRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetImportRequest", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitImportRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetImportRequest indicates an expected call of GetImportRequest
+func (mr *MockGitClientMockRecorder) GetImportRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImportRequest", reflect.TypeOf((*MockGitClient)(nil).GetImportRequest), arg0, arg1)
+}
+
+// GetItem mocks base method
+func (m *MockGitClient) GetItem(arg0 context.Context, arg1 git.GetItemArgs) (*git.GitItem, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetItem", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitItem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetItem indicates an expected call of GetItem
+func (mr *MockGitClientMockRecorder) GetItem(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItem", reflect.TypeOf((*MockGitClient)(nil).GetItem), arg0, arg1)
+}
+
+// GetItemContent mocks base method
+func (m *MockGitClient) GetItemContent(arg0 context.Context, arg1 git.GetItemContentArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetItemContent", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetItemContent indicates an expected call of GetItemContent
+func (mr *MockGitClientMockRecorder) GetItemContent(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemContent", reflect.TypeOf((*MockGitClient)(nil).GetItemContent), arg0, arg1)
+}
+
+// GetItemText mocks base method
+func (m *MockGitClient) GetItemText(arg0 context.Context, arg1 git.GetItemTextArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetItemText", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetItemText indicates an expected call of GetItemText
+func (mr *MockGitClientMockRecorder) GetItemText(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemText", reflect.TypeOf((*MockGitClient)(nil).GetItemText), arg0, arg1)
+}
+
+// GetItemZip mocks base method
+func (m *MockGitClient) GetItemZip(arg0 context.Context, arg1 git.GetItemZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetItemZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetItemZip indicates an expected call of GetItemZip
+func (mr *MockGitClientMockRecorder) GetItemZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemZip", reflect.TypeOf((*MockGitClient)(nil).GetItemZip), arg0, arg1)
+}
+
+// GetItems mocks base method
+func (m *MockGitClient) GetItems(arg0 context.Context, arg1 git.GetItemsArgs) (*[]git.GitItem, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetItems", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitItem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetItems indicates an expected call of GetItems
+func (mr *MockGitClientMockRecorder) GetItems(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItems", reflect.TypeOf((*MockGitClient)(nil).GetItems), arg0, arg1)
+}
+
+// GetItemsBatch mocks base method
+func (m *MockGitClient) GetItemsBatch(arg0 context.Context, arg1 git.GetItemsBatchArgs) (*[][]git.GitItem, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetItemsBatch", arg0, arg1)
+	ret0, _ := ret[0].(*[][]git.GitItem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetItemsBatch indicates an expected call of GetItemsBatch
+func (mr *MockGitClientMockRecorder) GetItemsBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemsBatch", reflect.TypeOf((*MockGitClient)(nil).GetItemsBatch), arg0, arg1)
+}
+
+// GetLikes mocks base method
+func (m *MockGitClient) GetLikes(arg0 context.Context, arg1 git.GetLikesArgs) (*[]webapi.IdentityRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLikes", arg0, arg1)
+	ret0, _ := ret[0].(*[]webapi.IdentityRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLikes indicates an expected call of GetLikes
+func (mr *MockGitClientMockRecorder) GetLikes(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLikes", reflect.TypeOf((*MockGitClient)(nil).GetLikes), arg0, arg1)
+}
+
+// GetMergeBases mocks base method
+func (m *MockGitClient) GetMergeBases(arg0 context.Context, arg1 git.GetMergeBasesArgs) (*[]git.GitCommitRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMergeBases", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitCommitRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetMergeBases indicates an expected call of GetMergeBases
+func (mr *MockGitClientMockRecorder) GetMergeBases(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeBases", reflect.TypeOf((*MockGitClient)(nil).GetMergeBases), arg0, arg1)
+}
+
+// GetMergeRequest mocks base method
+func (m *MockGitClient) GetMergeRequest(arg0 context.Context, arg1 git.GetMergeRequestArgs) (*git.GitMerge, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMergeRequest", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitMerge)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetMergeRequest indicates an expected call of GetMergeRequest
+func (mr *MockGitClientMockRecorder) GetMergeRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMergeRequest", reflect.TypeOf((*MockGitClient)(nil).GetMergeRequest), arg0, arg1)
+}
+
+// GetPolicyConfigurations mocks base method
+func (m *MockGitClient) GetPolicyConfigurations(arg0 context.Context, arg1 git.GetPolicyConfigurationsArgs) (*git.GitPolicyConfigurationResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPolicyConfigurations", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPolicyConfigurationResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPolicyConfigurations indicates an expected call of GetPolicyConfigurations
+func (mr *MockGitClientMockRecorder) GetPolicyConfigurations(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyConfigurations", reflect.TypeOf((*MockGitClient)(nil).GetPolicyConfigurations), arg0, arg1)
+}
+
+// GetPullRequest mocks base method
+func (m *MockGitClient) GetPullRequest(arg0 context.Context, arg1 git.GetPullRequestArgs) (*git.GitPullRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequest", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequest indicates an expected call of GetPullRequest
+func (mr *MockGitClientMockRecorder) GetPullRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockGitClient)(nil).GetPullRequest), arg0, arg1)
+}
+
+// GetPullRequestById mocks base method
+func (m *MockGitClient) GetPullRequestById(arg0 context.Context, arg1 git.GetPullRequestByIdArgs) (*git.GitPullRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestById", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestById indicates an expected call of GetPullRequestById
+func (mr *MockGitClientMockRecorder) GetPullRequestById(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestById", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestById), arg0, arg1)
+}
+
+// GetPullRequestCommits mocks base method
+func (m *MockGitClient) GetPullRequestCommits(arg0 context.Context, arg1 git.GetPullRequestCommitsArgs) (*git.GetPullRequestCommitsResponseValue, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestCommits", arg0, arg1)
+	ret0, _ := ret[0].(*git.GetPullRequestCommitsResponseValue)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestCommits indicates an expected call of GetPullRequestCommits
+func (mr *MockGitClientMockRecorder) GetPullRequestCommits(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestCommits", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestCommits), arg0, arg1)
+}
+
+// GetPullRequestIteration mocks base method
+func (m *MockGitClient) GetPullRequestIteration(arg0 context.Context, arg1 git.GetPullRequestIterationArgs) (*git.GitPullRequestIteration, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestIteration", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequestIteration)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestIteration indicates an expected call of GetPullRequestIteration
+func (mr *MockGitClientMockRecorder) GetPullRequestIteration(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestIteration", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestIteration), arg0, arg1)
+}
+
+// GetPullRequestIterationChanges mocks base method
+func (m *MockGitClient) GetPullRequestIterationChanges(arg0 context.Context, arg1 git.GetPullRequestIterationChangesArgs) (*git.GitPullRequestIterationChanges, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestIterationChanges", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequestIterationChanges)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestIterationChanges indicates an expected call of GetPullRequestIterationChanges
+func (mr *MockGitClientMockRecorder) GetPullRequestIterationChanges(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestIterationChanges", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestIterationChanges), arg0, arg1)
+}
+
+// GetPullRequestIterationCommits mocks base method
+func (m *MockGitClient) GetPullRequestIterationCommits(arg0 context.Context, arg1 git.GetPullRequestIterationCommitsArgs) (*[]git.GitCommitRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestIterationCommits", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitCommitRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestIterationCommits indicates an expected call of GetPullRequestIterationCommits
+func (mr *MockGitClientMockRecorder) GetPullRequestIterationCommits(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestIterationCommits", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestIterationCommits), arg0, arg1)
+}
+
+// GetPullRequestIterationStatus mocks base method
+func (m *MockGitClient) GetPullRequestIterationStatus(arg0 context.Context, arg1 git.GetPullRequestIterationStatusArgs) (*git.GitPullRequestStatus, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestIterationStatus", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequestStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestIterationStatus indicates an expected call of GetPullRequestIterationStatus
+func (mr *MockGitClientMockRecorder) GetPullRequestIterationStatus(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestIterationStatus", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestIterationStatus), arg0, arg1)
+}
+
+// GetPullRequestIterationStatuses mocks base method
+func (m *MockGitClient) GetPullRequestIterationStatuses(arg0 context.Context, arg1 git.GetPullRequestIterationStatusesArgs) (*[]git.GitPullRequestStatus, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestIterationStatuses", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitPullRequestStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestIterationStatuses indicates an expected call of GetPullRequestIterationStatuses
+func (mr *MockGitClientMockRecorder) GetPullRequestIterationStatuses(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestIterationStatuses", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestIterationStatuses), arg0, arg1)
+}
+
+// GetPullRequestIterations mocks base method
+func (m *MockGitClient) GetPullRequestIterations(arg0 context.Context, arg1 git.GetPullRequestIterationsArgs) (*[]git.GitPullRequestIteration, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestIterations", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitPullRequestIteration)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestIterations indicates an expected call of GetPullRequestIterations
+func (mr *MockGitClientMockRecorder) GetPullRequestIterations(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestIterations", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestIterations), arg0, arg1)
+}
+
+// GetPullRequestLabel mocks base method
+func (m *MockGitClient) GetPullRequestLabel(arg0 context.Context, arg1 git.GetPullRequestLabelArgs) (*core.WebApiTagDefinition, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestLabel", arg0, arg1)
+	ret0, _ := ret[0].(*core.WebApiTagDefinition)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestLabel indicates an expected call of GetPullRequestLabel
+func (mr *MockGitClientMockRecorder) GetPullRequestLabel(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestLabel", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestLabel), arg0, arg1)
+}
+
+// GetPullRequestLabels mocks base method
+func (m *MockGitClient) GetPullRequestLabels(arg0 context.Context, arg1 git.GetPullRequestLabelsArgs) (*[]core.WebApiTagDefinition, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestLabels", arg0, arg1)
+	ret0, _ := ret[0].(*[]core.WebApiTagDefinition)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestLabels indicates an expected call of GetPullRequestLabels
+func (mr *MockGitClientMockRecorder) GetPullRequestLabels(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestLabels", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestLabels), arg0, arg1)
+}
+
+// GetPullRequestProperties mocks base method
+func (m *MockGitClient) GetPullRequestProperties(arg0 context.Context, arg1 git.GetPullRequestPropertiesArgs) (interface{}, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestProperties", arg0, arg1)
+	ret0, _ := ret[0].(interface{})
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestProperties indicates an expected call of GetPullRequestProperties
+func (mr *MockGitClientMockRecorder) GetPullRequestProperties(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestProperties", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestProperties), arg0, arg1)
+}
+
+// GetPullRequestQuery mocks base method
+func (m *MockGitClient) GetPullRequestQuery(arg0 context.Context, arg1 git.GetPullRequestQueryArgs) (*git.GitPullRequestQuery, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestQuery", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequestQuery)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestQuery indicates an expected call of GetPullRequestQuery
+func (mr *MockGitClientMockRecorder) GetPullRequestQuery(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestQuery", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestQuery), arg0, arg1)
+}
+
+// GetPullRequestReviewer mocks base method
+func (m *MockGitClient) GetPullRequestReviewer(arg0 context.Context, arg1 git.GetPullRequestReviewerArgs) (*git.IdentityRefWithVote, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestReviewer", arg0, arg1)
+	ret0, _ := ret[0].(*git.IdentityRefWithVote)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestReviewer indicates an expected call of GetPullRequestReviewer
+func (mr *MockGitClientMockRecorder) GetPullRequestReviewer(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviewer", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestReviewer), arg0, arg1)
+}
+
+// GetPullRequestReviewers mocks base method
+func (m *MockGitClient) GetPullRequestReviewers(arg0 context.Context, arg1 git.GetPullRequestReviewersArgs) (*[]git.IdentityRefWithVote, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestReviewers", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.IdentityRefWithVote)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestReviewers indicates an expected call of GetPullRequestReviewers
+func (mr *MockGitClientMockRecorder) GetPullRequestReviewers(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviewers", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestReviewers), arg0, arg1)
+}
+
+// GetPullRequestStatus mocks base method
+func (m *MockGitClient) GetPullRequestStatus(arg0 context.Context, arg1 git.GetPullRequestStatusArgs) (*git.GitPullRequestStatus, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestStatus", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequestStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestStatus indicates an expected call of GetPullRequestStatus
+func (mr *MockGitClientMockRecorder) GetPullRequestStatus(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestStatus", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestStatus), arg0, arg1)
+}
+
+// GetPullRequestStatuses mocks base method
+func (m *MockGitClient) GetPullRequestStatuses(arg0 context.Context, arg1 git.GetPullRequestStatusesArgs) (*[]git.GitPullRequestStatus, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestStatuses", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitPullRequestStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestStatuses indicates an expected call of GetPullRequestStatuses
+func (mr *MockGitClientMockRecorder) GetPullRequestStatuses(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestStatuses", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestStatuses), arg0, arg1)
+}
+
+// GetPullRequestThread mocks base method
+func (m *MockGitClient) GetPullRequestThread(arg0 context.Context, arg1 git.GetPullRequestThreadArgs) (*git.GitPullRequestCommentThread, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestThread", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequestCommentThread)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestThread indicates an expected call of GetPullRequestThread
+func (mr *MockGitClientMockRecorder) GetPullRequestThread(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestThread", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestThread), arg0, arg1)
+}
+
+// GetPullRequestWorkItemRefs mocks base method
+func (m *MockGitClient) GetPullRequestWorkItemRefs(arg0 context.Context, arg1 git.GetPullRequestWorkItemRefsArgs) (*[]webapi.ResourceRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestWorkItemRefs", arg0, arg1)
+	ret0, _ := ret[0].(*[]webapi.ResourceRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestWorkItemRefs indicates an expected call of GetPullRequestWorkItemRefs
+func (mr *MockGitClientMockRecorder) GetPullRequestWorkItemRefs(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestWorkItemRefs", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestWorkItemRefs), arg0, arg1)
+}
+
+// GetPullRequests mocks base method
+func (m *MockGitClient) GetPullRequests(arg0 context.Context, arg1 git.GetPullRequestsArgs) (*[]git.GitPullRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequests", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitPullRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequests indicates an expected call of GetPullRequests
+func (mr *MockGitClientMockRecorder) GetPullRequests(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequests", reflect.TypeOf((*MockGitClient)(nil).GetPullRequests), arg0, arg1)
+}
+
+// GetPullRequestsByProject mocks base method
+func (m *MockGitClient) GetPullRequestsByProject(arg0 context.Context, arg1 git.GetPullRequestsByProjectArgs) (*[]git.GitPullRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPullRequestsByProject", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitPullRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPullRequestsByProject indicates an expected call of GetPullRequestsByProject
+func (mr *MockGitClientMockRecorder) GetPullRequestsByProject(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestsByProject", reflect.TypeOf((*MockGitClient)(nil).GetPullRequestsByProject), arg0, arg1)
+}
+
+// GetPush mocks base method
+func (m *MockGitClient) GetPush(arg0 context.Context, arg1 git.GetPushArgs) (*git.GitPush, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPush", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPush)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPush indicates an expected call of GetPush
+func (mr *MockGitClientMockRecorder) GetPush(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPush", reflect.TypeOf((*MockGitClient)(nil).GetPush), arg0, arg1)
+}
+
+// GetPushCommits mocks base method
+func (m *MockGitClient) GetPushCommits(arg0 context.Context, arg1 git.GetPushCommitsArgs) (*[]git.GitCommitRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPushCommits", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitCommitRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPushCommits indicates an expected call of GetPushCommits
+func (mr *MockGitClientMockRecorder) GetPushCommits(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPushCommits", reflect.TypeOf((*MockGitClient)(nil).GetPushCommits), arg0, arg1)
+}
+
+// GetPushes mocks base method
+func (m *MockGitClient) GetPushes(arg0 context.Context, arg1 git.GetPushesArgs) (*[]git.GitPush, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPushes", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitPush)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPushes indicates an expected call of GetPushes
+func (mr *MockGitClientMockRecorder) GetPushes(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPushes", reflect.TypeOf((*MockGitClient)(nil).GetPushes), arg0, arg1)
+}
+
+// GetRecycleBinRepositories mocks base method
+func (m *MockGitClient) GetRecycleBinRepositories(arg0 context.Context, arg1 git.GetRecycleBinRepositoriesArgs) (*[]git.GitDeletedRepository, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRecycleBinRepositories", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitDeletedRepository)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRecycleBinRepositories indicates an expected call of GetRecycleBinRepositories
+func (mr *MockGitClientMockRecorder) GetRecycleBinRepositories(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecycleBinRepositories", reflect.TypeOf((*MockGitClient)(nil).GetRecycleBinRepositories), arg0, arg1)
+}
+
+// GetRefFavorite mocks base method
+func (m *MockGitClient) GetRefFavorite(arg0 context.Context, arg1 git.GetRefFavoriteArgs) (*git.GitRefFavorite, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRefFavorite", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRefFavorite)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRefFavorite indicates an expected call of GetRefFavorite
+func (mr *MockGitClientMockRecorder) GetRefFavorite(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRefFavorite", reflect.TypeOf((*MockGitClient)(nil).GetRefFavorite), arg0, arg1)
+}
+
+// GetRefFavorites mocks base method
+func (m *MockGitClient) GetRefFavorites(arg0 context.Context, arg1 git.GetRefFavoritesArgs) (*[]git.GitRefFavorite, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRefFavorites", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitRefFavorite)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRefFavorites indicates an expected call of GetRefFavorites
+func (mr *MockGitClientMockRecorder) GetRefFavorites(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRefFavorites", reflect.TypeOf((*MockGitClient)(nil).GetRefFavorites), arg0, arg1)
+}
+
+// GetRefs mocks base method
+func (m *MockGitClient) GetRefs(arg0 context.Context, arg1 git.GetRefsArgs) (*git.GetRefsResponseValue, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRefs", arg0, arg1)
+	ret0, _ := ret[0].(*git.GetRefsResponseValue)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRefs indicates an expected call of GetRefs
+func (mr *MockGitClientMockRecorder) GetRefs(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRefs", reflect.TypeOf((*MockGitClient)(nil).GetRefs), arg0, arg1)
+}
+
+// GetRepositories mocks base method
+func (m *MockGitClient) GetRepositories(arg0 context.Context, arg1 git.GetRepositoriesArgs) (*[]git.GitRepository, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRepositories", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitRepository)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRepositories indicates an expected call of GetRepositories
+func (mr *MockGitClientMockRecorder) GetRepositories(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositories", reflect.TypeOf((*MockGitClient)(nil).GetRepositories), arg0, arg1)
+}
+
+// GetRepository mocks base method
+func (m *MockGitClient) GetRepository(arg0 context.Context, arg1 git.GetRepositoryArgs) (*git.GitRepository, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRepository", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRepository)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRepository indicates an expected call of GetRepository
+func (mr *MockGitClientMockRecorder) GetRepository(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockGitClient)(nil).GetRepository), arg0, arg1)
+}
+
+// GetRepositoryWithParent mocks base method
+func (m *MockGitClient) GetRepositoryWithParent(arg0 context.Context, arg1 git.GetRepositoryWithParentArgs) (*git.GitRepository, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRepositoryWithParent", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRepository)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRepositoryWithParent indicates an expected call of GetRepositoryWithParent
+func (mr *MockGitClientMockRecorder) GetRepositoryWithParent(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryWithParent", reflect.TypeOf((*MockGitClient)(nil).GetRepositoryWithParent), arg0, arg1)
+}
+
+// GetRevert mocks base method
+func (m *MockGitClient) GetRevert(arg0 context.Context, arg1 git.GetRevertArgs) (*git.GitRevert, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRevert", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRevert)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRevert indicates an expected call of GetRevert
+func (mr *MockGitClientMockRecorder) GetRevert(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRevert", reflect.TypeOf((*MockGitClient)(nil).GetRevert), arg0, arg1)
+}
+
+// GetRevertForRefName mocks base method
+func (m *MockGitClient) GetRevertForRefName(arg0 context.Context, arg1 git.GetRevertForRefNameArgs) (*git.GitRevert, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRevertForRefName", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRevert)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRevertForRefName indicates an expected call of GetRevertForRefName
+func (mr *MockGitClientMockRecorder) GetRevertForRefName(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRevertForRefName", reflect.TypeOf((*MockGitClient)(nil).GetRevertForRefName), arg0, arg1)
+}
+
+// GetStatuses mocks base method
+func (m *MockGitClient) GetStatuses(arg0 context.Context, arg1 git.GetStatusesArgs) (*[]git.GitStatus, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStatuses", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStatuses indicates an expected call of GetStatuses
+func (mr *MockGitClientMockRecorder) GetStatuses(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatuses", reflect.TypeOf((*MockGitClient)(nil).GetStatuses), arg0, arg1)
+}
+
+// GetSuggestions mocks base method
+func (m *MockGitClient) GetSuggestions(arg0 context.Context, arg1 git.GetSuggestionsArgs) (*[]git.GitSuggestion, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSuggestions", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitSuggestion)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSuggestions indicates an expected call of GetSuggestions
+func (mr *MockGitClientMockRecorder) GetSuggestions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSuggestions", reflect.TypeOf((*MockGitClient)(nil).GetSuggestions), arg0, arg1)
+}
+
+// GetThreads mocks base method
+func (m *MockGitClient) GetThreads(arg0 context.Context, arg1 git.GetThreadsArgs) (*[]git.GitPullRequestCommentThread, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetThreads", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitPullRequestCommentThread)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetThreads indicates an expected call of GetThreads
+func (mr *MockGitClientMockRecorder) GetThreads(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetThreads", reflect.TypeOf((*MockGitClient)(nil).GetThreads), arg0, arg1)
+}
+
+// GetTree mocks base method
+func (m *MockGitClient) GetTree(arg0 context.Context, arg1 git.GetTreeArgs) (*git.GitTreeRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTree", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitTreeRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTree indicates an expected call of GetTree
+func (mr *MockGitClientMockRecorder) GetTree(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTree", reflect.TypeOf((*MockGitClient)(nil).GetTree), arg0, arg1)
+}
+
+// GetTreeZip mocks base method
+func (m *MockGitClient) GetTreeZip(arg0 context.Context, arg1 git.GetTreeZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTreeZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTreeZip indicates an expected call of GetTreeZip
+func (mr *MockGitClientMockRecorder) GetTreeZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTreeZip", reflect.TypeOf((*MockGitClient)(nil).GetTreeZip), arg0, arg1)
+}
+
+// QueryImportRequests mocks base method
+func (m *MockGitClient) QueryImportRequests(arg0 context.Context, arg1 git.QueryImportRequestsArgs) (*[]git.GitImportRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "QueryImportRequests", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitImportRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// QueryImportRequests indicates an expected call of QueryImportRequests
+func (mr *MockGitClientMockRecorder) QueryImportRequests(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryImportRequests", reflect.TypeOf((*MockGitClient)(nil).QueryImportRequests), arg0, arg1)
+}
+
+// RestoreRepositoryFromRecycleBin mocks base method
+func (m *MockGitClient) RestoreRepositoryFromRecycleBin(arg0 context.Context, arg1 git.RestoreRepositoryFromRecycleBinArgs) (*git.GitRepository, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RestoreRepositoryFromRecycleBin", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRepository)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RestoreRepositoryFromRecycleBin indicates an expected call of RestoreRepositoryFromRecycleBin
+func (mr *MockGitClientMockRecorder) RestoreRepositoryFromRecycleBin(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreRepositoryFromRecycleBin", reflect.TypeOf((*MockGitClient)(nil).RestoreRepositoryFromRecycleBin), arg0, arg1)
+}
+
+// SharePullRequest mocks base method
+func (m *MockGitClient) SharePullRequest(arg0 context.Context, arg1 git.SharePullRequestArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SharePullRequest", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SharePullRequest indicates an expected call of SharePullRequest
+func (mr *MockGitClientMockRecorder) SharePullRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SharePullRequest", reflect.TypeOf((*MockGitClient)(nil).SharePullRequest), arg0, arg1)
+}
+
+// UpdateComment mocks base method
+func (m *MockGitClient) UpdateComment(arg0 context.Context, arg1 git.UpdateCommentArgs) (*git.Comment, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateComment", arg0, arg1)
+	ret0, _ := ret[0].(*git.Comment)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateComment indicates an expected call of UpdateComment
+func (mr *MockGitClientMockRecorder) UpdateComment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateComment", reflect.TypeOf((*MockGitClient)(nil).UpdateComment), arg0, arg1)
+}
+
+// UpdateImportRequest mocks base method
+func (m *MockGitClient) UpdateImportRequest(arg0 context.Context, arg1 git.UpdateImportRequestArgs) (*git.GitImportRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateImportRequest", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitImportRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateImportRequest indicates an expected call of UpdateImportRequest
+func (mr *MockGitClientMockRecorder) UpdateImportRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateImportRequest", reflect.TypeOf((*MockGitClient)(nil).UpdateImportRequest), arg0, arg1)
+}
+
+// UpdatePullRequest mocks base method
+func (m *MockGitClient) UpdatePullRequest(arg0 context.Context, arg1 git.UpdatePullRequestArgs) (*git.GitPullRequest, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdatePullRequest", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequest)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdatePullRequest indicates an expected call of UpdatePullRequest
+func (mr *MockGitClientMockRecorder) UpdatePullRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequest", reflect.TypeOf((*MockGitClient)(nil).UpdatePullRequest), arg0, arg1)
+}
+
+// UpdatePullRequestIterationStatuses mocks base method
+func (m *MockGitClient) UpdatePullRequestIterationStatuses(arg0 context.Context, arg1 git.UpdatePullRequestIterationStatusesArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdatePullRequestIterationStatuses", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdatePullRequestIterationStatuses indicates an expected call of UpdatePullRequestIterationStatuses
+func (mr *MockGitClientMockRecorder) UpdatePullRequestIterationStatuses(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequestIterationStatuses", reflect.TypeOf((*MockGitClient)(nil).UpdatePullRequestIterationStatuses), arg0, arg1)
+}
+
+// UpdatePullRequestProperties mocks base method
+func (m *MockGitClient) UpdatePullRequestProperties(arg0 context.Context, arg1 git.UpdatePullRequestPropertiesArgs) (interface{}, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdatePullRequestProperties", arg0, arg1)
+	ret0, _ := ret[0].(interface{})
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdatePullRequestProperties indicates an expected call of UpdatePullRequestProperties
+func (mr *MockGitClientMockRecorder) UpdatePullRequestProperties(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequestProperties", reflect.TypeOf((*MockGitClient)(nil).UpdatePullRequestProperties), arg0, arg1)
+}
+
+// UpdatePullRequestReviewers mocks base method
+func (m *MockGitClient) UpdatePullRequestReviewers(arg0 context.Context, arg1 git.UpdatePullRequestReviewersArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdatePullRequestReviewers", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdatePullRequestReviewers indicates an expected call of UpdatePullRequestReviewers
+func (mr *MockGitClientMockRecorder) UpdatePullRequestReviewers(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequestReviewers", reflect.TypeOf((*MockGitClient)(nil).UpdatePullRequestReviewers), arg0, arg1)
+}
+
+// UpdatePullRequestStatuses mocks base method
+func (m *MockGitClient) UpdatePullRequestStatuses(arg0 context.Context, arg1 git.UpdatePullRequestStatusesArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdatePullRequestStatuses", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdatePullRequestStatuses indicates an expected call of UpdatePullRequestStatuses
+func (mr *MockGitClientMockRecorder) UpdatePullRequestStatuses(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequestStatuses", reflect.TypeOf((*MockGitClient)(nil).UpdatePullRequestStatuses), arg0, arg1)
+}
+
+// UpdateRef mocks base method
+func (m *MockGitClient) UpdateRef(arg0 context.Context, arg1 git.UpdateRefArgs) (*git.GitRef, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateRef", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRef)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateRef indicates an expected call of UpdateRef
+func (mr *MockGitClientMockRecorder) UpdateRef(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRef", reflect.TypeOf((*MockGitClient)(nil).UpdateRef), arg0, arg1)
+}
+
+// UpdateRefs mocks base method
+func (m *MockGitClient) UpdateRefs(arg0 context.Context, arg1 git.UpdateRefsArgs) (*[]git.GitRefUpdateResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateRefs", arg0, arg1)
+	ret0, _ := ret[0].(*[]git.GitRefUpdateResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateRefs indicates an expected call of UpdateRefs
+func (mr *MockGitClientMockRecorder) UpdateRefs(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRefs", reflect.TypeOf((*MockGitClient)(nil).UpdateRefs), arg0, arg1)
+}
+
+// UpdateRepository mocks base method
+func (m *MockGitClient) UpdateRepository(arg0 context.Context, arg1 git.UpdateRepositoryArgs) (*git.GitRepository, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateRepository", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitRepository)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateRepository indicates an expected call of UpdateRepository
+func (mr *MockGitClientMockRecorder) UpdateRepository(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRepository", reflect.TypeOf((*MockGitClient)(nil).UpdateRepository), arg0, arg1)
+}
+
+// UpdateThread mocks base method
+func (m *MockGitClient) UpdateThread(arg0 context.Context, arg1 git.UpdateThreadArgs) (*git.GitPullRequestCommentThread, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateThread", arg0, arg1)
+	ret0, _ := ret[0].(*git.GitPullRequestCommentThread)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateThread indicates an expected call of UpdateThread
+func (mr *MockGitClientMockRecorder) UpdateThread(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateThread", reflect.TypeOf((*MockGitClient)(nil).UpdateThread), arg0, arg1)
+}
diff --git a/azdosdkmocks/identity_sdk_mock.go b/azdosdkmocks/identity_sdk_mock.go
new file mode 100644
index 00000000..ed8cf624
--- /dev/null
+++ b/azdosdkmocks/identity_sdk_mock.go
@@ -0,0 +1,498 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/microsoft/azure-devops-go-api/azuredevops/identity (interfaces: Client)
+
+// Package azdosdkmocks is a generated GoMock package.
+package azdosdkmocks
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	uuid "github.com/google/uuid"
+	delegatedauthorization "github.com/microsoft/azure-devops-go-api/azuredevops/delegatedauthorization"
+	identity "github.com/microsoft/azure-devops-go-api/azuredevops/identity"
+	reflect "reflect"
+)
+
+// MockIdentityClient is a mock of Client interface
+type MockIdentityClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockIdentityClientMockRecorder
+}
+
+// MockIdentityClientMockRecorder is the mock recorder for MockIdentityClient
+type MockIdentityClientMockRecorder struct {
+	mock *MockIdentityClient
+}
+
+// NewMockIdentityClient creates a new mock instance
+func NewMockIdentityClient(ctrl *gomock.Controller) *MockIdentityClient {
+	mock := &MockIdentityClient{ctrl: ctrl}
+	mock.recorder = &MockIdentityClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockIdentityClient) EXPECT() *MockIdentityClientMockRecorder {
+	return m.recorder
+}
+
+// AddMember mocks base method
+func (m *MockIdentityClient) AddMember(arg0 context.Context, arg1 identity.AddMemberArgs) (*bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddMember", arg0, arg1)
+	ret0, _ := ret[0].(*bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddMember indicates an expected call of AddMember
+func (mr *MockIdentityClientMockRecorder) AddMember(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMember", reflect.TypeOf((*MockIdentityClient)(nil).AddMember), arg0, arg1)
+}
+
+// CreateGroups mocks base method
+func (m *MockIdentityClient) CreateGroups(arg0 context.Context, arg1 identity.CreateGroupsArgs) (*[]identity.Identity, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateGroups", arg0, arg1)
+	ret0, _ := ret[0].(*[]identity.Identity)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateGroups indicates an expected call of CreateGroups
+func (mr *MockIdentityClientMockRecorder) CreateGroups(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroups", reflect.TypeOf((*MockIdentityClient)(nil).CreateGroups), arg0, arg1)
+}
+
+// CreateIdentity mocks base method
+func (m *MockIdentityClient) CreateIdentity(arg0 context.Context, arg1 identity.CreateIdentityArgs) (*identity.Identity, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateIdentity", arg0, arg1)
+	ret0, _ := ret[0].(*identity.Identity)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateIdentity indicates an expected call of CreateIdentity
+func (mr *MockIdentityClientMockRecorder) CreateIdentity(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIdentity", reflect.TypeOf((*MockIdentityClient)(nil).CreateIdentity), arg0, arg1)
+}
+
+// CreateOrBindWithClaims mocks base method
+func (m *MockIdentityClient) CreateOrBindWithClaims(arg0 context.Context, arg1 identity.CreateOrBindWithClaimsArgs) (*identity.Identity, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrBindWithClaims", arg0, arg1)
+	ret0, _ := ret[0].(*identity.Identity)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateOrBindWithClaims indicates an expected call of CreateOrBindWithClaims
+func (mr *MockIdentityClientMockRecorder) CreateOrBindWithClaims(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrBindWithClaims", reflect.TypeOf((*MockIdentityClient)(nil).CreateOrBindWithClaims), arg0, arg1)
+}
+
+// CreateScope mocks base method
+func (m *MockIdentityClient) CreateScope(arg0 context.Context, arg1 identity.CreateScopeArgs) (*identity.IdentityScope, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateScope", arg0, arg1)
+	ret0, _ := ret[0].(*identity.IdentityScope)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateScope indicates an expected call of CreateScope
+func (mr *MockIdentityClientMockRecorder) CreateScope(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateScope", reflect.TypeOf((*MockIdentityClient)(nil).CreateScope), arg0, arg1)
+}
+
+// DeleteGroup mocks base method
+func (m *MockIdentityClient) DeleteGroup(arg0 context.Context, arg1 identity.DeleteGroupArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteGroup", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteGroup indicates an expected call of DeleteGroup
+func (mr *MockIdentityClientMockRecorder) DeleteGroup(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroup", reflect.TypeOf((*MockIdentityClient)(nil).DeleteGroup), arg0, arg1)
+}
+
+// DeleteScope mocks base method
+func (m *MockIdentityClient) DeleteScope(arg0 context.Context, arg1 identity.DeleteScopeArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteScope", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteScope indicates an expected call of DeleteScope
+func (mr *MockIdentityClientMockRecorder) DeleteScope(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScope", reflect.TypeOf((*MockIdentityClient)(nil).DeleteScope), arg0, arg1)
+}
+
+// GetDescriptorById mocks base method
+func (m *MockIdentityClient) GetDescriptorById(arg0 context.Context, arg1 identity.GetDescriptorByIdArgs) (*string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDescriptorById", arg0, arg1)
+	ret0, _ := ret[0].(*string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDescriptorById indicates an expected call of GetDescriptorById
+func (mr *MockIdentityClientMockRecorder) GetDescriptorById(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDescriptorById", reflect.TypeOf((*MockIdentityClient)(nil).GetDescriptorById), arg0, arg1)
+}
+
+// GetIdentityChanges mocks base method
+func (m *MockIdentityClient) GetIdentityChanges(arg0 context.Context, arg1 identity.GetIdentityChangesArgs) (*identity.ChangedIdentities, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetIdentityChanges", arg0, arg1)
+	ret0, _ := ret[0].(*identity.ChangedIdentities)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetIdentityChanges indicates an expected call of GetIdentityChanges
+func (mr *MockIdentityClientMockRecorder) GetIdentityChanges(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIdentityChanges", reflect.TypeOf((*MockIdentityClient)(nil).GetIdentityChanges), arg0, arg1)
+}
+
+// GetIdentitySnapshot mocks base method
+func (m *MockIdentityClient) GetIdentitySnapshot(arg0 context.Context, arg1 identity.GetIdentitySnapshotArgs) (*identity.IdentitySnapshot, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetIdentitySnapshot", arg0, arg1)
+	ret0, _ := ret[0].(*identity.IdentitySnapshot)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetIdentitySnapshot indicates an expected call of GetIdentitySnapshot
+func (mr *MockIdentityClientMockRecorder) GetIdentitySnapshot(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIdentitySnapshot", reflect.TypeOf((*MockIdentityClient)(nil).GetIdentitySnapshot), arg0, arg1)
+}
+
+// GetMaxSequenceId mocks base method
+func (m *MockIdentityClient) GetMaxSequenceId(arg0 context.Context, arg1 identity.GetMaxSequenceIdArgs) (*uint64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMaxSequenceId", arg0, arg1)
+	ret0, _ := ret[0].(*uint64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetMaxSequenceId indicates an expected call of GetMaxSequenceId
+func (mr *MockIdentityClientMockRecorder) GetMaxSequenceId(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxSequenceId", reflect.TypeOf((*MockIdentityClient)(nil).GetMaxSequenceId), arg0, arg1)
+}
+
+// GetScopeById mocks base method
+func (m *MockIdentityClient) GetScopeById(arg0 context.Context, arg1 identity.GetScopeByIdArgs) (*identity.IdentityScope, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetScopeById", arg0, arg1)
+	ret0, _ := ret[0].(*identity.IdentityScope)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetScopeById indicates an expected call of GetScopeById
+func (mr *MockIdentityClientMockRecorder) GetScopeById(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScopeById", reflect.TypeOf((*MockIdentityClient)(nil).GetScopeById), arg0, arg1)
+}
+
+// GetScopeByName mocks base method
+func (m *MockIdentityClient) GetScopeByName(arg0 context.Context, arg1 identity.GetScopeByNameArgs) (*identity.IdentityScope, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetScopeByName", arg0, arg1)
+	ret0, _ := ret[0].(*identity.IdentityScope)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetScopeByName indicates an expected call of GetScopeByName
+func (mr *MockIdentityClientMockRecorder) GetScopeByName(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScopeByName", reflect.TypeOf((*MockIdentityClient)(nil).GetScopeByName), arg0, arg1)
+}
+
+// GetSelf mocks base method
+func (m *MockIdentityClient) GetSelf(arg0 context.Context, arg1 identity.GetSelfArgs) (*identity.IdentitySelf, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSelf", arg0, arg1)
+	ret0, _ := ret[0].(*identity.IdentitySelf)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSelf indicates an expected call of GetSelf
+func (mr *MockIdentityClientMockRecorder) GetSelf(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSelf", reflect.TypeOf((*MockIdentityClient)(nil).GetSelf), arg0, arg1)
+}
+
+// GetSignedInToken mocks base method
+func (m *MockIdentityClient) GetSignedInToken(arg0 context.Context, arg1 identity.GetSignedInTokenArgs) (*delegatedauthorization.AccessTokenResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSignedInToken", arg0, arg1)
+	ret0, _ := ret[0].(*delegatedauthorization.AccessTokenResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSignedInToken indicates an expected call of GetSignedInToken
+func (mr *MockIdentityClientMockRecorder) GetSignedInToken(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignedInToken", reflect.TypeOf((*MockIdentityClient)(nil).GetSignedInToken), arg0, arg1)
+}
+
+// GetSignoutToken mocks base method
+func (m *MockIdentityClient) GetSignoutToken(arg0 context.Context, arg1 identity.GetSignoutTokenArgs) (*delegatedauthorization.AccessTokenResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSignoutToken", arg0, arg1)
+	ret0, _ := ret[0].(*delegatedauthorization.AccessTokenResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSignoutToken indicates an expected call of GetSignoutToken
+func (mr *MockIdentityClientMockRecorder) GetSignoutToken(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignoutToken", reflect.TypeOf((*MockIdentityClient)(nil).GetSignoutToken), arg0, arg1)
+}
+
+// GetTenant mocks base method
+func (m *MockIdentityClient) GetTenant(arg0 context.Context, arg1 identity.GetTenantArgs) (*identity.TenantInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTenant", arg0, arg1)
+	ret0, _ := ret[0].(*identity.TenantInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTenant indicates an expected call of GetTenant
+func (mr *MockIdentityClientMockRecorder) GetTenant(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTenant", reflect.TypeOf((*MockIdentityClient)(nil).GetTenant), arg0, arg1)
+}
+
+// GetUserIdentityIdsByDomainId mocks base method
+func (m *MockIdentityClient) GetUserIdentityIdsByDomainId(arg0 context.Context, arg1 identity.GetUserIdentityIdsByDomainIdArgs) (*[]uuid.UUID, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUserIdentityIdsByDomainId", arg0, arg1)
+	ret0, _ := ret[0].(*[]uuid.UUID)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUserIdentityIdsByDomainId indicates an expected call of GetUserIdentityIdsByDomainId
+func (mr *MockIdentityClientMockRecorder) GetUserIdentityIdsByDomainId(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserIdentityIdsByDomainId", reflect.TypeOf((*MockIdentityClient)(nil).GetUserIdentityIdsByDomainId), arg0, arg1)
+}
+
+// ListGroups mocks base method
+func (m *MockIdentityClient) ListGroups(arg0 context.Context, arg1 identity.ListGroupsArgs) (*[]identity.Identity, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListGroups", arg0, arg1)
+	ret0, _ := ret[0].(*[]identity.Identity)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListGroups indicates an expected call of ListGroups
+func (mr *MockIdentityClientMockRecorder) ListGroups(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroups", reflect.TypeOf((*MockIdentityClient)(nil).ListGroups), arg0, arg1)
+}
+
+// ReadIdentities mocks base method
+func (m *MockIdentityClient) ReadIdentities(arg0 context.Context, arg1 identity.ReadIdentitiesArgs) (*[]identity.Identity, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReadIdentities", arg0, arg1)
+	ret0, _ := ret[0].(*[]identity.Identity)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ReadIdentities indicates an expected call of ReadIdentities
+func (mr *MockIdentityClientMockRecorder) ReadIdentities(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadIdentities", reflect.TypeOf((*MockIdentityClient)(nil).ReadIdentities), arg0, arg1)
+}
+
+// ReadIdentitiesByScope mocks base method
+func (m *MockIdentityClient) ReadIdentitiesByScope(arg0 context.Context, arg1 identity.ReadIdentitiesByScopeArgs) (*[]identity.Identity, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReadIdentitiesByScope", arg0, arg1)
+	ret0, _ := ret[0].(*[]identity.Identity)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ReadIdentitiesByScope indicates an expected call of ReadIdentitiesByScope
+func (mr *MockIdentityClientMockRecorder) ReadIdentitiesByScope(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadIdentitiesByScope", reflect.TypeOf((*MockIdentityClient)(nil).ReadIdentitiesByScope), arg0, arg1)
+}
+
+// ReadIdentity mocks base method
+func (m *MockIdentityClient) ReadIdentity(arg0 context.Context, arg1 identity.ReadIdentityArgs) (*identity.Identity, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReadIdentity", arg0, arg1)
+	ret0, _ := ret[0].(*identity.Identity)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ReadIdentity indicates an expected call of ReadIdentity
+func (mr *MockIdentityClientMockRecorder) ReadIdentity(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadIdentity", reflect.TypeOf((*MockIdentityClient)(nil).ReadIdentity), arg0, arg1)
+}
+
+// ReadIdentityBatch mocks base method
+func (m *MockIdentityClient) ReadIdentityBatch(arg0 context.Context, arg1 identity.ReadIdentityBatchArgs) (*[]identity.Identity, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReadIdentityBatch", arg0, arg1)
+	ret0, _ := ret[0].(*[]identity.Identity)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ReadIdentityBatch indicates an expected call of ReadIdentityBatch
+func (mr *MockIdentityClientMockRecorder) ReadIdentityBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadIdentityBatch", reflect.TypeOf((*MockIdentityClient)(nil).ReadIdentityBatch), arg0, arg1)
+}
+
+// ReadMember mocks base method
+func (m *MockIdentityClient) ReadMember(arg0 context.Context, arg1 identity.ReadMemberArgs) (*string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReadMember", arg0, arg1)
+	ret0, _ := ret[0].(*string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ReadMember indicates an expected call of ReadMember
+func (mr *MockIdentityClientMockRecorder) ReadMember(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMember", reflect.TypeOf((*MockIdentityClient)(nil).ReadMember), arg0, arg1)
+}
+
+// ReadMemberOf mocks base method
+func (m *MockIdentityClient) ReadMemberOf(arg0 context.Context, arg1 identity.ReadMemberOfArgs) (*string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReadMemberOf", arg0, arg1)
+	ret0, _ := ret[0].(*string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ReadMemberOf indicates an expected call of ReadMemberOf
+func (mr *MockIdentityClientMockRecorder) ReadMemberOf(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMemberOf", reflect.TypeOf((*MockIdentityClient)(nil).ReadMemberOf), arg0, arg1)
+}
+
+// ReadMembers mocks base method
+func (m *MockIdentityClient) ReadMembers(arg0 context.Context, arg1 identity.ReadMembersArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReadMembers", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ReadMembers indicates an expected call of ReadMembers
+func (mr *MockIdentityClientMockRecorder) ReadMembers(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMembers", reflect.TypeOf((*MockIdentityClient)(nil).ReadMembers), arg0, arg1)
+}
+
+// ReadMembersOf mocks base method
+func (m *MockIdentityClient) ReadMembersOf(arg0 context.Context, arg1 identity.ReadMembersOfArgs) (*[]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ReadMembersOf", arg0, arg1)
+	ret0, _ := ret[0].(*[]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ReadMembersOf indicates an expected call of ReadMembersOf
+func (mr *MockIdentityClientMockRecorder) ReadMembersOf(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMembersOf", reflect.TypeOf((*MockIdentityClient)(nil).ReadMembersOf), arg0, arg1)
+}
+
+// RemoveMember mocks base method
+func (m *MockIdentityClient) RemoveMember(arg0 context.Context, arg1 identity.RemoveMemberArgs) (*bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RemoveMember", arg0, arg1)
+	ret0, _ := ret[0].(*bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RemoveMember indicates an expected call of RemoveMember
+func (mr *MockIdentityClientMockRecorder) RemoveMember(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMember", reflect.TypeOf((*MockIdentityClient)(nil).RemoveMember), arg0, arg1)
+}
+
+// UpdateIdentities mocks base method
+func (m *MockIdentityClient) UpdateIdentities(arg0 context.Context, arg1 identity.UpdateIdentitiesArgs) (*[]identity.IdentityUpdateData, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateIdentities", arg0, arg1)
+	ret0, _ := ret[0].(*[]identity.IdentityUpdateData)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateIdentities indicates an expected call of UpdateIdentities
+func (mr *MockIdentityClientMockRecorder) UpdateIdentities(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIdentities", reflect.TypeOf((*MockIdentityClient)(nil).UpdateIdentities), arg0, arg1)
+}
+
+// UpdateIdentity mocks base method
+func (m *MockIdentityClient) UpdateIdentity(arg0 context.Context, arg1 identity.UpdateIdentityArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateIdentity", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateIdentity indicates an expected call of UpdateIdentity
+func (mr *MockIdentityClientMockRecorder) UpdateIdentity(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIdentity", reflect.TypeOf((*MockIdentityClient)(nil).UpdateIdentity), arg0, arg1)
+}
+
+// UpdateScope mocks base method
+func (m *MockIdentityClient) UpdateScope(arg0 context.Context, arg1 identity.UpdateScopeArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateScope", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateScope indicates an expected call of UpdateScope
+func (mr *MockIdentityClientMockRecorder) UpdateScope(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScope", reflect.TypeOf((*MockIdentityClient)(nil).UpdateScope), arg0, arg1)
+}
diff --git a/azdosdkmocks/operations_sdk_mock.go b/azdosdkmocks/operations_sdk_mock.go
new file mode 100644
index 00000000..523e83d9
--- /dev/null
+++ b/azdosdkmocks/operations_sdk_mock.go
@@ -0,0 +1,50 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/microsoft/azure-devops-go-api/azuredevops/operations (interfaces: Client)
+
+// Package azdosdkmocks is a generated GoMock package.
+package azdosdkmocks
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	operations "github.com/microsoft/azure-devops-go-api/azuredevops/operations"
+	reflect "reflect"
+)
+
+// MockOperationsClient is a mock of Client interface
+type MockOperationsClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockOperationsClientMockRecorder
+}
+
+// MockOperationsClientMockRecorder is the mock recorder for MockOperationsClient
+type MockOperationsClientMockRecorder struct {
+	mock *MockOperationsClient
+}
+
+// NewMockOperationsClient creates a new mock instance
+func NewMockOperationsClient(ctrl *gomock.Controller) *MockOperationsClient {
+	mock := &MockOperationsClient{ctrl: ctrl}
+	mock.recorder = &MockOperationsClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockOperationsClient) EXPECT() *MockOperationsClientMockRecorder {
+	return m.recorder
+}
+
+// GetOperation mocks base method
+func (m *MockOperationsClient) GetOperation(arg0 context.Context, arg1 operations.GetOperationArgs) (*operations.Operation, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetOperation", arg0, arg1)
+	ret0, _ := ret[0].(*operations.Operation)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOperation indicates an expected call of GetOperation
+func (mr *MockOperationsClientMockRecorder) GetOperation(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperation", reflect.TypeOf((*MockOperationsClient)(nil).GetOperation), arg0, arg1)
+}
diff --git a/azdosdkmocks/policy_sdk_mock.go b/azdosdkmocks/policy_sdk_mock.go
new file mode 100644
index 00000000..75b34ab5
--- /dev/null
+++ b/azdosdkmocks/policy_sdk_mock.go
@@ -0,0 +1,214 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/microsoft/azure-devops-go-api/azuredevops/policy (interfaces: Client)
+
+// Package azdosdkmocks is a generated GoMock package.
+package azdosdkmocks
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	policy "github.com/microsoft/azure-devops-go-api/azuredevops/policy"
+	reflect "reflect"
+)
+
+// MockPolicyClient is a mock of Client interface
+type MockPolicyClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockPolicyClientMockRecorder
+}
+
+// MockPolicyClientMockRecorder is the mock recorder for MockPolicyClient
+type MockPolicyClientMockRecorder struct {
+	mock *MockPolicyClient
+}
+
+// NewMockPolicyClient creates a new mock instance
+func NewMockPolicyClient(ctrl *gomock.Controller) *MockPolicyClient {
+	mock := &MockPolicyClient{ctrl: ctrl}
+	mock.recorder = &MockPolicyClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockPolicyClient) EXPECT() *MockPolicyClientMockRecorder {
+	return m.recorder
+}
+
+// CreatePolicyConfiguration mocks base method
+func (m *MockPolicyClient) CreatePolicyConfiguration(arg0 context.Context, arg1 policy.CreatePolicyConfigurationArgs) (*policy.PolicyConfiguration, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatePolicyConfiguration", arg0, arg1)
+	ret0, _ := ret[0].(*policy.PolicyConfiguration)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreatePolicyConfiguration indicates an expected call of CreatePolicyConfiguration
+func (mr *MockPolicyClientMockRecorder) CreatePolicyConfiguration(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePolicyConfiguration", reflect.TypeOf((*MockPolicyClient)(nil).CreatePolicyConfiguration), arg0, arg1)
+}
+
+// DeletePolicyConfiguration mocks base method
+func (m *MockPolicyClient) DeletePolicyConfiguration(arg0 context.Context, arg1 policy.DeletePolicyConfigurationArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeletePolicyConfiguration", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeletePolicyConfiguration indicates an expected call of DeletePolicyConfiguration
+func (mr *MockPolicyClientMockRecorder) DeletePolicyConfiguration(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyConfiguration", reflect.TypeOf((*MockPolicyClient)(nil).DeletePolicyConfiguration), arg0, arg1)
+}
+
+// GetPolicyConfiguration mocks base method
+func (m *MockPolicyClient) GetPolicyConfiguration(arg0 context.Context, arg1 policy.GetPolicyConfigurationArgs) (*policy.PolicyConfiguration, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPolicyConfiguration", arg0, arg1)
+	ret0, _ := ret[0].(*policy.PolicyConfiguration)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPolicyConfiguration indicates an expected call of GetPolicyConfiguration
+func (mr *MockPolicyClientMockRecorder) GetPolicyConfiguration(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyConfiguration", reflect.TypeOf((*MockPolicyClient)(nil).GetPolicyConfiguration), arg0, arg1)
+}
+
+// GetPolicyConfigurationRevision mocks base method
+func (m *MockPolicyClient) GetPolicyConfigurationRevision(arg0 context.Context, arg1 policy.GetPolicyConfigurationRevisionArgs) (*policy.PolicyConfiguration, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPolicyConfigurationRevision", arg0, arg1)
+	ret0, _ := ret[0].(*policy.PolicyConfiguration)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPolicyConfigurationRevision indicates an expected call of GetPolicyConfigurationRevision
+func (mr *MockPolicyClientMockRecorder) GetPolicyConfigurationRevision(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyConfigurationRevision", reflect.TypeOf((*MockPolicyClient)(nil).GetPolicyConfigurationRevision), arg0, arg1)
+}
+
+// GetPolicyConfigurationRevisions mocks base method
+func (m *MockPolicyClient) GetPolicyConfigurationRevisions(arg0 context.Context, arg1 policy.GetPolicyConfigurationRevisionsArgs) (*[]policy.PolicyConfiguration, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPolicyConfigurationRevisions", arg0, arg1)
+	ret0, _ := ret[0].(*[]policy.PolicyConfiguration)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPolicyConfigurationRevisions indicates an expected call of GetPolicyConfigurationRevisions
+func (mr *MockPolicyClientMockRecorder) GetPolicyConfigurationRevisions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyConfigurationRevisions", reflect.TypeOf((*MockPolicyClient)(nil).GetPolicyConfigurationRevisions), arg0, arg1)
+}
+
+// GetPolicyConfigurations mocks base method
+func (m *MockPolicyClient) GetPolicyConfigurations(arg0 context.Context, arg1 policy.GetPolicyConfigurationsArgs) (*policy.GetPolicyConfigurationsResponseValue, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPolicyConfigurations", arg0, arg1)
+	ret0, _ := ret[0].(*policy.GetPolicyConfigurationsResponseValue)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPolicyConfigurations indicates an expected call of GetPolicyConfigurations
+func (mr *MockPolicyClientMockRecorder) GetPolicyConfigurations(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyConfigurations", reflect.TypeOf((*MockPolicyClient)(nil).GetPolicyConfigurations), arg0, arg1)
+}
+
+// GetPolicyEvaluation mocks base method
+func (m *MockPolicyClient) GetPolicyEvaluation(arg0 context.Context, arg1 policy.GetPolicyEvaluationArgs) (*policy.PolicyEvaluationRecord, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPolicyEvaluation", arg0, arg1)
+	ret0, _ := ret[0].(*policy.PolicyEvaluationRecord)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPolicyEvaluation indicates an expected call of GetPolicyEvaluation
+func (mr *MockPolicyClientMockRecorder) GetPolicyEvaluation(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyEvaluation", reflect.TypeOf((*MockPolicyClient)(nil).GetPolicyEvaluation), arg0, arg1)
+}
+
+// GetPolicyEvaluations mocks base method
+func (m *MockPolicyClient) GetPolicyEvaluations(arg0 context.Context, arg1 policy.GetPolicyEvaluationsArgs) (*[]policy.PolicyEvaluationRecord, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPolicyEvaluations", arg0, arg1)
+	ret0, _ := ret[0].(*[]policy.PolicyEvaluationRecord)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPolicyEvaluations indicates an expected call of GetPolicyEvaluations
+func (mr *MockPolicyClientMockRecorder) GetPolicyEvaluations(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyEvaluations", reflect.TypeOf((*MockPolicyClient)(nil).GetPolicyEvaluations), arg0, arg1)
+}
+
+// GetPolicyType mocks base method
+func (m *MockPolicyClient) GetPolicyType(arg0 context.Context, arg1 policy.GetPolicyTypeArgs) (*policy.PolicyType, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPolicyType", arg0, arg1)
+	ret0, _ := ret[0].(*policy.PolicyType)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPolicyType indicates an expected call of GetPolicyType
+func (mr *MockPolicyClientMockRecorder) GetPolicyType(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyType", reflect.TypeOf((*MockPolicyClient)(nil).GetPolicyType), arg0, arg1)
+}
+
+// GetPolicyTypes mocks base method
+func (m *MockPolicyClient) GetPolicyTypes(arg0 context.Context, arg1 policy.GetPolicyTypesArgs) (*[]policy.PolicyType, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPolicyTypes", arg0, arg1)
+	ret0, _ := ret[0].(*[]policy.PolicyType)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPolicyTypes indicates an expected call of GetPolicyTypes
+func (mr *MockPolicyClientMockRecorder) GetPolicyTypes(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyTypes", reflect.TypeOf((*MockPolicyClient)(nil).GetPolicyTypes), arg0, arg1)
+}
+
+// RequeuePolicyEvaluation mocks base method
+func (m *MockPolicyClient) RequeuePolicyEvaluation(arg0 context.Context, arg1 policy.RequeuePolicyEvaluationArgs) (*policy.PolicyEvaluationRecord, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RequeuePolicyEvaluation", arg0, arg1)
+	ret0, _ := ret[0].(*policy.PolicyEvaluationRecord)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RequeuePolicyEvaluation indicates an expected call of RequeuePolicyEvaluation
+func (mr *MockPolicyClientMockRecorder) RequeuePolicyEvaluation(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequeuePolicyEvaluation", reflect.TypeOf((*MockPolicyClient)(nil).RequeuePolicyEvaluation), arg0, arg1)
+}
+
+// UpdatePolicyConfiguration mocks base method
+func (m *MockPolicyClient) UpdatePolicyConfiguration(arg0 context.Context, arg1 policy.UpdatePolicyConfigurationArgs) (*policy.PolicyConfiguration, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdatePolicyConfiguration", arg0, arg1)
+	ret0, _ := ret[0].(*policy.PolicyConfiguration)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdatePolicyConfiguration indicates an expected call of UpdatePolicyConfiguration
+func (mr *MockPolicyClientMockRecorder) UpdatePolicyConfiguration(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePolicyConfiguration", reflect.TypeOf((*MockPolicyClient)(nil).UpdatePolicyConfiguration), arg0, arg1)
+}
diff --git a/azdosdkmocks/serviceendpoint_sdk_mock.go b/azdosdkmocks/serviceendpoint_sdk_mock.go
new file mode 100644
index 00000000..054b5b17
--- /dev/null
+++ b/azdosdkmocks/serviceendpoint_sdk_mock.go
@@ -0,0 +1,184 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/microsoft/azure-devops-go-api/azuredevops/serviceendpoint (interfaces: Client)
+
+// Package azdosdkmocks is a generated GoMock package.
+package azdosdkmocks
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	serviceendpoint "github.com/microsoft/azure-devops-go-api/azuredevops/serviceendpoint"
+	reflect "reflect"
+)
+
+// MockServiceendpointClient is a mock of Client interface
+type MockServiceendpointClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockServiceendpointClientMockRecorder
+}
+
+// MockServiceendpointClientMockRecorder is the mock recorder for MockServiceendpointClient
+type MockServiceendpointClientMockRecorder struct {
+	mock *MockServiceendpointClient
+}
+
+// NewMockServiceendpointClient creates a new mock instance
+func NewMockServiceendpointClient(ctrl *gomock.Controller) *MockServiceendpointClient {
+	mock := &MockServiceendpointClient{ctrl: ctrl}
+	mock.recorder = &MockServiceendpointClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockServiceendpointClient) EXPECT() *MockServiceendpointClientMockRecorder {
+	return m.recorder
+}
+
+// CreateServiceEndpoint mocks base method
+func (m *MockServiceendpointClient) CreateServiceEndpoint(arg0 context.Context, arg1 serviceendpoint.CreateServiceEndpointArgs) (*serviceendpoint.ServiceEndpoint, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateServiceEndpoint", arg0, arg1)
+	ret0, _ := ret[0].(*serviceendpoint.ServiceEndpoint)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateServiceEndpoint indicates an expected call of CreateServiceEndpoint
+func (mr *MockServiceendpointClientMockRecorder) CreateServiceEndpoint(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceEndpoint", reflect.TypeOf((*MockServiceendpointClient)(nil).CreateServiceEndpoint), arg0, arg1)
+}
+
+// DeleteServiceEndpoint mocks base method
+func (m *MockServiceendpointClient) DeleteServiceEndpoint(arg0 context.Context, arg1 serviceendpoint.DeleteServiceEndpointArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteServiceEndpoint", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteServiceEndpoint indicates an expected call of DeleteServiceEndpoint
+func (mr *MockServiceendpointClientMockRecorder) DeleteServiceEndpoint(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceEndpoint", reflect.TypeOf((*MockServiceendpointClient)(nil).DeleteServiceEndpoint), arg0, arg1)
+}
+
+// ExecuteServiceEndpointRequest mocks base method
+func (m *MockServiceendpointClient) ExecuteServiceEndpointRequest(arg0 context.Context, arg1 serviceendpoint.ExecuteServiceEndpointRequestArgs) (*serviceendpoint.ServiceEndpointRequestResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteServiceEndpointRequest", arg0, arg1)
+	ret0, _ := ret[0].(*serviceendpoint.ServiceEndpointRequestResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteServiceEndpointRequest indicates an expected call of ExecuteServiceEndpointRequest
+func (mr *MockServiceendpointClientMockRecorder) ExecuteServiceEndpointRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteServiceEndpointRequest", reflect.TypeOf((*MockServiceendpointClient)(nil).ExecuteServiceEndpointRequest), arg0, arg1)
+}
+
+// GetServiceEndpointDetails mocks base method
+func (m *MockServiceendpointClient) GetServiceEndpointDetails(arg0 context.Context, arg1 serviceendpoint.GetServiceEndpointDetailsArgs) (*serviceendpoint.ServiceEndpoint, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetServiceEndpointDetails", arg0, arg1)
+	ret0, _ := ret[0].(*serviceendpoint.ServiceEndpoint)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetServiceEndpointDetails indicates an expected call of GetServiceEndpointDetails
+func (mr *MockServiceendpointClientMockRecorder) GetServiceEndpointDetails(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpointDetails", reflect.TypeOf((*MockServiceendpointClient)(nil).GetServiceEndpointDetails), arg0, arg1)
+}
+
+// GetServiceEndpointExecutionRecords mocks base method
+func (m *MockServiceendpointClient) GetServiceEndpointExecutionRecords(arg0 context.Context, arg1 serviceendpoint.GetServiceEndpointExecutionRecordsArgs) (*serviceendpoint.GetServiceEndpointExecutionRecordsResponseValue, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetServiceEndpointExecutionRecords", arg0, arg1)
+	ret0, _ := ret[0].(*serviceendpoint.GetServiceEndpointExecutionRecordsResponseValue)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetServiceEndpointExecutionRecords indicates an expected call of GetServiceEndpointExecutionRecords
+func (mr *MockServiceendpointClientMockRecorder) GetServiceEndpointExecutionRecords(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpointExecutionRecords", reflect.TypeOf((*MockServiceendpointClient)(nil).GetServiceEndpointExecutionRecords), arg0, arg1)
+}
+
+// GetServiceEndpointTypes mocks base method
+func (m *MockServiceendpointClient) GetServiceEndpointTypes(arg0 context.Context, arg1 serviceendpoint.GetServiceEndpointTypesArgs) (*[]serviceendpoint.ServiceEndpointType, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetServiceEndpointTypes", arg0, arg1)
+	ret0, _ := ret[0].(*[]serviceendpoint.ServiceEndpointType)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetServiceEndpointTypes indicates an expected call of GetServiceEndpointTypes
+func (mr *MockServiceendpointClientMockRecorder) GetServiceEndpointTypes(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpointTypes", reflect.TypeOf((*MockServiceendpointClient)(nil).GetServiceEndpointTypes), arg0, arg1)
+}
+
+// GetServiceEndpoints mocks base method
+func (m *MockServiceendpointClient) GetServiceEndpoints(arg0 context.Context, arg1 serviceendpoint.GetServiceEndpointsArgs) (*[]serviceendpoint.ServiceEndpoint, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetServiceEndpoints", arg0, arg1)
+	ret0, _ := ret[0].(*[]serviceendpoint.ServiceEndpoint)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetServiceEndpoints indicates an expected call of GetServiceEndpoints
+func (mr *MockServiceendpointClientMockRecorder) GetServiceEndpoints(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpoints", reflect.TypeOf((*MockServiceendpointClient)(nil).GetServiceEndpoints), arg0, arg1)
+}
+
+// GetServiceEndpointsByNames mocks base method
+func (m *MockServiceendpointClient) GetServiceEndpointsByNames(arg0 context.Context, arg1 serviceendpoint.GetServiceEndpointsByNamesArgs) (*[]serviceendpoint.ServiceEndpoint, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetServiceEndpointsByNames", arg0, arg1)
+	ret0, _ := ret[0].(*[]serviceendpoint.ServiceEndpoint)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetServiceEndpointsByNames indicates an expected call of GetServiceEndpointsByNames
+func (mr *MockServiceendpointClientMockRecorder) GetServiceEndpointsByNames(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpointsByNames", reflect.TypeOf((*MockServiceendpointClient)(nil).GetServiceEndpointsByNames), arg0, arg1)
+}
+
+// UpdateServiceEndpoint mocks base method
+func (m *MockServiceendpointClient) UpdateServiceEndpoint(arg0 context.Context, arg1 serviceendpoint.UpdateServiceEndpointArgs) (*serviceendpoint.ServiceEndpoint, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateServiceEndpoint", arg0, arg1)
+	ret0, _ := ret[0].(*serviceendpoint.ServiceEndpoint)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateServiceEndpoint indicates an expected call of UpdateServiceEndpoint
+func (mr *MockServiceendpointClientMockRecorder) UpdateServiceEndpoint(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceEndpoint", reflect.TypeOf((*MockServiceendpointClient)(nil).UpdateServiceEndpoint), arg0, arg1)
+}
+
+// UpdateServiceEndpoints mocks base method
+func (m *MockServiceendpointClient) UpdateServiceEndpoints(arg0 context.Context, arg1 serviceendpoint.UpdateServiceEndpointsArgs) (*[]serviceendpoint.ServiceEndpoint, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateServiceEndpoints", arg0, arg1)
+	ret0, _ := ret[0].(*[]serviceendpoint.ServiceEndpoint)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateServiceEndpoints indicates an expected call of UpdateServiceEndpoints
+func (mr *MockServiceendpointClientMockRecorder) UpdateServiceEndpoints(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceEndpoints", reflect.TypeOf((*MockServiceendpointClient)(nil).UpdateServiceEndpoints), arg0, arg1)
+}
diff --git a/azdosdkmocks/test_sdk_mock.go b/azdosdkmocks/test_sdk_mock.go
new file mode 100644
index 00000000..94695628
--- /dev/null
+++ b/azdosdkmocks/test_sdk_mock.go
@@ -0,0 +1,708 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/microsoft/azure-devops-go-api/azuredevops/test (interfaces: Client)
+
+// Package azdosdkmocks is a generated GoMock package.
+package azdosdkmocks
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	test "github.com/microsoft/azure-devops-go-api/azuredevops/test"
+	io "io"
+	reflect "reflect"
+)
+
+// MockTestClient is a mock of Client interface
+type MockTestClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockTestClientMockRecorder
+}
+
+// MockTestClientMockRecorder is the mock recorder for MockTestClient
+type MockTestClientMockRecorder struct {
+	mock *MockTestClient
+}
+
+// NewMockTestClient creates a new mock instance
+func NewMockTestClient(ctrl *gomock.Controller) *MockTestClient {
+	mock := &MockTestClient{ctrl: ctrl}
+	mock.recorder = &MockTestClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockTestClient) EXPECT() *MockTestClientMockRecorder {
+	return m.recorder
+}
+
+// AddTestCasesToSuite mocks base method
+func (m *MockTestClient) AddTestCasesToSuite(arg0 context.Context, arg1 test.AddTestCasesToSuiteArgs) (*[]test.SuiteTestCase, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddTestCasesToSuite", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.SuiteTestCase)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddTestCasesToSuite indicates an expected call of AddTestCasesToSuite
+func (mr *MockTestClientMockRecorder) AddTestCasesToSuite(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTestCasesToSuite", reflect.TypeOf((*MockTestClient)(nil).AddTestCasesToSuite), arg0, arg1)
+}
+
+// AddTestResultsToTestRun mocks base method
+func (m *MockTestClient) AddTestResultsToTestRun(arg0 context.Context, arg1 test.AddTestResultsToTestRunArgs) (*[]test.TestCaseResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddTestResultsToTestRun", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestCaseResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddTestResultsToTestRun indicates an expected call of AddTestResultsToTestRun
+func (mr *MockTestClientMockRecorder) AddTestResultsToTestRun(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTestResultsToTestRun", reflect.TypeOf((*MockTestClient)(nil).AddTestResultsToTestRun), arg0, arg1)
+}
+
+// CreateTestResultAttachment mocks base method
+func (m *MockTestClient) CreateTestResultAttachment(arg0 context.Context, arg1 test.CreateTestResultAttachmentArgs) (*test.TestAttachmentReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateTestResultAttachment", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestAttachmentReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateTestResultAttachment indicates an expected call of CreateTestResultAttachment
+func (mr *MockTestClientMockRecorder) CreateTestResultAttachment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTestResultAttachment", reflect.TypeOf((*MockTestClient)(nil).CreateTestResultAttachment), arg0, arg1)
+}
+
+// CreateTestRun mocks base method
+func (m *MockTestClient) CreateTestRun(arg0 context.Context, arg1 test.CreateTestRunArgs) (*test.TestRun, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateTestRun", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestRun)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateTestRun indicates an expected call of CreateTestRun
+func (mr *MockTestClientMockRecorder) CreateTestRun(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTestRun", reflect.TypeOf((*MockTestClient)(nil).CreateTestRun), arg0, arg1)
+}
+
+// CreateTestRunAttachment mocks base method
+func (m *MockTestClient) CreateTestRunAttachment(arg0 context.Context, arg1 test.CreateTestRunAttachmentArgs) (*test.TestAttachmentReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateTestRunAttachment", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestAttachmentReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateTestRunAttachment indicates an expected call of CreateTestRunAttachment
+func (mr *MockTestClientMockRecorder) CreateTestRunAttachment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTestRunAttachment", reflect.TypeOf((*MockTestClient)(nil).CreateTestRunAttachment), arg0, arg1)
+}
+
+// CreateTestSession mocks base method
+func (m *MockTestClient) CreateTestSession(arg0 context.Context, arg1 test.CreateTestSessionArgs) (*test.TestSession, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateTestSession", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestSession)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateTestSession indicates an expected call of CreateTestSession
+func (mr *MockTestClientMockRecorder) CreateTestSession(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTestSession", reflect.TypeOf((*MockTestClient)(nil).CreateTestSession), arg0, arg1)
+}
+
+// CreateTestSubResultAttachment mocks base method
+func (m *MockTestClient) CreateTestSubResultAttachment(arg0 context.Context, arg1 test.CreateTestSubResultAttachmentArgs) (*test.TestAttachmentReference, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateTestSubResultAttachment", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestAttachmentReference)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateTestSubResultAttachment indicates an expected call of CreateTestSubResultAttachment
+func (mr *MockTestClientMockRecorder) CreateTestSubResultAttachment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTestSubResultAttachment", reflect.TypeOf((*MockTestClient)(nil).CreateTestSubResultAttachment), arg0, arg1)
+}
+
+// DeleteTestCase mocks base method
+func (m *MockTestClient) DeleteTestCase(arg0 context.Context, arg1 test.DeleteTestCaseArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteTestCase", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteTestCase indicates an expected call of DeleteTestCase
+func (mr *MockTestClientMockRecorder) DeleteTestCase(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTestCase", reflect.TypeOf((*MockTestClient)(nil).DeleteTestCase), arg0, arg1)
+}
+
+// DeleteTestRun mocks base method
+func (m *MockTestClient) DeleteTestRun(arg0 context.Context, arg1 test.DeleteTestRunArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteTestRun", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteTestRun indicates an expected call of DeleteTestRun
+func (mr *MockTestClientMockRecorder) DeleteTestRun(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTestRun", reflect.TypeOf((*MockTestClient)(nil).DeleteTestRun), arg0, arg1)
+}
+
+// GetActionResults mocks base method
+func (m *MockTestClient) GetActionResults(arg0 context.Context, arg1 test.GetActionResultsArgs) (*[]test.TestActionResultModel, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetActionResults", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestActionResultModel)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetActionResults indicates an expected call of GetActionResults
+func (mr *MockTestClientMockRecorder) GetActionResults(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActionResults", reflect.TypeOf((*MockTestClient)(nil).GetActionResults), arg0, arg1)
+}
+
+// GetBuildCodeCoverage mocks base method
+func (m *MockTestClient) GetBuildCodeCoverage(arg0 context.Context, arg1 test.GetBuildCodeCoverageArgs) (*[]test.BuildCoverage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetBuildCodeCoverage", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.BuildCoverage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetBuildCodeCoverage indicates an expected call of GetBuildCodeCoverage
+func (mr *MockTestClientMockRecorder) GetBuildCodeCoverage(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildCodeCoverage", reflect.TypeOf((*MockTestClient)(nil).GetBuildCodeCoverage), arg0, arg1)
+}
+
+// GetPoint mocks base method
+func (m *MockTestClient) GetPoint(arg0 context.Context, arg1 test.GetPointArgs) (*test.TestPoint, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPoint", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestPoint)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPoint indicates an expected call of GetPoint
+func (mr *MockTestClientMockRecorder) GetPoint(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPoint", reflect.TypeOf((*MockTestClient)(nil).GetPoint), arg0, arg1)
+}
+
+// GetPoints mocks base method
+func (m *MockTestClient) GetPoints(arg0 context.Context, arg1 test.GetPointsArgs) (*[]test.TestPoint, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPoints", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestPoint)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPoints indicates an expected call of GetPoints
+func (mr *MockTestClientMockRecorder) GetPoints(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPoints", reflect.TypeOf((*MockTestClient)(nil).GetPoints), arg0, arg1)
+}
+
+// GetPointsByQuery mocks base method
+func (m *MockTestClient) GetPointsByQuery(arg0 context.Context, arg1 test.GetPointsByQueryArgs) (*test.TestPointsQuery, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPointsByQuery", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestPointsQuery)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPointsByQuery indicates an expected call of GetPointsByQuery
+func (mr *MockTestClientMockRecorder) GetPointsByQuery(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPointsByQuery", reflect.TypeOf((*MockTestClient)(nil).GetPointsByQuery), arg0, arg1)
+}
+
+// GetResultParameters mocks base method
+func (m *MockTestClient) GetResultParameters(arg0 context.Context, arg1 test.GetResultParametersArgs) (*[]test.TestResultParameterModel, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetResultParameters", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestResultParameterModel)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetResultParameters indicates an expected call of GetResultParameters
+func (mr *MockTestClientMockRecorder) GetResultParameters(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResultParameters", reflect.TypeOf((*MockTestClient)(nil).GetResultParameters), arg0, arg1)
+}
+
+// GetResultRetentionSettings mocks base method
+func (m *MockTestClient) GetResultRetentionSettings(arg0 context.Context, arg1 test.GetResultRetentionSettingsArgs) (*test.ResultRetentionSettings, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetResultRetentionSettings", arg0, arg1)
+	ret0, _ := ret[0].(*test.ResultRetentionSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetResultRetentionSettings indicates an expected call of GetResultRetentionSettings
+func (mr *MockTestClientMockRecorder) GetResultRetentionSettings(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResultRetentionSettings", reflect.TypeOf((*MockTestClient)(nil).GetResultRetentionSettings), arg0, arg1)
+}
+
+// GetTestCaseById mocks base method
+func (m *MockTestClient) GetTestCaseById(arg0 context.Context, arg1 test.GetTestCaseByIdArgs) (*test.SuiteTestCase, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestCaseById", arg0, arg1)
+	ret0, _ := ret[0].(*test.SuiteTestCase)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestCaseById indicates an expected call of GetTestCaseById
+func (mr *MockTestClientMockRecorder) GetTestCaseById(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestCaseById", reflect.TypeOf((*MockTestClient)(nil).GetTestCaseById), arg0, arg1)
+}
+
+// GetTestCases mocks base method
+func (m *MockTestClient) GetTestCases(arg0 context.Context, arg1 test.GetTestCasesArgs) (*[]test.SuiteTestCase, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestCases", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.SuiteTestCase)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestCases indicates an expected call of GetTestCases
+func (mr *MockTestClientMockRecorder) GetTestCases(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestCases", reflect.TypeOf((*MockTestClient)(nil).GetTestCases), arg0, arg1)
+}
+
+// GetTestIteration mocks base method
+func (m *MockTestClient) GetTestIteration(arg0 context.Context, arg1 test.GetTestIterationArgs) (*test.TestIterationDetailsModel, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestIteration", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestIterationDetailsModel)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestIteration indicates an expected call of GetTestIteration
+func (mr *MockTestClientMockRecorder) GetTestIteration(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestIteration", reflect.TypeOf((*MockTestClient)(nil).GetTestIteration), arg0, arg1)
+}
+
+// GetTestIterations mocks base method
+func (m *MockTestClient) GetTestIterations(arg0 context.Context, arg1 test.GetTestIterationsArgs) (*[]test.TestIterationDetailsModel, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestIterations", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestIterationDetailsModel)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestIterations indicates an expected call of GetTestIterations
+func (mr *MockTestClientMockRecorder) GetTestIterations(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestIterations", reflect.TypeOf((*MockTestClient)(nil).GetTestIterations), arg0, arg1)
+}
+
+// GetTestResultAttachmentContent mocks base method
+func (m *MockTestClient) GetTestResultAttachmentContent(arg0 context.Context, arg1 test.GetTestResultAttachmentContentArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestResultAttachmentContent", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestResultAttachmentContent indicates an expected call of GetTestResultAttachmentContent
+func (mr *MockTestClientMockRecorder) GetTestResultAttachmentContent(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestResultAttachmentContent", reflect.TypeOf((*MockTestClient)(nil).GetTestResultAttachmentContent), arg0, arg1)
+}
+
+// GetTestResultAttachmentZip mocks base method
+func (m *MockTestClient) GetTestResultAttachmentZip(arg0 context.Context, arg1 test.GetTestResultAttachmentZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestResultAttachmentZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestResultAttachmentZip indicates an expected call of GetTestResultAttachmentZip
+func (mr *MockTestClientMockRecorder) GetTestResultAttachmentZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestResultAttachmentZip", reflect.TypeOf((*MockTestClient)(nil).GetTestResultAttachmentZip), arg0, arg1)
+}
+
+// GetTestResultAttachments mocks base method
+func (m *MockTestClient) GetTestResultAttachments(arg0 context.Context, arg1 test.GetTestResultAttachmentsArgs) (*[]test.TestAttachment, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestResultAttachments", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestAttachment)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestResultAttachments indicates an expected call of GetTestResultAttachments
+func (mr *MockTestClientMockRecorder) GetTestResultAttachments(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestResultAttachments", reflect.TypeOf((*MockTestClient)(nil).GetTestResultAttachments), arg0, arg1)
+}
+
+// GetTestResultById mocks base method
+func (m *MockTestClient) GetTestResultById(arg0 context.Context, arg1 test.GetTestResultByIdArgs) (*test.TestCaseResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestResultById", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestCaseResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestResultById indicates an expected call of GetTestResultById
+func (mr *MockTestClientMockRecorder) GetTestResultById(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestResultById", reflect.TypeOf((*MockTestClient)(nil).GetTestResultById), arg0, arg1)
+}
+
+// GetTestResults mocks base method
+func (m *MockTestClient) GetTestResults(arg0 context.Context, arg1 test.GetTestResultsArgs) (*[]test.TestCaseResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestResults", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestCaseResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestResults indicates an expected call of GetTestResults
+func (mr *MockTestClientMockRecorder) GetTestResults(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestResults", reflect.TypeOf((*MockTestClient)(nil).GetTestResults), arg0, arg1)
+}
+
+// GetTestRunAttachmentContent mocks base method
+func (m *MockTestClient) GetTestRunAttachmentContent(arg0 context.Context, arg1 test.GetTestRunAttachmentContentArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestRunAttachmentContent", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestRunAttachmentContent indicates an expected call of GetTestRunAttachmentContent
+func (mr *MockTestClientMockRecorder) GetTestRunAttachmentContent(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestRunAttachmentContent", reflect.TypeOf((*MockTestClient)(nil).GetTestRunAttachmentContent), arg0, arg1)
+}
+
+// GetTestRunAttachmentZip mocks base method
+func (m *MockTestClient) GetTestRunAttachmentZip(arg0 context.Context, arg1 test.GetTestRunAttachmentZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestRunAttachmentZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestRunAttachmentZip indicates an expected call of GetTestRunAttachmentZip
+func (mr *MockTestClientMockRecorder) GetTestRunAttachmentZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestRunAttachmentZip", reflect.TypeOf((*MockTestClient)(nil).GetTestRunAttachmentZip), arg0, arg1)
+}
+
+// GetTestRunAttachments mocks base method
+func (m *MockTestClient) GetTestRunAttachments(arg0 context.Context, arg1 test.GetTestRunAttachmentsArgs) (*[]test.TestAttachment, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestRunAttachments", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestAttachment)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestRunAttachments indicates an expected call of GetTestRunAttachments
+func (mr *MockTestClientMockRecorder) GetTestRunAttachments(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestRunAttachments", reflect.TypeOf((*MockTestClient)(nil).GetTestRunAttachments), arg0, arg1)
+}
+
+// GetTestRunById mocks base method
+func (m *MockTestClient) GetTestRunById(arg0 context.Context, arg1 test.GetTestRunByIdArgs) (*test.TestRun, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestRunById", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestRun)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestRunById indicates an expected call of GetTestRunById
+func (mr *MockTestClientMockRecorder) GetTestRunById(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestRunById", reflect.TypeOf((*MockTestClient)(nil).GetTestRunById), arg0, arg1)
+}
+
+// GetTestRunCodeCoverage mocks base method
+func (m *MockTestClient) GetTestRunCodeCoverage(arg0 context.Context, arg1 test.GetTestRunCodeCoverageArgs) (*[]test.TestRunCoverage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestRunCodeCoverage", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestRunCoverage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestRunCodeCoverage indicates an expected call of GetTestRunCodeCoverage
+func (mr *MockTestClientMockRecorder) GetTestRunCodeCoverage(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestRunCodeCoverage", reflect.TypeOf((*MockTestClient)(nil).GetTestRunCodeCoverage), arg0, arg1)
+}
+
+// GetTestRunStatistics mocks base method
+func (m *MockTestClient) GetTestRunStatistics(arg0 context.Context, arg1 test.GetTestRunStatisticsArgs) (*test.TestRunStatistic, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestRunStatistics", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestRunStatistic)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestRunStatistics indicates an expected call of GetTestRunStatistics
+func (mr *MockTestClientMockRecorder) GetTestRunStatistics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestRunStatistics", reflect.TypeOf((*MockTestClient)(nil).GetTestRunStatistics), arg0, arg1)
+}
+
+// GetTestRuns mocks base method
+func (m *MockTestClient) GetTestRuns(arg0 context.Context, arg1 test.GetTestRunsArgs) (*[]test.TestRun, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestRuns", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestRun)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestRuns indicates an expected call of GetTestRuns
+func (mr *MockTestClientMockRecorder) GetTestRuns(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestRuns", reflect.TypeOf((*MockTestClient)(nil).GetTestRuns), arg0, arg1)
+}
+
+// GetTestSessions mocks base method
+func (m *MockTestClient) GetTestSessions(arg0 context.Context, arg1 test.GetTestSessionsArgs) (*[]test.TestSession, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestSessions", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestSession)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestSessions indicates an expected call of GetTestSessions
+func (mr *MockTestClientMockRecorder) GetTestSessions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestSessions", reflect.TypeOf((*MockTestClient)(nil).GetTestSessions), arg0, arg1)
+}
+
+// GetTestSubResultAttachmentContent mocks base method
+func (m *MockTestClient) GetTestSubResultAttachmentContent(arg0 context.Context, arg1 test.GetTestSubResultAttachmentContentArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestSubResultAttachmentContent", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestSubResultAttachmentContent indicates an expected call of GetTestSubResultAttachmentContent
+func (mr *MockTestClientMockRecorder) GetTestSubResultAttachmentContent(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestSubResultAttachmentContent", reflect.TypeOf((*MockTestClient)(nil).GetTestSubResultAttachmentContent), arg0, arg1)
+}
+
+// GetTestSubResultAttachmentZip mocks base method
+func (m *MockTestClient) GetTestSubResultAttachmentZip(arg0 context.Context, arg1 test.GetTestSubResultAttachmentZipArgs) (io.ReadCloser, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestSubResultAttachmentZip", arg0, arg1)
+	ret0, _ := ret[0].(io.ReadCloser)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestSubResultAttachmentZip indicates an expected call of GetTestSubResultAttachmentZip
+func (mr *MockTestClientMockRecorder) GetTestSubResultAttachmentZip(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestSubResultAttachmentZip", reflect.TypeOf((*MockTestClient)(nil).GetTestSubResultAttachmentZip), arg0, arg1)
+}
+
+// GetTestSubResultAttachments mocks base method
+func (m *MockTestClient) GetTestSubResultAttachments(arg0 context.Context, arg1 test.GetTestSubResultAttachmentsArgs) (*[]test.TestAttachment, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTestSubResultAttachments", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestAttachment)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTestSubResultAttachments indicates an expected call of GetTestSubResultAttachments
+func (mr *MockTestClientMockRecorder) GetTestSubResultAttachments(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestSubResultAttachments", reflect.TypeOf((*MockTestClient)(nil).GetTestSubResultAttachments), arg0, arg1)
+}
+
+// QueryTestHistory mocks base method
+func (m *MockTestClient) QueryTestHistory(arg0 context.Context, arg1 test.QueryTestHistoryArgs) (*test.TestHistoryQuery, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "QueryTestHistory", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestHistoryQuery)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// QueryTestHistory indicates an expected call of QueryTestHistory
+func (mr *MockTestClientMockRecorder) QueryTestHistory(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTestHistory", reflect.TypeOf((*MockTestClient)(nil).QueryTestHistory), arg0, arg1)
+}
+
+// QueryTestRuns mocks base method
+func (m *MockTestClient) QueryTestRuns(arg0 context.Context, arg1 test.QueryTestRunsArgs) (*test.QueryTestRunsResponseValue, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "QueryTestRuns", arg0, arg1)
+	ret0, _ := ret[0].(*test.QueryTestRunsResponseValue)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// QueryTestRuns indicates an expected call of QueryTestRuns
+func (mr *MockTestClientMockRecorder) QueryTestRuns(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTestRuns", reflect.TypeOf((*MockTestClient)(nil).QueryTestRuns), arg0, arg1)
+}
+
+// RemoveTestCasesFromSuiteUrl mocks base method
+func (m *MockTestClient) RemoveTestCasesFromSuiteUrl(arg0 context.Context, arg1 test.RemoveTestCasesFromSuiteUrlArgs) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RemoveTestCasesFromSuiteUrl", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RemoveTestCasesFromSuiteUrl indicates an expected call of RemoveTestCasesFromSuiteUrl
+func (mr *MockTestClientMockRecorder) RemoveTestCasesFromSuiteUrl(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTestCasesFromSuiteUrl", reflect.TypeOf((*MockTestClient)(nil).RemoveTestCasesFromSuiteUrl), arg0, arg1)
+}
+
+// UpdateResultRetentionSettings mocks base method
+func (m *MockTestClient) UpdateResultRetentionSettings(arg0 context.Context, arg1 test.UpdateResultRetentionSettingsArgs) (*test.ResultRetentionSettings, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateResultRetentionSettings", arg0, arg1)
+	ret0, _ := ret[0].(*test.ResultRetentionSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateResultRetentionSettings indicates an expected call of UpdateResultRetentionSettings
+func (mr *MockTestClientMockRecorder) UpdateResultRetentionSettings(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResultRetentionSettings", reflect.TypeOf((*MockTestClient)(nil).UpdateResultRetentionSettings), arg0, arg1)
+}
+
+// UpdateSuiteTestCases mocks base method
+func (m *MockTestClient) UpdateSuiteTestCases(arg0 context.Context, arg1 test.UpdateSuiteTestCasesArgs) (*[]test.SuiteTestCase, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateSuiteTestCases", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.SuiteTestCase)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateSuiteTestCases indicates an expected call of UpdateSuiteTestCases
+func (mr *MockTestClientMockRecorder) UpdateSuiteTestCases(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSuiteTestCases", reflect.TypeOf((*MockTestClient)(nil).UpdateSuiteTestCases), arg0, arg1)
+}
+
+// UpdateTestPoints mocks base method
+func (m *MockTestClient) UpdateTestPoints(arg0 context.Context, arg1 test.UpdateTestPointsArgs) (*[]test.TestPoint, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateTestPoints", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestPoint)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateTestPoints indicates an expected call of UpdateTestPoints
+func (mr *MockTestClientMockRecorder) UpdateTestPoints(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTestPoints", reflect.TypeOf((*MockTestClient)(nil).UpdateTestPoints), arg0, arg1)
+}
+
+// UpdateTestResults mocks base method
+func (m *MockTestClient) UpdateTestResults(arg0 context.Context, arg1 test.UpdateTestResultsArgs) (*[]test.TestCaseResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateTestResults", arg0, arg1)
+	ret0, _ := ret[0].(*[]test.TestCaseResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateTestResults indicates an expected call of UpdateTestResults
+func (mr *MockTestClientMockRecorder) UpdateTestResults(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTestResults", reflect.TypeOf((*MockTestClient)(nil).UpdateTestResults), arg0, arg1)
+}
+
+// UpdateTestRun mocks base method
+func (m *MockTestClient) UpdateTestRun(arg0 context.Context, arg1 test.UpdateTestRunArgs) (*test.TestRun, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateTestRun", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestRun)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateTestRun indicates an expected call of UpdateTestRun
+func (mr *MockTestClientMockRecorder) UpdateTestRun(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTestRun", reflect.TypeOf((*MockTestClient)(nil).UpdateTestRun), arg0, arg1)
+}
+
+// UpdateTestSession mocks base method
+func (m *MockTestClient) UpdateTestSession(arg0 context.Context, arg1 test.UpdateTestSessionArgs) (*test.TestSession, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateTestSession", arg0, arg1)
+	ret0, _ := ret[0].(*test.TestSession)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateTestSession indicates an expected call of UpdateTestSession
+func (mr *MockTestClientMockRecorder) UpdateTestSession(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTestSession", reflect.TypeOf((*MockTestClient)(nil).UpdateTestSession), arg0, arg1)
+}