TheArchive/zitadel
1
0
Fork 0
mirror of https://github.com/zitadel/zitadel.git synced 2025-12-31 13:17:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Improve OrgListCommand tests

Browse Source
This commit is contained in:
Marco Ardizzone
2025-09-23 16:20:55 +02:00
parent 2276742ada
commit d3a33c1c58
3 changed files with 197 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

147
backend/v3/domain/mock/org.mock.go
View File

@@ -22,7 +22,6 @@ import (
type MockOrganizationRepository struct {
ctrl *gomock.Controller
recorder *MockOrganizationRepositoryMockRecorder
isgomock struct{}
}
// MockOrganizationRepositoryMockRecorder is the mock recorder for MockOrganizationRepository.
@@ -43,17 +42,17 @@ func (m *MockOrganizationRepository) EXPECT() *MockOrganizationRepositoryMockRec
}
// Create mocks base method.
func (m *MockOrganizationRepository) Create(ctx context.Context, organization *domain.Organization) error {
func (m *MockOrganizationRepository) Create(arg0 context.Context, arg1 *domain.Organization) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", ctx, organization)
ret := m.ctrl.Call(m, "Create", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// Create indicates an expected call of Create.
func (mr *MockOrganizationRepositoryMockRecorder) Create(ctx, organization any) *MockOrganizationRepositoryCreateCall {
func (mr *MockOrganizationRepositoryMockRecorder) Create(arg0, arg1 any) *MockOrganizationRepositoryCreateCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockOrganizationRepository)(nil).Create), ctx, organization)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockOrganizationRepository)(nil).Create), arg0, arg1)
return &MockOrganizationRepositoryCreateCall{Call: call}
}
@@ -119,18 +118,18 @@ func (c *MockOrganizationRepositoryCreatedAtColumnCall) DoAndReturn(f func() dat
}
// Delete mocks base method.
func (m *MockOrganizationRepository) Delete(ctx context.Context, id domain.OrgIdentifierCondition, instance_id string) (int64, error) {
func (m *MockOrganizationRepository) Delete(arg0 context.Context, arg1 domain.OrgIdentifierCondition, arg2 string) (int64, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, id, instance_id)
ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2)
ret0, _ := ret[0].(int64)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Delete indicates an expected call of Delete.
func (mr *MockOrganizationRepositoryMockRecorder) Delete(ctx, id, instance_id any) *MockOrganizationRepositoryDeleteCall {
func (mr *MockOrganizationRepositoryMockRecorder) Delete(arg0, arg1, arg2 any) *MockOrganizationRepositoryDeleteCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockOrganizationRepository)(nil).Delete), ctx, id, instance_id)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockOrganizationRepository)(nil).Delete), arg0, arg1, arg2)
return &MockOrganizationRepositoryDeleteCall{Call: call}
}
@@ -158,17 +157,17 @@ func (c *MockOrganizationRepositoryDeleteCall) DoAndReturn(f func(context.Contex
}
// Domains mocks base method.
func (m *MockOrganizationRepository) Domains(shouldLoad bool) domain.OrganizationDomainRepository {
func (m *MockOrganizationRepository) Domains(arg0 bool) domain.OrganizationDomainRepository {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Domains", shouldLoad)
ret := m.ctrl.Call(m, "Domains", arg0)
ret0, _ := ret[0].(domain.OrganizationDomainRepository)
return ret0
}
// Domains indicates an expected call of Domains.
func (mr *MockOrganizationRepositoryMockRecorder) Domains(shouldLoad any) *MockOrganizationRepositoryDomainsCall {
func (mr *MockOrganizationRepositoryMockRecorder) Domains(arg0 any) *MockOrganizationRepositoryDomainsCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Domains", reflect.TypeOf((*MockOrganizationRepository)(nil).Domains), shouldLoad)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Domains", reflect.TypeOf((*MockOrganizationRepository)(nil).Domains), arg0)
return &MockOrganizationRepositoryDomainsCall{Call: call}
}
@@ -195,11 +194,49 @@ func (c *MockOrganizationRepositoryDomainsCall) DoAndReturn(f func(bool) domain.
return c
}
// Get mocks base method.
func (m *MockOrganizationRepository) Get(ctx context.Context, opts ...database.QueryOption) (*domain.Organization, error) {
// ExistsDomain mocks base method.
func (m *MockOrganizationRepository) ExistsDomain(arg0 database.Condition) database.Condition {
m.ctrl.T.Helper()
varargs := []any{ctx}
for _, a := range opts {
ret := m.ctrl.Call(m, "ExistsDomain", arg0)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// ExistsDomain indicates an expected call of ExistsDomain.
func (mr *MockOrganizationRepositoryMockRecorder) ExistsDomain(arg0 any) *MockOrganizationRepositoryExistsDomainCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsDomain", reflect.TypeOf((*MockOrganizationRepository)(nil).ExistsDomain), arg0)
return &MockOrganizationRepositoryExistsDomainCall{Call: call}
}
// MockOrganizationRepositoryExistsDomainCall wrap *gomock.Call
type MockOrganizationRepositoryExistsDomainCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockOrganizationRepositoryExistsDomainCall) Return(arg0 database.Condition) *MockOrganizationRepositoryExistsDomainCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockOrganizationRepositoryExistsDomainCall) Do(f func(database.Condition) database.Condition) *MockOrganizationRepositoryExistsDomainCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockOrganizationRepositoryExistsDomainCall) DoAndReturn(f func(database.Condition) database.Condition) *MockOrganizationRepositoryExistsDomainCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// Get mocks base method.
func (m *MockOrganizationRepository) Get(arg0 context.Context, arg1 ...database.QueryOption) (*domain.Organization, error) {
m.ctrl.T.Helper()
varargs := []any{arg0}
for _, a := range arg1 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Get", varargs...)
@@ -209,9 +246,9 @@ func (m *MockOrganizationRepository) Get(ctx context.Context, opts ...database.Q
}
// Get indicates an expected call of Get.
func (mr *MockOrganizationRepositoryMockRecorder) Get(ctx any, opts ...any) *MockOrganizationRepositoryGetCall {
func (mr *MockOrganizationRepositoryMockRecorder) Get(arg0 any, arg1 ...any) *MockOrganizationRepositoryGetCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{ctx}, opts...)
varargs := append([]any{arg0}, arg1...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockOrganizationRepository)(nil).Get), varargs...)
return &MockOrganizationRepositoryGetCall{Call: call}
}
@@ -278,17 +315,17 @@ func (c *MockOrganizationRepositoryIDColumnCall) DoAndReturn(f func() database.C
}
// IDCondition mocks base method.
func (m *MockOrganizationRepository) IDCondition(organizationID string) domain.OrgIdentifierCondition {
func (m *MockOrganizationRepository) IDCondition(arg0 string) domain.OrgIdentifierCondition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IDCondition", organizationID)
ret := m.ctrl.Call(m, "IDCondition", arg0)
ret0, _ := ret[0].(domain.OrgIdentifierCondition)
return ret0
}
// IDCondition indicates an expected call of IDCondition.
func (mr *MockOrganizationRepositoryMockRecorder) IDCondition(organizationID any) *MockOrganizationRepositoryIDConditionCall {
func (mr *MockOrganizationRepositoryMockRecorder) IDCondition(arg0 any) *MockOrganizationRepositoryIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockOrganizationRepository)(nil).IDCondition), organizationID)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockOrganizationRepository)(nil).IDCondition), arg0)
return &MockOrganizationRepositoryIDConditionCall{Call: call}
}
@@ -354,17 +391,17 @@ func (c *MockOrganizationRepositoryInstanceIDColumnCall) DoAndReturn(f func() da
}
// InstanceIDCondition mocks base method.
func (m *MockOrganizationRepository) InstanceIDCondition(instanceID string) database.Condition {
func (m *MockOrganizationRepository) InstanceIDCondition(arg0 string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InstanceIDCondition", instanceID)
ret := m.ctrl.Call(m, "InstanceIDCondition", arg0)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockOrganizationRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockOrganizationRepositoryInstanceIDConditionCall {
func (mr *MockOrganizationRepositoryMockRecorder) InstanceIDCondition(arg0 any) *MockOrganizationRepositoryInstanceIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockOrganizationRepository)(nil).InstanceIDCondition), instanceID)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockOrganizationRepository)(nil).InstanceIDCondition), arg0)
return &MockOrganizationRepositoryInstanceIDConditionCall{Call: call}
}
@@ -392,10 +429,10 @@ func (c *MockOrganizationRepositoryInstanceIDConditionCall) DoAndReturn(f func(s
}
// List mocks base method.
func (m *MockOrganizationRepository) List(ctx context.Context, opts ...database.QueryOption) ([]*domain.Organization, error) {
func (m *MockOrganizationRepository) List(arg0 context.Context, arg1 ...database.QueryOption) ([]*domain.Organization, error) {
m.ctrl.T.Helper()
varargs := []any{ctx}
for _, a := range opts {
varargs := []any{arg0}
for _, a := range arg1 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "List", varargs...)
@@ -405,9 +442,9 @@ func (m *MockOrganizationRepository) List(ctx context.Context, opts ...database.
}
// List indicates an expected call of List.
func (mr *MockOrganizationRepositoryMockRecorder) List(ctx any, opts ...any) *MockOrganizationRepositoryListCall {
func (mr *MockOrganizationRepositoryMockRecorder) List(arg0 any, arg1 ...any) *MockOrganizationRepositoryListCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{ctx}, opts...)
varargs := append([]any{arg0}, arg1...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockOrganizationRepository)(nil).List), varargs...)
return &MockOrganizationRepositoryListCall{Call: call}
}
@@ -474,17 +511,17 @@ func (c *MockOrganizationRepositoryNameColumnCall) DoAndReturn(f func() database
}
// NameCondition mocks base method.
func (m *MockOrganizationRepository) NameCondition(name string) domain.OrgIdentifierCondition {
func (m *MockOrganizationRepository) NameCondition(arg0 database.TextOperation, arg1 string) domain.OrgIdentifierCondition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NameCondition", name)
ret := m.ctrl.Call(m, "NameCondition", arg0, arg1)
ret0, _ := ret[0].(domain.OrgIdentifierCondition)
return ret0
}
// NameCondition indicates an expected call of NameCondition.
func (mr *MockOrganizationRepositoryMockRecorder) NameCondition(name any) *MockOrganizationRepositoryNameConditionCall {
func (mr *MockOrganizationRepositoryMockRecorder) NameCondition(arg0, arg1 any) *MockOrganizationRepositoryNameConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NameCondition", reflect.TypeOf((*MockOrganizationRepository)(nil).NameCondition), name)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NameCondition", reflect.TypeOf((*MockOrganizationRepository)(nil).NameCondition), arg0, arg1)
return &MockOrganizationRepositoryNameConditionCall{Call: call}
}
@@ -500,29 +537,29 @@ func (c *MockOrganizationRepositoryNameConditionCall) Return(arg0 domain.OrgIden
}
// Do rewrite *gomock.Call.Do
func (c *MockOrganizationRepositoryNameConditionCall) Do(f func(string) domain.OrgIdentifierCondition) *MockOrganizationRepositoryNameConditionCall {
func (c *MockOrganizationRepositoryNameConditionCall) Do(f func(database.TextOperation, string) domain.OrgIdentifierCondition) *MockOrganizationRepositoryNameConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockOrganizationRepositoryNameConditionCall) DoAndReturn(f func(string) domain.OrgIdentifierCondition) *MockOrganizationRepositoryNameConditionCall {
func (c *MockOrganizationRepositoryNameConditionCall) DoAndReturn(f func(database.TextOperation, string) domain.OrgIdentifierCondition) *MockOrganizationRepositoryNameConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SetName mocks base method.
func (m *MockOrganizationRepository) SetName(name string) database.Change {
func (m *MockOrganizationRepository) SetName(arg0 string) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetName", name)
ret := m.ctrl.Call(m, "SetName", arg0)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetName indicates an expected call of SetName.
func (mr *MockOrganizationRepositoryMockRecorder) SetName(name any) *MockOrganizationRepositorySetNameCall {
func (mr *MockOrganizationRepositoryMockRecorder) SetName(arg0 any) *MockOrganizationRepositorySetNameCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetName", reflect.TypeOf((*MockOrganizationRepository)(nil).SetName), name)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetName", reflect.TypeOf((*MockOrganizationRepository)(nil).SetName), arg0)
return &MockOrganizationRepositorySetNameCall{Call: call}
}
@@ -550,17 +587,17 @@ func (c *MockOrganizationRepositorySetNameCall) DoAndReturn(f func(string) datab
}
// SetState mocks base method.
func (m *MockOrganizationRepository) SetState(state domain.OrgState) database.Change {
func (m *MockOrganizationRepository) SetState(arg0 domain.OrgState) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetState", state)
ret := m.ctrl.Call(m, "SetState", arg0)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetState indicates an expected call of SetState.
func (mr *MockOrganizationRepositoryMockRecorder) SetState(state any) *MockOrganizationRepositorySetStateCall {
func (mr *MockOrganizationRepositoryMockRecorder) SetState(arg0 any) *MockOrganizationRepositorySetStateCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockOrganizationRepository)(nil).SetState), state)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockOrganizationRepository)(nil).SetState), arg0)
return &MockOrganizationRepositorySetStateCall{Call: call}
}
@@ -626,17 +663,17 @@ func (c *MockOrganizationRepositoryStateColumnCall) DoAndReturn(f func() databas
}
// StateCondition mocks base method.
func (m *MockOrganizationRepository) StateCondition(state domain.OrgState) database.Condition {
func (m *MockOrganizationRepository) StateCondition(arg0 domain.OrgState) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StateCondition", state)
ret := m.ctrl.Call(m, "StateCondition", arg0)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// StateCondition indicates an expected call of StateCondition.
func (mr *MockOrganizationRepositoryMockRecorder) StateCondition(state any) *MockOrganizationRepositoryStateConditionCall {
func (mr *MockOrganizationRepositoryMockRecorder) StateCondition(arg0 any) *MockOrganizationRepositoryStateConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCondition", reflect.TypeOf((*MockOrganizationRepository)(nil).StateCondition), state)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCondition", reflect.TypeOf((*MockOrganizationRepository)(nil).StateCondition), arg0)
return &MockOrganizationRepositoryStateConditionCall{Call: call}
}
@@ -664,10 +701,10 @@ func (c *MockOrganizationRepositoryStateConditionCall) DoAndReturn(f func(domain
}
// Update mocks base method.
func (m *MockOrganizationRepository) Update(ctx context.Context, id domain.OrgIdentifierCondition, instance_id string, changes ...database.Change) (int64, error) {
func (m *MockOrganizationRepository) Update(arg0 context.Context, arg1 domain.OrgIdentifierCondition, arg2 string, arg3 ...database.Change) (int64, error) {
m.ctrl.T.Helper()
varargs := []any{ctx, id, instance_id}
for _, a := range changes {
varargs := []any{arg0, arg1, arg2}
for _, a := range arg3 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Update", varargs...)
@@ -677,9 +714,9 @@ func (m *MockOrganizationRepository) Update(ctx context.Context, id domain.OrgId
}
// Update indicates an expected call of Update.
func (mr *MockOrganizationRepositoryMockRecorder) Update(ctx, id, instance_id any, changes ...any) *MockOrganizationRepositoryUpdateCall {
func (mr *MockOrganizationRepositoryMockRecorder) Update(arg0, arg1, arg2 any, arg3 ...any) *MockOrganizationRepositoryUpdateCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{ctx, id, instance_id}, changes...)
varargs := append([]any{arg0, arg1, arg2}, arg3...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockOrganizationRepository)(nil).Update), varargs...)
return &MockOrganizationRepositoryUpdateCall{Call: call}
}

103
backend/v3/domain/mock/org_domain.mock.go
View File

@@ -23,7 +23,6 @@ import (
type MockOrganizationDomainRepository struct {
ctrl *gomock.Controller
recorder *MockOrganizationDomainRepositoryMockRecorder
isgomock struct{}
}
// MockOrganizationDomainRepositoryMockRecorder is the mock recorder for MockOrganizationDomainRepository.
@@ -44,17 +43,17 @@ func (m *MockOrganizationDomainRepository) EXPECT() *MockOrganizationDomainRepos
}
// Add mocks base method.
func (m *MockOrganizationDomainRepository) Add(ctx context.Context, arg1 *domain.AddOrganizationDomain) error {
func (m *MockOrganizationDomainRepository) Add(arg0 context.Context, arg1 *domain.AddOrganizationDomain) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Add", ctx, arg1)
ret := m.ctrl.Call(m, "Add", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// Add indicates an expected call of Add.
func (mr *MockOrganizationDomainRepositoryMockRecorder) Add(ctx, arg1 any) *MockOrganizationDomainRepositoryAddCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) Add(arg0, arg1 any) *MockOrganizationDomainRepositoryAddCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).Add), ctx, arg1)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).Add), arg0, arg1)
return &MockOrganizationDomainRepositoryAddCall{Call: call}
}
@@ -158,17 +157,17 @@ func (c *MockOrganizationDomainRepositoryDomainColumnCall) DoAndReturn(f func()
}
// DomainCondition mocks base method.
func (m *MockOrganizationDomainRepository) DomainCondition(op database.TextOperation, arg1 string) database.Condition {
func (m *MockOrganizationDomainRepository) DomainCondition(arg0 database.TextOperation, arg1 string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DomainCondition", op, arg1)
ret := m.ctrl.Call(m, "DomainCondition", arg0, arg1)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// DomainCondition indicates an expected call of DomainCondition.
func (mr *MockOrganizationDomainRepositoryMockRecorder) DomainCondition(op, arg1 any) *MockOrganizationDomainRepositoryDomainConditionCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) DomainCondition(arg0, arg1 any) *MockOrganizationDomainRepositoryDomainConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainCondition", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).DomainCondition), op, arg1)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainCondition", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).DomainCondition), arg0, arg1)
return &MockOrganizationDomainRepositoryDomainConditionCall{Call: call}
}
@@ -196,10 +195,10 @@ func (c *MockOrganizationDomainRepositoryDomainConditionCall) DoAndReturn(f func
}
// Get mocks base method.
func (m *MockOrganizationDomainRepository) Get(ctx context.Context, opts ...database.QueryOption) (*domain.OrganizationDomain, error) {
func (m *MockOrganizationDomainRepository) Get(arg0 context.Context, arg1 ...database.QueryOption) (*domain.OrganizationDomain, error) {
m.ctrl.T.Helper()
varargs := []any{ctx}
for _, a := range opts {
varargs := []any{arg0}
for _, a := range arg1 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Get", varargs...)
@@ -209,9 +208,9 @@ func (m *MockOrganizationDomainRepository) Get(ctx context.Context, opts ...data
}
// Get indicates an expected call of Get.
func (mr *MockOrganizationDomainRepositoryMockRecorder) Get(ctx any, opts ...any) *MockOrganizationDomainRepositoryGetCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) Get(arg0 any, arg1 ...any) *MockOrganizationDomainRepositoryGetCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{ctx}, opts...)
varargs := append([]any{arg0}, arg1...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).Get), varargs...)
return &MockOrganizationDomainRepositoryGetCall{Call: call}
}
@@ -278,17 +277,17 @@ func (c *MockOrganizationDomainRepositoryInstanceIDColumnCall) DoAndReturn(f fun
}
// InstanceIDCondition mocks base method.
func (m *MockOrganizationDomainRepository) InstanceIDCondition(instanceID string) database.Condition {
func (m *MockOrganizationDomainRepository) InstanceIDCondition(arg0 string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InstanceIDCondition", instanceID)
ret := m.ctrl.Call(m, "InstanceIDCondition", arg0)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockOrganizationDomainRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockOrganizationDomainRepositoryInstanceIDConditionCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) InstanceIDCondition(arg0 any) *MockOrganizationDomainRepositoryInstanceIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).InstanceIDCondition), instanceID)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).InstanceIDCondition), arg0)
return &MockOrganizationDomainRepositoryInstanceIDConditionCall{Call: call}
}
@@ -354,17 +353,17 @@ func (c *MockOrganizationDomainRepositoryIsPrimaryColumnCall) DoAndReturn(f func
}
// IsPrimaryCondition mocks base method.
func (m *MockOrganizationDomainRepository) IsPrimaryCondition(isPrimary bool) database.Condition {
func (m *MockOrganizationDomainRepository) IsPrimaryCondition(arg0 bool) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsPrimaryCondition", isPrimary)
ret := m.ctrl.Call(m, "IsPrimaryCondition", arg0)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// IsPrimaryCondition indicates an expected call of IsPrimaryCondition.
func (mr *MockOrganizationDomainRepositoryMockRecorder) IsPrimaryCondition(isPrimary any) *MockOrganizationDomainRepositoryIsPrimaryConditionCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) IsPrimaryCondition(arg0 any) *MockOrganizationDomainRepositoryIsPrimaryConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPrimaryCondition", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).IsPrimaryCondition), isPrimary)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPrimaryCondition", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).IsPrimaryCondition), arg0)
return &MockOrganizationDomainRepositoryIsPrimaryConditionCall{Call: call}
}
@@ -430,17 +429,17 @@ func (c *MockOrganizationDomainRepositoryIsVerifiedColumnCall) DoAndReturn(f fun
}
// IsVerifiedCondition mocks base method.
func (m *MockOrganizationDomainRepository) IsVerifiedCondition(isVerified bool) database.Condition {
func (m *MockOrganizationDomainRepository) IsVerifiedCondition(arg0 bool) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsVerifiedCondition", isVerified)
ret := m.ctrl.Call(m, "IsVerifiedCondition", arg0)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// IsVerifiedCondition indicates an expected call of IsVerifiedCondition.
func (mr *MockOrganizationDomainRepositoryMockRecorder) IsVerifiedCondition(isVerified any) *MockOrganizationDomainRepositoryIsVerifiedConditionCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) IsVerifiedCondition(arg0 any) *MockOrganizationDomainRepositoryIsVerifiedConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsVerifiedCondition", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).IsVerifiedCondition), isVerified)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsVerifiedCondition", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).IsVerifiedCondition), arg0)
return &MockOrganizationDomainRepositoryIsVerifiedConditionCall{Call: call}
}
@@ -468,10 +467,10 @@ func (c *MockOrganizationDomainRepositoryIsVerifiedConditionCall) DoAndReturn(f
}
// List mocks base method.
func (m *MockOrganizationDomainRepository) List(ctx context.Context, opts ...database.QueryOption) ([]*domain.OrganizationDomain, error) {
func (m *MockOrganizationDomainRepository) List(arg0 context.Context, arg1 ...database.QueryOption) ([]*domain.OrganizationDomain, error) {
m.ctrl.T.Helper()
varargs := []any{ctx}
for _, a := range opts {
varargs := []any{arg0}
for _, a := range arg1 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "List", varargs...)
@@ -481,9 +480,9 @@ func (m *MockOrganizationDomainRepository) List(ctx context.Context, opts ...dat
}
// List indicates an expected call of List.
func (mr *MockOrganizationDomainRepositoryMockRecorder) List(ctx any, opts ...any) *MockOrganizationDomainRepositoryListCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) List(arg0 any, arg1 ...any) *MockOrganizationDomainRepositoryListCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{ctx}, opts...)
varargs := append([]any{arg0}, arg1...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).List), varargs...)
return &MockOrganizationDomainRepositoryListCall{Call: call}
}
@@ -550,17 +549,17 @@ func (c *MockOrganizationDomainRepositoryOrgIDColumnCall) DoAndReturn(f func() d
}
// OrgIDCondition mocks base method.
func (m *MockOrganizationDomainRepository) OrgIDCondition(orgID string) database.Condition {
func (m *MockOrganizationDomainRepository) OrgIDCondition(arg0 string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "OrgIDCondition", orgID)
ret := m.ctrl.Call(m, "OrgIDCondition", arg0)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// OrgIDCondition indicates an expected call of OrgIDCondition.
func (mr *MockOrganizationDomainRepositoryMockRecorder) OrgIDCondition(orgID any) *MockOrganizationDomainRepositoryOrgIDConditionCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) OrgIDCondition(arg0 any) *MockOrganizationDomainRepositoryOrgIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrgIDCondition", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).OrgIDCondition), orgID)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrgIDCondition", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).OrgIDCondition), arg0)
return &MockOrganizationDomainRepositoryOrgIDConditionCall{Call: call}
}
@@ -588,18 +587,18 @@ func (c *MockOrganizationDomainRepositoryOrgIDConditionCall) DoAndReturn(f func(
}
// Remove mocks base method.
func (m *MockOrganizationDomainRepository) Remove(ctx context.Context, condition database.Condition) (int64, error) {
func (m *MockOrganizationDomainRepository) Remove(arg0 context.Context, arg1 database.Condition) (int64, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Remove", ctx, condition)
ret := m.ctrl.Call(m, "Remove", arg0, arg1)
ret0, _ := ret[0].(int64)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Remove indicates an expected call of Remove.
func (mr *MockOrganizationDomainRepositoryMockRecorder) Remove(ctx, condition any) *MockOrganizationDomainRepositoryRemoveCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) Remove(arg0, arg1 any) *MockOrganizationDomainRepositoryRemoveCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).Remove), ctx, condition)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).Remove), arg0, arg1)
return &MockOrganizationDomainRepositoryRemoveCall{Call: call}
}
@@ -665,17 +664,17 @@ func (c *MockOrganizationDomainRepositorySetPrimaryCall) DoAndReturn(f func() da
}
// SetUpdatedAt mocks base method.
func (m *MockOrganizationDomainRepository) SetUpdatedAt(t time.Time) database.Change {
func (m *MockOrganizationDomainRepository) SetUpdatedAt(arg0 time.Time) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetUpdatedAt", t)
ret := m.ctrl.Call(m, "SetUpdatedAt", arg0)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetUpdatedAt indicates an expected call of SetUpdatedAt.
func (mr *MockOrganizationDomainRepositoryMockRecorder) SetUpdatedAt(t any) *MockOrganizationDomainRepositorySetUpdatedAtCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) SetUpdatedAt(arg0 any) *MockOrganizationDomainRepositorySetUpdatedAtCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).SetUpdatedAt), t)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).SetUpdatedAt), arg0)
return &MockOrganizationDomainRepositorySetUpdatedAtCall{Call: call}
}
@@ -703,17 +702,17 @@ func (c *MockOrganizationDomainRepositorySetUpdatedAtCall) DoAndReturn(f func(ti
}
// SetValidationType mocks base method.
func (m *MockOrganizationDomainRepository) SetValidationType(verificationType domain.DomainValidationType) database.Change {
func (m *MockOrganizationDomainRepository) SetValidationType(arg0 domain.DomainValidationType) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetValidationType", verificationType)
ret := m.ctrl.Call(m, "SetValidationType", arg0)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetValidationType indicates an expected call of SetValidationType.
func (mr *MockOrganizationDomainRepositoryMockRecorder) SetValidationType(verificationType any) *MockOrganizationDomainRepositorySetValidationTypeCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) SetValidationType(arg0 any) *MockOrganizationDomainRepositorySetValidationTypeCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidationType", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).SetValidationType), verificationType)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidationType", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).SetValidationType), arg0)
return &MockOrganizationDomainRepositorySetValidationTypeCall{Call: call}
}
@@ -779,10 +778,10 @@ func (c *MockOrganizationDomainRepositorySetVerifiedCall) DoAndReturn(f func() d
}
// Update mocks base method.
func (m *MockOrganizationDomainRepository) Update(ctx context.Context, condition database.Condition, changes ...database.Change) (int64, error) {
func (m *MockOrganizationDomainRepository) Update(arg0 context.Context, arg1 database.Condition, arg2 ...database.Change) (int64, error) {
m.ctrl.T.Helper()
varargs := []any{ctx, condition}
for _, a := range changes {
varargs := []any{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Update", varargs...)
@@ -792,9 +791,9 @@ func (m *MockOrganizationDomainRepository) Update(ctx context.Context, condition
}
// Update indicates an expected call of Update.
func (mr *MockOrganizationDomainRepositoryMockRecorder) Update(ctx, condition any, changes ...any) *MockOrganizationDomainRepositoryUpdateCall {
func (mr *MockOrganizationDomainRepositoryMockRecorder) Update(arg0, arg1 any, arg2 ...any) *MockOrganizationDomainRepositoryUpdateCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{ctx, condition}, changes...)
varargs := append([]any{arg0, arg1}, arg2...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockOrganizationDomainRepository)(nil).Update), varargs...)
return &MockOrganizationDomainRepositoryUpdateCall{Call: call}
}

64
backend/v3/domain/org_list_test.go
View File

@@ -227,6 +227,7 @@ func TestListOrgsCommand_OperationMapper(t *testing.T) {
}
func TestListOrgsCommand_Execute(t *testing.T) {
t.Parallel()
clientAcquireErr := errors.New("client acquire error")
listErr := errors.New("list mock error")
@@ -276,9 +277,23 @@ func TestListOrgsCommand_Execute(t *testing.T) {
repo := domainmock.NewOrgRepo(ctrl)
domainRepo := domainmock.NewOrgDomainRepo(ctrl)
repo.SetDomains(domainRepo)
repo.SetExistsDomain(database.Exists("domains", domainRepo.DomainCondition(database.TextOperationEqual, "some domain")))
repo.EXPECT().
List(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
List(
gomock.Any(),
dbmock.QueryOptions(
database.WithCondition(
database.And(
repo.InstanceIDCondition("instance-1"),
repo.ExistsDomain(domainRepo.DomainCondition(database.TextOperationEqual, "some domain")),
),
),
),
dbmock.QueryOptions(database.WithOrderBy(database.OrderDirectionAsc, repo.NameColumn())),
dbmock.QueryOptions(database.WithLimit(2)),
dbmock.QueryOptions(database.WithOffset(1)),
).
Times(1).
Return(nil, listErr)
@@ -313,11 +328,21 @@ func TestListOrgsCommand_Execute(t *testing.T) {
repo.SetDomains(domainRepo)
repo.EXPECT().
List(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
List(
gomock.Any(),
dbmock.QueryOptions(database.WithCondition(repo.IDCondition("org-1"))),
dbmock.QueryOptions(database.WithCondition(repo.IDCondition("org-2"))),
dbmock.QueryOptions(database.WithCondition(repo.NameCondition(database.TextOperationEqual, "Named Org"))),
dbmock.QueryOptions(database.WithCondition(repo.StateCondition(domain.OrgStateActive))),
dbmock.QueryOptions(database.WithOrderBy(database.OrderDirectionDesc, repo.NameColumn())),
dbmock.QueryOptions(database.WithLimit(2)),
dbmock.QueryOptions(database.WithOffset(1)),
).
Times(1).
Return([]*domain.Organization{
{ID: "1"},
{ID: "2"},
{ID: "org-1"},
{ID: "org-2"},
}, nil)
return func(_ database.QueryExecutor) domain.OrganizationRepository { return repo }
@@ -325,25 +350,44 @@ func TestListOrgsCommand_Execute(t *testing.T) {
inputRequest: &org.ListOrganizationsRequest{
Queries: []*org.SearchQuery{
{
Query: &org.SearchQuery_DomainQuery{
DomainQuery: &org.OrganizationDomainQuery{
Domain: "some domain",
Query: &org.SearchQuery_DefaultQuery{
DefaultQuery: &org.DefaultOrganizationQuery{},
},
},
{
Query: &org.SearchQuery_IdQuery{
IdQuery: &org.OrganizationIDQuery{
Id: "org-2",
},
},
},
{
Query: &org.SearchQuery_NameQuery{
NameQuery: &org.OrganizationNameQuery{
Name: "Named Org",
Method: object.TextQueryMethod_TEXT_QUERY_METHOD_EQUALS,
},
},
},
{
Query: &org.SearchQuery_StateQuery{
StateQuery: &org.OrganizationStateQuery{
State: org.OrganizationState_ORGANIZATION_STATE_ACTIVE,
},
},
},
},
SortingColumn: org.OrganizationFieldName_ORGANIZATION_FIELD_NAME_NAME,
Query: &object.ListQuery{
Asc: true,
Asc: false,
Offset: 1,
Limit: 2,
},
},
expectedOrganizations: []*domain.Organization{
{ID: "1"},
{ID: "2"},
{ID: "org-1"},
{ID: "org-2"},
},
},
}