From 2c5c17a5d5adfbc0b0327e92cb263613f259e6cc Mon Sep 17 00:00:00 2001 From: gfleury Date: Fri, 2 Nov 2018 20:14:46 +0100 Subject: [PATCH] Adding tests --- api_client_test.go | 434 +++ api_response_test.go | 293 ++ configuration_test.go | 84 + default_api_test.go | 6801 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 7612 insertions(+) create mode 100644 api_client_test.go create mode 100644 api_response_test.go create mode 100644 configuration_test.go create mode 100644 default_api_test.go diff --git a/api_client_test.go b/api_client_test.go new file mode 100644 index 0000000..a825422 --- /dev/null +++ b/api_client_test.go @@ -0,0 +1,434 @@ +/* + * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git) + */ + +package bitbucketv1 + +import ( + "bytes" + "mime/multipart" + "net/http" + "net/url" + "reflect" + "testing" + "time" + + "golang.org/x/net/context" +) + +func TestNewAPIClient(t *testing.T) { + type args struct { + ctx context.Context + cfg *Configuration + } + tests := []struct { + name string + args args + want *APIClient + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewAPIClient(tt.args.ctx, tt.args.cfg); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewAPIClient() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_atoi(t *testing.T) { + type args struct { + in string + } + tests := []struct { + name string + args args + want int + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := atoi(tt.args.in) + if (err != nil) != tt.wantErr { + t.Errorf("atoi() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("atoi() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_selectHeaderContentType(t *testing.T) { + type args struct { + contentTypes []string + } + tests := []struct { + name string + args args + want string + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := selectHeaderContentType(tt.args.contentTypes); got != tt.want { + t.Errorf("selectHeaderContentType() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_selectHeaderAccept(t *testing.T) { + type args struct { + accepts []string + } + tests := []struct { + name string + args args + want string + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := selectHeaderAccept(tt.args.accepts); got != tt.want { + t.Errorf("selectHeaderAccept() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_contains(t *testing.T) { + type args struct { + haystack []string + needle string + } + tests := []struct { + name string + args args + want bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := contains(tt.args.haystack, tt.args.needle); got != tt.want { + t.Errorf("contains() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_typeCheckParameter(t *testing.T) { + type args struct { + obj interface{} + expected string + name string + } + tests := []struct { + name string + args args + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := typeCheckParameter(tt.args.obj, tt.args.expected, tt.args.name); (err != nil) != tt.wantErr { + t.Errorf("typeCheckParameter() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_parameterToString(t *testing.T) { + type args struct { + obj interface{} + collectionFormat string + } + tests := []struct { + name string + args args + want string + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := parameterToString(tt.args.obj, tt.args.collectionFormat); got != tt.want { + t.Errorf("parameterToString() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestAPIClient_callAPI(t *testing.T) { + type fields struct { + cfg *Configuration + common service + ctx context.Context + DefaultApi *DefaultApiService + } + type args struct { + request *http.Request + } + tests := []struct { + name string + fields fields + args args + want *http.Response + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &APIClient{ + cfg: tt.fields.cfg, + common: tt.fields.common, + ctx: tt.fields.ctx, + DefaultApi: tt.fields.DefaultApi, + } + got, err := c.callAPI(tt.args.request) + if (err != nil) != tt.wantErr { + t.Errorf("APIClient.callAPI() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("APIClient.callAPI() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestAPIClient_ChangeBasePath(t *testing.T) { + type fields struct { + cfg *Configuration + common service + ctx context.Context + DefaultApi *DefaultApiService + } + type args struct { + path string + } + tests := []struct { + name string + fields fields + args args + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &APIClient{ + cfg: tt.fields.cfg, + common: tt.fields.common, + ctx: tt.fields.ctx, + DefaultApi: tt.fields.DefaultApi, + } + c.ChangeBasePath(tt.args.path) + }) + } +} + +func TestAPIClient_prepareRequest(t *testing.T) { + type fields struct { + cfg *Configuration + common service + ctx context.Context + DefaultApi *DefaultApiService + } + type args struct { + ctx context.Context + path string + method string + postBody interface{} + headerParams map[string]string + queryParams url.Values + formParams url.Values + fileName string + fileBytes []byte + } + tests := []struct { + name string + fields fields + args args + wantLocalVarRequest *http.Request + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &APIClient{ + cfg: tt.fields.cfg, + common: tt.fields.common, + ctx: tt.fields.ctx, + DefaultApi: tt.fields.DefaultApi, + } + gotLocalVarRequest, err := c.prepareRequest(tt.args.ctx, tt.args.path, tt.args.method, tt.args.postBody, tt.args.headerParams, tt.args.queryParams, tt.args.formParams, tt.args.fileName, tt.args.fileBytes) + if (err != nil) != tt.wantErr { + t.Errorf("APIClient.prepareRequest() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(gotLocalVarRequest, tt.wantLocalVarRequest) { + t.Errorf("APIClient.prepareRequest() = %v, want %v", gotLocalVarRequest, tt.wantLocalVarRequest) + } + }) + } +} + +func Test_addFile(t *testing.T) { + type args struct { + w *multipart.Writer + fieldName string + path string + } + tests := []struct { + name string + args args + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := addFile(tt.args.w, tt.args.fieldName, tt.args.path); (err != nil) != tt.wantErr { + t.Errorf("addFile() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_reportError(t *testing.T) { + type args struct { + format string + a []interface{} + } + tests := []struct { + name string + args args + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := reportError(tt.args.format, tt.args.a...); (err != nil) != tt.wantErr { + t.Errorf("reportError() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_setBody(t *testing.T) { + type args struct { + body interface{} + contentType string + } + tests := []struct { + name string + args args + wantBodyBuf *bytes.Buffer + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + gotBodyBuf, err := setBody(tt.args.body, tt.args.contentType) + if (err != nil) != tt.wantErr { + t.Errorf("setBody() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(gotBodyBuf, tt.wantBodyBuf) { + t.Errorf("setBody() = %v, want %v", gotBodyBuf, tt.wantBodyBuf) + } + }) + } +} + +func Test_detectContentType(t *testing.T) { + type args struct { + body interface{} + } + tests := []struct { + name string + args args + want string + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := detectContentType(tt.args.body); got != tt.want { + t.Errorf("detectContentType() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_parseCacheControl(t *testing.T) { + type args struct { + headers http.Header + } + tests := []struct { + name string + args args + want cacheControl + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := parseCacheControl(tt.args.headers); !reflect.DeepEqual(got, tt.want) { + t.Errorf("parseCacheControl() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestCacheExpires(t *testing.T) { + type args struct { + r *http.Response + } + tests := []struct { + name string + args args + want time.Time + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := CacheExpires(tt.args.r); !reflect.DeepEqual(got, tt.want) { + t.Errorf("CacheExpires() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_strlen(t *testing.T) { + type args struct { + s string + } + tests := []struct { + name string + args args + want int + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := strlen(tt.args.s); got != tt.want { + t.Errorf("strlen() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/api_response_test.go b/api_response_test.go new file mode 100644 index 0000000..b965cc3 --- /dev/null +++ b/api_response_test.go @@ -0,0 +1,293 @@ +/* + * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git) + */ + +package bitbucketv1 + +import ( + "net/http" + "reflect" + "testing" +) + +func TestSSHKey_String(t *testing.T) { + type fields struct { + ID int + Text string + Label string + } + tests := []struct { + name string + fields fields + want string + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + k := &SSHKey{ + ID: tt.fields.ID, + Text: tt.fields.Text, + Label: tt.fields.Label, + } + if got := k.String(); got != tt.want { + t.Errorf("SSHKey.String() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetCommitsResponse(t *testing.T) { + type args struct { + r *APIResponse + } + tests := []struct { + name string + args args + want []Commit + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := GetCommitsResponse(tt.args.r) + if (err != nil) != tt.wantErr { + t.Errorf("GetCommitsResponse() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetCommitsResponse() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetTagsResponse(t *testing.T) { + type args struct { + r *APIResponse + } + tests := []struct { + name string + args args + want []Tag + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := GetTagsResponse(tt.args.r) + if (err != nil) != tt.wantErr { + t.Errorf("GetTagsResponse() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetTagsResponse() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetBranchesResponse(t *testing.T) { + type args struct { + r *APIResponse + } + tests := []struct { + name string + args args + want []Branch + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := GetBranchesResponse(tt.args.r) + if (err != nil) != tt.wantErr { + t.Errorf("GetBranchesResponse() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetBranchesResponse() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetRepositoriesResponse(t *testing.T) { + type args struct { + r *APIResponse + } + tests := []struct { + name string + args args + want []Repository + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := GetRepositoriesResponse(tt.args.r) + if (err != nil) != tt.wantErr { + t.Errorf("GetRepositoriesResponse() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetRepositoriesResponse() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetRepositoryResponse(t *testing.T) { + type args struct { + r *APIResponse + } + tests := []struct { + name string + args args + want Repository + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := GetRepositoryResponse(tt.args.r) + if (err != nil) != tt.wantErr { + t.Errorf("GetRepositoryResponse() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetRepositoryResponse() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetDiffResponse(t *testing.T) { + type args struct { + r *APIResponse + } + tests := []struct { + name string + args args + want Diff + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := GetDiffResponse(tt.args.r) + if (err != nil) != tt.wantErr { + t.Errorf("GetDiffResponse() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetDiffResponse() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetSSHKeysResponse(t *testing.T) { + type args struct { + r *APIResponse + } + tests := []struct { + name string + args args + want []SSHKey + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := GetSSHKeysResponse(tt.args.r) + if (err != nil) != tt.wantErr { + t.Errorf("GetSSHKeysResponse() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetSSHKeysResponse() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNewAPIResponse(t *testing.T) { + type args struct { + r *http.Response + } + tests := []struct { + name string + args args + want *APIResponse + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewAPIResponse(tt.args.r); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewAPIResponse() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNewAPIResponseWithError(t *testing.T) { + type args struct { + r *http.Response + err error + } + tests := []struct { + name string + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := NewAPIResponseWithError(tt.args.r, tt.args.err) + if (err != nil) != tt.wantErr { + t.Errorf("NewAPIResponseWithError() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewAPIResponseWithError() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNewBitbucketAPIResponse(t *testing.T) { + type args struct { + r *http.Response + } + tests := []struct { + name string + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := NewBitbucketAPIResponse(tt.args.r) + if (err != nil) != tt.wantErr { + t.Errorf("NewBitbucketAPIResponse() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewBitbucketAPIResponse() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/configuration_test.go b/configuration_test.go new file mode 100644 index 0000000..3e90d87 --- /dev/null +++ b/configuration_test.go @@ -0,0 +1,84 @@ +/* + * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git) + */ + +package bitbucketv1 + +import ( + "net/http" + "reflect" + "testing" +) + +func Test_contextKey_String(t *testing.T) { + tests := []struct { + name string + c contextKey + want string + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.c.String(); got != tt.want { + t.Errorf("contextKey.String() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNewConfiguration(t *testing.T) { + type args struct { + basePath string + options []func(*Configuration) + } + tests := []struct { + name string + args args + want *Configuration + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewConfiguration(tt.args.basePath, tt.args.options...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewConfiguration() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestConfiguration_AddDefaultHeader(t *testing.T) { + type fields struct { + BasePath string + Host string + Scheme string + DefaultHeader map[string]string + UserAgent string + HTTPClient *http.Client + } + type args struct { + key string + value string + } + tests := []struct { + name string + fields fields + args args + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &Configuration{ + BasePath: tt.fields.BasePath, + Host: tt.fields.Host, + Scheme: tt.fields.Scheme, + DefaultHeader: tt.fields.DefaultHeader, + UserAgent: tt.fields.UserAgent, + HTTPClient: tt.fields.HTTPClient, + } + c.AddDefaultHeader(tt.args.key, tt.args.value) + }) + } +} diff --git a/default_api_test.go b/default_api_test.go new file mode 100644 index 0000000..1da056d --- /dev/null +++ b/default_api_test.go @@ -0,0 +1,6801 @@ +/* + * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git) + */ + +package bitbucketv1 + +import ( + "reflect" + "testing" + + "golang.org/x/net/context" +) + +func TestDefaultApiService_AddGroupToUser(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.AddGroupToUser(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.AddGroupToUser() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.AddGroupToUser() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_AddUserToGroup(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.AddUserToGroup(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.AddUserToGroup() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.AddUserToGroup() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_AddUserToGroups(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.AddUserToGroups(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.AddUserToGroups() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.AddUserToGroups() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_AddUsersToGroup(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.AddUsersToGroup(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.AddUsersToGroup() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.AddUsersToGroup() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Approve(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Approve(tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Approve() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Approve() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_AssignParticipantRole(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.AssignParticipantRole(tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.AssignParticipantRole() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.AssignParticipantRole() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CanMerge(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CanMerge(tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CanMerge() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CanMerge() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_ClearSenderAddress(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.ClearSenderAddress(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.ClearSenderAddress() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.ClearSenderAddress() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_ClearUserCaptchaChallenge(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.ClearUserCaptchaChallenge(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.ClearUserCaptchaChallenge() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.ClearUserCaptchaChallenge() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CountPullRequestTasks(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CountPullRequestTasks(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CountPullRequestTasks() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CountPullRequestTasks() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Create(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Create(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Create() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Create() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateBranch(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateBranch(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateBranch() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateBranch() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateComment(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateComment(tt.args.commitId, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateComment() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateComment() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateComment_1(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + pullRequestID int + localVarPostBody interface{} + localVarHTTPContentTypes []string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateComment_1(tt.args.projectKey, tt.args.repositorySlug, tt.args.pullRequestID, tt.args.localVarPostBody, tt.args.localVarHTTPContentTypes) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateComment_1() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateComment_1() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateGroup(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateGroup(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateGroup() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateGroup() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateProject(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateProject(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateProject() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateProject() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateRepository(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateRepository(tt.args.projectKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateRepository() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateRepository() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateRepositoryWithOptions(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + localVarPostBody interface{} + localVarHTTPContentTypes []string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateRepositoryWithOptions(tt.args.projectKey, tt.args.localVarPostBody, tt.args.localVarHTTPContentTypes) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateRepositoryWithOptions() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateRepositoryWithOptions() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreatePullRequestWithOptions(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repo string + localVarPostBody interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreatePullRequestWithOptions(tt.args.projectKey, tt.args.repo, tt.args.localVarPostBody) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreatePullRequestWithOptions() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreatePullRequestWithOptions() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateTag(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateTag(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateTag() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateTag() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateTask(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateTask(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateTask() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateTask() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateUser(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateUser(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateUser() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateUser() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateWebhook(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + localVarPostBody interface{} + localVarHTTPContentTypes []string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateWebhook(tt.args.projectKey, tt.args.repositorySlug, tt.args.localVarPostBody, tt.args.localVarHTTPContentTypes) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateWebhook() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateWebhook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Decline(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Decline(tt.args.pullRequestID, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Decline() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Decline() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Delete(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Delete(tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Delete() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Delete() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteAvatar(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteAvatar(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteAvatar() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteAvatar() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteComment(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + commentId int64 + commitId2 string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteComment(tt.args.commitId, tt.args.commentId, tt.args.commitId2, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteComment() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteComment() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteComment_2(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commentId int64 + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteComment_2(tt.args.commentId, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteComment_2() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteComment_2() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteGroup(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteGroup(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteGroup() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteGroup() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteMailConfig(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteMailConfig(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteMailConfig() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteMailConfig() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteProject(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteProject(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteProject() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteProject() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteRepository(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteRepository(tt.args.projectKey, tt.args.repositorySlug) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteRepository() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteRepository() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteRepositoryHook(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteRepositoryHook(tt.args.hookKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteRepositoryHook() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteRepositoryHook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteTask(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + taskId int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteTask(tt.args.taskId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteTask() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteTask() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteUser(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteUser(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteUser() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteUser() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DeleteWebhook(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + webhookId int32 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DeleteWebhook(tt.args.webhookId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DeleteWebhook() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DeleteWebhook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DisableHook(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DisableHook(tt.args.hookKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DisableHook() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DisableHook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_DisableHook_3(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.DisableHook_3(tt.args.hookKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.DisableHook_3() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.DisableHook_3() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_EditFile(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + path string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.EditFile(tt.args.path) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.EditFile() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.EditFile() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_EnableHook(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.EnableHook(tt.args.hookKey, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.EnableHook() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.EnableHook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_EnableHook_4(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.EnableHook_4(tt.args.hookKey, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.EnableHook_4() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.EnableHook_4() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_FindGroupsForUser(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.FindGroupsForUser(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.FindGroupsForUser() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.FindGroupsForUser() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_FindOtherGroupsForUser(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.FindOtherGroupsForUser(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.FindOtherGroupsForUser() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.FindOtherGroupsForUser() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_FindUsersInGroup(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.FindUsersInGroup(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.FindUsersInGroup() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.FindUsersInGroup() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_FindUsersNotInGroup(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.FindUsersNotInGroup(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.FindUsersNotInGroup() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.FindUsersNotInGroup() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_FindWebhooks(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.FindWebhooks(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.FindWebhooks() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.FindWebhooks() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_ForkRepository(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + localVarPostBody interface{} + localVarHTTPContentTypes []string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.ForkRepository(tt.args.projectKey, tt.args.repositorySlug, tt.args.localVarPostBody, tt.args.localVarHTTPContentTypes) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.ForkRepository() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.ForkRepository() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Get(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Get(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Get() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Get() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetActivities(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetActivities(tt.args.pullRequestID, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetActivities() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetActivities() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetApplicationProperties(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetApplicationProperties(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetApplicationProperties() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetApplicationProperties() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetArchive(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + project string + repository string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetArchive(tt.args.project, tt.args.repository, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetArchive() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetArchive() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetAvatar(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetAvatar(tt.args.hookKey, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetAvatar() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetAvatar() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetBranches(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + project string + repository string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetBranches(tt.args.project, tt.args.repository, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetBranches() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetBranches() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetChanges(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetChanges(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetChanges() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetChanges() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetChanges_5(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetChanges_5(tt.args.commitId, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetChanges_5() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetChanges_5() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetComment(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + commentId int64 + commitId2 string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetComment(tt.args.commitId, tt.args.commentId, tt.args.commitId2) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetComment() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetComment() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetComment_6(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commentId int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetComment_6(tt.args.commentId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetComment_6() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetComment_6() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetComments(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetComments(tt.args.commitId, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetComments() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetComments() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetComments_7(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetComments_7(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetComments_7() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetComments_7() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetCommit(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetCommit(tt.args.commitId, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetCommit() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetCommit() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetCommits(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + project string + repository string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetCommits(tt.args.project, tt.args.repository, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetCommits() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetCommits() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetCommits_8(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetCommits_8(tt.args.pullRequestID, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetCommits_8() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetCommits_8() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetContent(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetContent(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetContent() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetContent() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetContent_9(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + path string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetContent_9(tt.args.path, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetContent_9() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetContent_9() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetContent_10(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetContent_10(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetContent_10() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetContent_10() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetContent_11(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + path string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetContent_11(tt.args.path, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetContent_11() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetContent_11() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetDefaultBranch(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetDefaultBranch(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetDefaultBranch() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetDefaultBranch() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetForkedRepositories(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetForkedRepositories(tt.args.projectKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetForkedRepositories() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetForkedRepositories() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetGroups(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetGroups(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetGroups() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetGroups() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetGroupsWithAnyPermission(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetGroupsWithAnyPermission(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetGroupsWithAnyPermission() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetGroupsWithAnyPermission() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetGroupsWithAnyPermission_12(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetGroupsWithAnyPermission_12(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetGroupsWithAnyPermission_12() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetGroupsWithAnyPermission_12() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetGroupsWithAnyPermission_13(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetGroupsWithAnyPermission_13(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetGroupsWithAnyPermission_13() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetGroupsWithAnyPermission_13() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetGroupsWithoutAnyPermission(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetGroupsWithoutAnyPermission(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetGroupsWithoutAnyPermission() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetGroupsWithoutAnyPermission() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetGroupsWithoutAnyPermission_14(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetGroupsWithoutAnyPermission_14(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetGroupsWithoutAnyPermission_14() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetGroupsWithoutAnyPermission_14() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetGroupsWithoutAnyPermission_15(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetGroupsWithoutAnyPermission_15(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetGroupsWithoutAnyPermission_15() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetGroupsWithoutAnyPermission_15() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetGroups_16(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetGroups_16(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetGroups_16() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetGroups_16() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetInformation(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetInformation(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetInformation() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetInformation() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetLatestInvocation(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + webhookId int32 + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetLatestInvocation(tt.args.webhookId, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetLatestInvocation() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetLatestInvocation() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetLevel(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + loggerName string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetLevel(tt.args.loggerName) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetLevel() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetLevel() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetMailConfig(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetMailConfig(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetMailConfig() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetMailConfig() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetMergeConfig(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + scmId string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetMergeConfig(tt.args.scmId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetMergeConfig() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetMergeConfig() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequestsPage(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequestsPage(tt.args.projectKey, tt.args.repositorySlug, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequestsPage() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequestsPage() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetProject(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetProject(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetProject() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetProject() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetProjectAvatar(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetProjectAvatar(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetProjectAvatar() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetProjectAvatar() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetProjects(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetProjects(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetProjects() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetProjects() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequestCount(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequestCount(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequestCount() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequestCount() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequestSettings(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequestSettings(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequestSettings() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequestSettings() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequestSettings_17(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + scmId string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequestSettings_17(tt.args.scmId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequestSettings_17() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequestSettings_17() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequestSuggestions(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequestSuggestions(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequestSuggestions() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequestSuggestions() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequestTasks(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequestTasks(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequestTasks() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequestTasks() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequests(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequests(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequests() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequests() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequests_18(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequests_18(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequests_18() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequests_18() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRelatedRepositories(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRelatedRepositories(tt.args.projectKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRelatedRepositories() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRelatedRepositories() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRepositories(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRepositories(tt.args.projectKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRepositories() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRepositories() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRepositoriesWithOptions(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRepositoriesWithOptions(tt.args.projectKey, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRepositoriesWithOptions() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRepositoriesWithOptions() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRepositoriesRecentlyAccessed(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRepositoriesRecentlyAccessed(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRepositoriesRecentlyAccessed() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRepositoriesRecentlyAccessed() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRepositories_19(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRepositories_19(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRepositories_19() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRepositories_19() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRepository(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRepository(tt.args.projectKey, tt.args.repositorySlug) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRepository() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRepository() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUserRepository(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + username string + repositorySlug string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUserRepository(tt.args.username, tt.args.repositorySlug) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUserRepository() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUserRepository() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequest(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + pullRequestID int + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequest(tt.args.projectKey, tt.args.repositorySlug, tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequest() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequest() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequestActivity(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + pullRequestID int + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequestActivity(tt.args.projectKey, tt.args.repositorySlug, tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequestActivity() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequestActivity() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequestCommits(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + pullRequestID int + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequestCommits(tt.args.projectKey, tt.args.repositorySlug, tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequestCommits() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequestCommits() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetPullRequestCommitsWithOptions(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + pullRequestID int + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetPullRequestCommitsWithOptions(tt.args.projectKey, tt.args.repositorySlug, tt.args.pullRequestID, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetPullRequestCommitsWithOptions() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetPullRequestCommitsWithOptions() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetCommitBuildStatuses(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitSHA string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetCommitBuildStatuses(tt.args.commitSHA) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetCommitBuildStatuses() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetCommitBuildStatuses() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRepositoryHook(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRepositoryHook(tt.args.hookKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRepositoryHook() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRepositoryHook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRepositoryHook_20(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRepositoryHook_20(tt.args.hookKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRepositoryHook_20() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRepositoryHook_20() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRepositoryHooks(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRepositoryHooks(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRepositoryHooks() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRepositoryHooks() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRepositoryHooks_21(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRepositoryHooks_21(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRepositoryHooks_21() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRepositoryHooks_21() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetRootLevel(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetRootLevel(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetRootLevel() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetRootLevel() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetSenderAddress(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetSenderAddress(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetSenderAddress() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetSenderAddress() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetSettings(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetSettings(tt.args.hookKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetSettings() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetSettings() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetSettings_22(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetSettings_22(tt.args.hookKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetSettings_22() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetSettings_22() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetStatistics(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + webhookId int32 + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetStatistics(tt.args.webhookId, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetStatistics() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetStatistics() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetStatisticsSummary(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + webhookId int32 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetStatisticsSummary(tt.args.webhookId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetStatisticsSummary() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetStatisticsSummary() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetTag(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + name string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetTag(tt.args.name) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetTag() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetTag() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetTags(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + project string + repository string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetTags(tt.args.project, tt.args.repository, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetTags() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetTags() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetTask(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + taskId int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetTask(tt.args.taskId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetTask() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetTask() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetSSHKeys(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + user string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetSSHKeys(tt.args.user) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetSSHKeys() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetSSHKeys() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_CreateSSHKey(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.CreateSSHKey(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.CreateSSHKey() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.CreateSSHKey() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUser(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + username string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUser(tt.args.username) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUser() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUser() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUserSettings(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUserSettings(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUserSettings() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUserSettings() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUsers(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUsers(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUsers() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUsers() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUsersWithAnyPermission(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUsersWithAnyPermission(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUsersWithAnyPermission() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUsersWithAnyPermission() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUsersWithAnyPermission_23(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUsersWithAnyPermission_23(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUsersWithAnyPermission_23() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUsersWithAnyPermission_23() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUsersWithAnyPermission_24(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUsersWithAnyPermission_24(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUsersWithAnyPermission_24() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUsersWithAnyPermission_24() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUsersWithoutAnyPermission(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUsersWithoutAnyPermission(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUsersWithoutAnyPermission() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUsersWithoutAnyPermission() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUsersWithoutPermission(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUsersWithoutPermission(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUsersWithoutPermission() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUsersWithoutPermission() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUsersWithoutPermission_25(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUsersWithoutPermission_25(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUsersWithoutPermission_25() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUsersWithoutPermission_25() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetUsers_26(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetUsers_26(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetUsers_26() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetUsers_26() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_GetWebhook(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + webhookId int32 + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.GetWebhook(tt.args.webhookId, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.GetWebhook() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.GetWebhook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Get_27(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Get_27(tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Get_27() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Get_27() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_HasAllUserPermission(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + permission string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.HasAllUserPermission(tt.args.permission) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.HasAllUserPermission() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.HasAllUserPermission() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_ListParticipants(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.ListParticipants(tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.ListParticipants() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.ListParticipants() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Merge(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + pullRequestID int + localVarOptionals map[string]interface{} + localVarPostBody interface{} + localVarHTTPContentTypes []string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Merge(tt.args.projectKey, tt.args.repositorySlug, tt.args.pullRequestID, tt.args.localVarOptionals, tt.args.localVarPostBody, tt.args.localVarHTTPContentTypes) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Merge() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Merge() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_ModifyAllUserPermission(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + permission string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.ModifyAllUserPermission(tt.args.permission, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.ModifyAllUserPermission() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.ModifyAllUserPermission() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Preview(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Preview(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Preview() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Preview() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_RemoveGroupFromUser(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.RemoveGroupFromUser(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.RemoveGroupFromUser() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.RemoveGroupFromUser() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_RemoveUserFromGroup(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.RemoveUserFromGroup(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.RemoveUserFromGroup() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.RemoveUserFromGroup() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_RenameUser(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.RenameUser(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.RenameUser() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.RenameUser() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Reopen(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Reopen(tt.args.pullRequestID, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Reopen() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Reopen() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_RetryCreateRepository(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.RetryCreateRepository(tt.args.projectKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.RetryCreateRepository() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.RetryCreateRepository() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_RevokePermissionsForGroup(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.RevokePermissionsForGroup(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.RevokePermissionsForGroup() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.RevokePermissionsForGroup() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_RevokePermissionsForGroup_28(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.RevokePermissionsForGroup_28(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.RevokePermissionsForGroup_28() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.RevokePermissionsForGroup_28() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_RevokePermissionsForGroup_29(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.RevokePermissionsForGroup_29(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.RevokePermissionsForGroup_29() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.RevokePermissionsForGroup_29() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_RevokePermissionsForUser(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.RevokePermissionsForUser(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.RevokePermissionsForUser() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.RevokePermissionsForUser() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_RevokePermissionsForUser_30(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.RevokePermissionsForUser_30(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.RevokePermissionsForUser_30() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.RevokePermissionsForUser_30() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_RevokePermissionsForUser_31(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.RevokePermissionsForUser_31(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.RevokePermissionsForUser_31() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.RevokePermissionsForUser_31() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Search(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Search(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Search() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Search() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetDefaultBranch(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetDefaultBranch(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetDefaultBranch() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetDefaultBranch() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetLevel(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + levelName string + loggerName string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetLevel(tt.args.levelName, tt.args.loggerName) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetLevel() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetLevel() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetMailConfig(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetMailConfig(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetMailConfig() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetMailConfig() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetMergeConfig(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + scmId string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetMergeConfig(tt.args.scmId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetMergeConfig() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetMergeConfig() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetPermissionForGroup(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetPermissionForGroup(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetPermissionForGroup() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetPermissionForGroup() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetPermissionForGroups(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetPermissionForGroups(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetPermissionForGroups() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetPermissionForGroups() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetPermissionForGroups_32(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetPermissionForGroups_32(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetPermissionForGroups_32() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetPermissionForGroups_32() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetPermissionForUser(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetPermissionForUser(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetPermissionForUser() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetPermissionForUser() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetPermissionForUsers(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetPermissionForUsers(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetPermissionForUsers() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetPermissionForUsers() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetPermissionForUsers_33(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetPermissionForUsers_33(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetPermissionForUsers_33() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetPermissionForUsers_33() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetRootLevel(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + levelName string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetRootLevel(tt.args.levelName) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetRootLevel() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetRootLevel() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetSenderAddress(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetSenderAddress(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetSenderAddress() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetSenderAddress() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetSettings(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetSettings(tt.args.hookKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetSettings() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetSettings() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_SetSettings_34(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + hookKey string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.SetSettings_34(tt.args.hookKey) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.SetSettings_34() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.SetSettings_34() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Stream(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Stream(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Stream() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Stream() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamChanges(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamChanges(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamChanges() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamChanges() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamChanges_35(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamChanges_35(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamChanges_35() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamChanges_35() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamCommits(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + project string + repository string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamCommits(tt.args.project, tt.args.repository, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamCommits() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamCommits() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamDiff(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamDiff(tt.args.commitId, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamDiff() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamDiff() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamDiff_36(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + path string + commitId2 string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamDiff_36(tt.args.commitId, tt.args.path, tt.args.commitId2, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamDiff_36() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamDiff_36() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamDiff_37(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + project string + repository string + path string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamDiff_37(tt.args.project, tt.args.repository, tt.args.path, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamDiff_37() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamDiff_37() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamDiff_38(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamDiff_38(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamDiff_38() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamDiff_38() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamDiff_39(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + path string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamDiff_39(tt.args.path, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamDiff_39() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamDiff_39() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamDiff_40(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamDiff_40(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamDiff_40() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamDiff_40() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamDiff_41(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + path string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamDiff_41(tt.args.path, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamDiff_41() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamDiff_41() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamFiles(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamFiles(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamFiles() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamFiles() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_StreamFiles_42(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + path string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.StreamFiles_42(tt.args.path, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.StreamFiles_42() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.StreamFiles_42() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Stream_43(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + path string + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Stream_43(tt.args.path, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Stream_43() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Stream_43() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestWebhook(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.TestWebhook(tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.TestWebhook() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.TestWebhook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UnassignParticipantRole(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + localVarOptionals map[string]interface{} + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UnassignParticipantRole(tt.args.pullRequestID, tt.args.localVarOptionals) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UnassignParticipantRole() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UnassignParticipantRole() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UnassignParticipantRole_44(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + userSlug string + pullRequestId2 int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UnassignParticipantRole_44(tt.args.pullRequestID, tt.args.userSlug, tt.args.pullRequestId2) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UnassignParticipantRole_44() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UnassignParticipantRole_44() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Unwatch(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Unwatch(tt.args.commitId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Unwatch() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Unwatch() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Unwatch_45(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Unwatch_45(tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Unwatch_45() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Unwatch_45() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Update(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Update(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Update() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Update() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateComment(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + commentId int64 + commitId2 string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateComment(tt.args.commitId, tt.args.commentId, tt.args.commitId2) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateComment() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateComment() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateComment_46(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commentId int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateComment_46(tt.args.commentId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateComment_46() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateComment_46() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateProject(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateProject(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateProject() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateProject() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdatePullRequestSettings(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdatePullRequestSettings(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdatePullRequestSettings() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdatePullRequestSettings() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdatePullRequestSettings_47(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + scmId string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdatePullRequestSettings_47(tt.args.scmId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdatePullRequestSettings_47() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdatePullRequestSettings_47() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateRepository(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateRepository(tt.args.projectKey, tt.args.repositorySlug) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateRepository() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateRepository() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateRepositoryWithOptions(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + projectKey string + repositorySlug string + localVarPostBody interface{} + localVarHTTPContentTypes []string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateRepositoryWithOptions(tt.args.projectKey, tt.args.repositorySlug, tt.args.localVarPostBody, tt.args.localVarHTTPContentTypes) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateRepositoryWithOptions() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateRepositoryWithOptions() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateSettings(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateSettings(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateSettings() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateSettings() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateStatus(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + userSlug string + pullRequestId2 int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateStatus(tt.args.pullRequestID, tt.args.userSlug, tt.args.pullRequestId2) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateStatus() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateStatus() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateTask(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + taskId int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateTask(tt.args.taskId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateTask() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateTask() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateUserDetails(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateUserDetails(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateUserDetails() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateUserDetails() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateUserDetails_48(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateUserDetails_48(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateUserDetails_48() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateUserDetails_48() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateUserPassword(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateUserPassword(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateUserPassword() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateUserPassword() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateUserPassword_49(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateUserPassword_49(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateUserPassword_49() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateUserPassword_49() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UpdateWebhook(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + webhookId int32 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UpdateWebhook(tt.args.webhookId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UpdateWebhook() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UpdateWebhook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Update_50(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Update_50(tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Update_50() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Update_50() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UploadAvatar(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UploadAvatar(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UploadAvatar() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UploadAvatar() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_UploadAvatar_51(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + ctx context.Context + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.UploadAvatar_51(tt.args.ctx) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.UploadAvatar_51() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.UploadAvatar_51() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Watch(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + commitId string + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Watch(tt.args.commitId) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Watch() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Watch() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_Watch_52(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.Watch_52(tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.Watch_52() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.Watch_52() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDefaultApiService_WithdrawApproval(t *testing.T) { + type fields struct { + client *APIClient + } + type args struct { + pullRequestID int64 + } + tests := []struct { + name string + fields fields + args args + want *APIResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + a := &DefaultApiService{ + client: tt.fields.client, + } + got, err := a.WithdrawApproval(tt.args.pullRequestID) + if (err != nil) != tt.wantErr { + t.Errorf("DefaultApiService.WithdrawApproval() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultApiService.WithdrawApproval() = %v, want %v", got, tt.want) + } + }) + } +}