From ed547ee1d4d30ec546a97fa0ca5076453f0912af Mon Sep 17 00:00:00 2001 From: Silvan Date: Tue, 16 Nov 2021 09:24:30 +0100 Subject: [PATCH] test(queries): policies prepare funcs (#2651) * chore(queries): test suite for prepare stmt funcs * test(queries): prepare project funcs * refactor: add comments * test: simlify expected sql, added possibility to add args to expected queries * test(queries): prepare funcs in org * chore(backend): correct modules * test(queries): org domain prepare funcs * test: correct name * refactor: file name * refactor: add table to login policy columns * chore(prepare_test): only add row to result if columns * test(queries): login policy prepare funcs * chore: add comments for configs * test(queries): prepare idp funcs * fix(queries): add table to password complexity policy cols * test(queries): password complexity policy prepare funcs * fix(queries): add table to password age policy cols * test(queries): password age policy prepare func * fix(queries): set cols on lockout policy * test(queries): lockout policy prepare funs * fix(queries): set table on privacy policy cols * test(queries): privacy policy prepare funcs * fix(queries): set table on org iam policy cols * fix(queries): correct table in org iam policy cols * test(queries): org iam policy prepare funcs --- internal/query/lockout_policy.go | 27 ++- internal/query/lockout_policy_test.go | 136 ++++++++++++++++ internal/query/org_iam_policy.go | 24 ++- internal/query/org_iam_policy_test.go | 130 +++++++++++++++ internal/query/password_age_policy.go | 27 ++- internal/query/password_age_policy_test.go | 136 ++++++++++++++++ internal/query/password_complexity_policy.go | 36 ++-- .../query/password_complexity_policy_test.go | 154 ++++++++++++++++++ internal/query/privacy_policy.go | 27 ++- internal/query/privacy_policy_test.go | 136 ++++++++++++++++ 10 files changed, 786 insertions(+), 47 deletions(-) create mode 100644 internal/query/lockout_policy_test.go create mode 100644 internal/query/org_iam_policy_test.go create mode 100644 internal/query/password_age_policy_test.go create mode 100644 internal/query/password_complexity_policy_test.go create mode 100644 internal/query/privacy_policy_test.go diff --git a/internal/query/lockout_policy.go b/internal/query/lockout_policy.go index 45f93bcf40..0a4b570a51 100644 --- a/internal/query/lockout_policy.go +++ b/internal/query/lockout_policy.go @@ -31,31 +31,40 @@ var ( name: projection.LockoutPolicyTable, } LockoutColID = Column{ - name: projection.LockoutPolicyIDCol, + name: projection.LockoutPolicyIDCol, + table: lockoutTable, } LockoutColSequence = Column{ - name: projection.LockoutPolicySequenceCol, + name: projection.LockoutPolicySequenceCol, + table: lockoutTable, } LockoutColCreationDate = Column{ - name: projection.LockoutPolicyCreationDateCol, + name: projection.LockoutPolicyCreationDateCol, + table: lockoutTable, } LockoutColChangeDate = Column{ - name: projection.LockoutPolicyChangeDateCol, + name: projection.LockoutPolicyChangeDateCol, + table: lockoutTable, } LockoutColResourceOwner = Column{ - name: projection.LockoutPolicyResourceOwnerCol, + name: projection.LockoutPolicyResourceOwnerCol, + table: lockoutTable, } LockoutColShowFailures = Column{ - name: projection.LockoutPolicyShowLockOutFailuresCol, + name: projection.LockoutPolicyShowLockOutFailuresCol, + table: lockoutTable, } LockoutColMaxPasswordAttempts = Column{ - name: projection.LockoutPolicyMaxPasswordAttemptsCol, + name: projection.LockoutPolicyMaxPasswordAttemptsCol, + table: lockoutTable, } LockoutColIsDefault = Column{ - name: projection.LockoutPolicyIsDefaultCol, + name: projection.LockoutPolicyIsDefaultCol, + table: lockoutTable, } LockoutColState = Column{ - name: projection.LockoutPolicyStateCol, + name: projection.LockoutPolicyStateCol, + table: lockoutTable, } ) diff --git a/internal/query/lockout_policy_test.go b/internal/query/lockout_policy_test.go new file mode 100644 index 0000000000..2a05448459 --- /dev/null +++ b/internal/query/lockout_policy_test.go @@ -0,0 +1,136 @@ +package query + +import ( + "database/sql" + "database/sql/driver" + "errors" + "fmt" + "regexp" + "testing" + + "github.com/caos/zitadel/internal/domain" + errs "github.com/caos/zitadel/internal/errors" +) + +func Test_LockoutPolicyPrepares(t *testing.T) { + type want struct { + sqlExpectations sqlExpectation + err checkErr + } + tests := []struct { + name string + prepare interface{} + want want + object interface{} + }{ + { + name: "prepareLockoutPolicyQuery no result", + prepare: prepareLockoutPolicyQuery, + want: want{ + sqlExpectations: mockQueries( + regexp.QuoteMeta(`SELECT zitadel.projections.lockout_policies.id,`+ + ` zitadel.projections.lockout_policies.sequence,`+ + ` zitadel.projections.lockout_policies.creation_date,`+ + ` zitadel.projections.lockout_policies.change_date,`+ + ` zitadel.projections.lockout_policies.resource_owner,`+ + ` zitadel.projections.lockout_policies.show_failure,`+ + ` zitadel.projections.lockout_policies.max_password_attempts,`+ + ` zitadel.projections.lockout_policies.is_default,`+ + ` zitadel.projections.lockout_policies.state`+ + ` FROM zitadel.projections.lockout_policies`), + nil, + nil, + ), + err: func(err error) (error, bool) { + if !errs.IsNotFound(err) { + return fmt.Errorf("err should be zitadel.NotFoundError got: %w", err), false + } + return nil, true + }, + }, + object: (*LockoutPolicy)(nil), + }, + { + name: "prepareLockoutPolicyQuery found", + prepare: prepareLockoutPolicyQuery, + want: want{ + sqlExpectations: mockQuery( + regexp.QuoteMeta(`SELECT zitadel.projections.lockout_policies.id,`+ + ` zitadel.projections.lockout_policies.sequence,`+ + ` zitadel.projections.lockout_policies.creation_date,`+ + ` zitadel.projections.lockout_policies.change_date,`+ + ` zitadel.projections.lockout_policies.resource_owner,`+ + ` zitadel.projections.lockout_policies.show_failure,`+ + ` zitadel.projections.lockout_policies.max_password_attempts,`+ + ` zitadel.projections.lockout_policies.is_default,`+ + ` zitadel.projections.lockout_policies.state`+ + ` FROM zitadel.projections.lockout_policies`), + []string{ + "id", + "sequence", + "creation_date", + "change_date", + "resource_owner", + "show_failure", + "max_password_attempts", + "is_default", + "state", + }, + []driver.Value{ + "pol-id", + uint64(20211109), + testNow, + testNow, + "ro", + true, + 20, + true, + domain.PolicyStateActive, + }, + ), + }, + object: &LockoutPolicy{ + ID: "pol-id", + CreationDate: testNow, + ChangeDate: testNow, + Sequence: 20211109, + ResourceOwner: "ro", + State: domain.PolicyStateActive, + ShowFailures: true, + MaxPasswordAttempts: 20, + IsDefault: true, + }, + }, + { + name: "prepareLockoutPolicyQuery sql err", + prepare: prepareLockoutPolicyQuery, + want: want{ + sqlExpectations: mockQueryErr( + regexp.QuoteMeta(`SELECT zitadel.projections.lockout_policies.id,`+ + ` zitadel.projections.lockout_policies.sequence,`+ + ` zitadel.projections.lockout_policies.creation_date,`+ + ` zitadel.projections.lockout_policies.change_date,`+ + ` zitadel.projections.lockout_policies.resource_owner,`+ + ` zitadel.projections.lockout_policies.show_failure,`+ + ` zitadel.projections.lockout_policies.max_password_attempts,`+ + ` zitadel.projections.lockout_policies.is_default,`+ + ` zitadel.projections.lockout_policies.state`+ + ` FROM zitadel.projections.lockout_policies`), + sql.ErrConnDone, + ), + err: func(err error) (error, bool) { + if !errors.Is(err, sql.ErrConnDone) { + return fmt.Errorf("err should be sql.ErrConnDone got: %w", err), false + } + return nil, true + }, + }, + object: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assertPrepare(t, tt.prepare, tt.object, tt.want.sqlExpectations, tt.want.err) + }) + } +} diff --git a/internal/query/org_iam_policy.go b/internal/query/org_iam_policy.go index a982c96de5..3f85efaaad 100644 --- a/internal/query/org_iam_policy.go +++ b/internal/query/org_iam_policy.go @@ -30,28 +30,36 @@ var ( name: projection.OrgIAMPolicyTable, } OrgIAMColID = Column{ - name: projection.OrgIAMPolicyIDCol, + name: projection.OrgIAMPolicyIDCol, + table: orgIAMTable, } OrgIAMColSequence = Column{ - name: projection.OrgIAMPolicySequenceCol, + name: projection.OrgIAMPolicySequenceCol, + table: orgIAMTable, } OrgIAMColCreationDate = Column{ - name: projection.OrgIAMPolicyCreationDateCol, + name: projection.OrgIAMPolicyCreationDateCol, + table: orgIAMTable, } OrgIAMColChangeDate = Column{ - name: projection.OrgIAMPolicyChangeDateCol, + name: projection.OrgIAMPolicyChangeDateCol, + table: orgIAMTable, } OrgIAMColResourceOwner = Column{ - name: projection.OrgIAMPolicyResourceOwnerCol, + name: projection.OrgIAMPolicyResourceOwnerCol, + table: orgIAMTable, } OrgIAMColUserLoginMustBeDomain = Column{ - name: projection.OrgIAMPolicyUserLoginMustBeDomainCol, + name: projection.OrgIAMPolicyUserLoginMustBeDomainCol, + table: orgIAMTable, } OrgIAMColIsDefault = Column{ - name: projection.OrgIAMPolicyIsDefaultCol, + name: projection.OrgIAMPolicyIsDefaultCol, + table: orgIAMTable, } OrgIAMColState = Column{ - name: projection.OrgIAMPolicyStateCol, + name: projection.OrgIAMPolicyStateCol, + table: orgIAMTable, } ) diff --git a/internal/query/org_iam_policy_test.go b/internal/query/org_iam_policy_test.go new file mode 100644 index 0000000000..bc0a596484 --- /dev/null +++ b/internal/query/org_iam_policy_test.go @@ -0,0 +1,130 @@ +package query + +import ( + "database/sql" + "database/sql/driver" + "errors" + "fmt" + "regexp" + "testing" + + "github.com/caos/zitadel/internal/domain" + errs "github.com/caos/zitadel/internal/errors" +) + +func Test_OrgIAMPolicyPrepares(t *testing.T) { + type want struct { + sqlExpectations sqlExpectation + err checkErr + } + tests := []struct { + name string + prepare interface{} + want want + object interface{} + }{ + { + name: "prepareOrgIAMPolicyQuery no result", + prepare: prepareOrgIAMPolicyQuery, + want: want{ + sqlExpectations: mockQueries( + regexp.QuoteMeta(`SELECT zitadel.projections.org_iam_policies.id,`+ + ` zitadel.projections.org_iam_policies.sequence,`+ + ` zitadel.projections.org_iam_policies.creation_date,`+ + ` zitadel.projections.org_iam_policies.change_date,`+ + ` zitadel.projections.org_iam_policies.resource_owner,`+ + ` zitadel.projections.org_iam_policies.user_login_must_be_domain,`+ + ` zitadel.projections.org_iam_policies.is_default,`+ + ` zitadel.projections.org_iam_policies.state`+ + ` FROM zitadel.projections.org_iam_policies`), + nil, + nil, + ), + err: func(err error) (error, bool) { + if !errs.IsNotFound(err) { + return fmt.Errorf("err should be zitadel.NotFoundError got: %w", err), false + } + return nil, true + }, + }, + object: (*OrgIAMPolicy)(nil), + }, + { + name: "prepareOrgIAMPolicyQuery found", + prepare: prepareOrgIAMPolicyQuery, + want: want{ + sqlExpectations: mockQuery( + regexp.QuoteMeta(`SELECT zitadel.projections.org_iam_policies.id,`+ + ` zitadel.projections.org_iam_policies.sequence,`+ + ` zitadel.projections.org_iam_policies.creation_date,`+ + ` zitadel.projections.org_iam_policies.change_date,`+ + ` zitadel.projections.org_iam_policies.resource_owner,`+ + ` zitadel.projections.org_iam_policies.user_login_must_be_domain,`+ + ` zitadel.projections.org_iam_policies.is_default,`+ + ` zitadel.projections.org_iam_policies.state`+ + ` FROM zitadel.projections.org_iam_policies`), + []string{ + "id", + "sequence", + "creation_date", + "change_date", + "resource_owner", + "user_login_must_be_domain", + "is_default", + "state", + }, + []driver.Value{ + "pol-id", + uint64(20211109), + testNow, + testNow, + "ro", + true, + true, + domain.PolicyStateActive, + }, + ), + }, + object: &OrgIAMPolicy{ + ID: "pol-id", + CreationDate: testNow, + ChangeDate: testNow, + Sequence: 20211109, + ResourceOwner: "ro", + State: domain.PolicyStateActive, + UserLoginMustBeDomain: true, + IsDefault: true, + }, + }, + { + name: "prepareOrgIAMPolicyQuery sql err", + prepare: prepareOrgIAMPolicyQuery, + want: want{ + sqlExpectations: mockQueryErr( + regexp.QuoteMeta(`SELECT zitadel.projections.org_iam_policies.id,`+ + ` zitadel.projections.org_iam_policies.sequence,`+ + ` zitadel.projections.org_iam_policies.creation_date,`+ + ` zitadel.projections.org_iam_policies.change_date,`+ + ` zitadel.projections.org_iam_policies.resource_owner,`+ + ` zitadel.projections.org_iam_policies.user_login_must_be_domain,`+ + ` zitadel.projections.org_iam_policies.is_default,`+ + ` zitadel.projections.org_iam_policies.state`+ + ` FROM zitadel.projections.org_iam_policies`), + sql.ErrConnDone, + ), + err: func(err error) (error, bool) { + if !errors.Is(err, sql.ErrConnDone) { + return fmt.Errorf("err should be sql.ErrConnDone got: %w", err), false + } + return nil, true + }, + }, + object: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assertPrepare(t, tt.prepare, tt.object, tt.want.sqlExpectations, tt.want.err) + }) + } +} diff --git a/internal/query/password_age_policy.go b/internal/query/password_age_policy.go index 62c32ffc36..adbf220036 100644 --- a/internal/query/password_age_policy.go +++ b/internal/query/password_age_policy.go @@ -31,31 +31,40 @@ var ( name: projection.PasswordAgeTable, } PasswordAgeColID = Column{ - name: projection.AgePolicyIDCol, + name: projection.AgePolicyIDCol, + table: passwordAgeTable, } PasswordAgeColSequence = Column{ - name: projection.AgePolicySequenceCol, + name: projection.AgePolicySequenceCol, + table: passwordAgeTable, } PasswordAgeColCreationDate = Column{ - name: projection.AgePolicyCreationDateCol, + name: projection.AgePolicyCreationDateCol, + table: passwordAgeTable, } PasswordAgeColChangeDate = Column{ - name: projection.AgePolicyChangeDateCol, + name: projection.AgePolicyChangeDateCol, + table: passwordAgeTable, } PasswordAgeColResourceOwner = Column{ - name: projection.AgePolicyResourceOwnerCol, + name: projection.AgePolicyResourceOwnerCol, + table: passwordAgeTable, } PasswordAgeColWarnDays = Column{ - name: projection.AgePolicyExpireWarnDaysCol, + name: projection.AgePolicyExpireWarnDaysCol, + table: passwordAgeTable, } PasswordAgeColMaxAge = Column{ - name: projection.AgePolicyMaxAgeDaysCol, + name: projection.AgePolicyMaxAgeDaysCol, + table: passwordAgeTable, } PasswordAgeColIsDefault = Column{ - name: projection.AgePolicyIsDefaultCol, + name: projection.AgePolicyIsDefaultCol, + table: passwordAgeTable, } PasswordAgeColState = Column{ - name: projection.AgePolicyStateCol, + name: projection.AgePolicyStateCol, + table: passwordAgeTable, } ) diff --git a/internal/query/password_age_policy_test.go b/internal/query/password_age_policy_test.go new file mode 100644 index 0000000000..d0dad615c3 --- /dev/null +++ b/internal/query/password_age_policy_test.go @@ -0,0 +1,136 @@ +package query + +import ( + "database/sql" + "database/sql/driver" + "errors" + "fmt" + "regexp" + "testing" + + "github.com/caos/zitadel/internal/domain" + errs "github.com/caos/zitadel/internal/errors" +) + +func Test_PasswordAgePolicyPrepares(t *testing.T) { + type want struct { + sqlExpectations sqlExpectation + err checkErr + } + tests := []struct { + name string + prepare interface{} + want want + object interface{} + }{ + { + name: "preparePasswordAgePolicyQuery no result", + prepare: preparePasswordAgePolicyQuery, + want: want{ + sqlExpectations: mockQueries( + regexp.QuoteMeta(`SELECT zitadel.projections.password_age_policies.id,`+ + ` zitadel.projections.password_age_policies.sequence,`+ + ` zitadel.projections.password_age_policies.creation_date,`+ + ` zitadel.projections.password_age_policies.change_date,`+ + ` zitadel.projections.password_age_policies.resource_owner,`+ + ` zitadel.projections.password_age_policies.expire_warn_days,`+ + ` zitadel.projections.password_age_policies.max_age_days,`+ + ` zitadel.projections.password_age_policies.is_default,`+ + ` zitadel.projections.password_age_policies.state`+ + ` FROM zitadel.projections.password_age_policies`), + nil, + nil, + ), + err: func(err error) (error, bool) { + if !errs.IsNotFound(err) { + return fmt.Errorf("err should be zitadel.NotFoundError got: %w", err), false + } + return nil, true + }, + }, + object: (*PasswordAgePolicy)(nil), + }, + { + name: "preparePasswordAgePolicyQuery found", + prepare: preparePasswordAgePolicyQuery, + want: want{ + sqlExpectations: mockQuery( + regexp.QuoteMeta(`SELECT zitadel.projections.password_age_policies.id,`+ + ` zitadel.projections.password_age_policies.sequence,`+ + ` zitadel.projections.password_age_policies.creation_date,`+ + ` zitadel.projections.password_age_policies.change_date,`+ + ` zitadel.projections.password_age_policies.resource_owner,`+ + ` zitadel.projections.password_age_policies.expire_warn_days,`+ + ` zitadel.projections.password_age_policies.max_age_days,`+ + ` zitadel.projections.password_age_policies.is_default,`+ + ` zitadel.projections.password_age_policies.state`+ + ` FROM zitadel.projections.password_age_policies`), + []string{ + "id", + "sequence", + "creation_date", + "change_date", + "resource_owner", + "expire_warn_days", + "max_age_days", + "is_default", + "state", + }, + []driver.Value{ + "pol-id", + uint64(20211109), + testNow, + testNow, + "ro", + 10, + 20, + true, + domain.PolicyStateActive, + }, + ), + }, + object: &PasswordAgePolicy{ + ID: "pol-id", + CreationDate: testNow, + ChangeDate: testNow, + Sequence: 20211109, + ResourceOwner: "ro", + State: domain.PolicyStateActive, + ExpireWarnDays: 10, + MaxAgeDays: 20, + IsDefault: true, + }, + }, + { + name: "preparePasswordAgePolicyQuery sql err", + prepare: preparePasswordAgePolicyQuery, + want: want{ + sqlExpectations: mockQueryErr( + regexp.QuoteMeta(`SELECT zitadel.projections.password_age_policies.id,`+ + ` zitadel.projections.password_age_policies.sequence,`+ + ` zitadel.projections.password_age_policies.creation_date,`+ + ` zitadel.projections.password_age_policies.change_date,`+ + ` zitadel.projections.password_age_policies.resource_owner,`+ + ` zitadel.projections.password_age_policies.expire_warn_days,`+ + ` zitadel.projections.password_age_policies.max_age_days,`+ + ` zitadel.projections.password_age_policies.is_default,`+ + ` zitadel.projections.password_age_policies.state`+ + ` FROM zitadel.projections.password_age_policies`), + sql.ErrConnDone, + ), + err: func(err error) (error, bool) { + if !errors.Is(err, sql.ErrConnDone) { + return fmt.Errorf("err should be sql.ErrConnDone got: %w", err), false + } + return nil, true + }, + }, + object: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assertPrepare(t, tt.prepare, tt.object, tt.want.sqlExpectations, tt.want.err) + }) + } +} diff --git a/internal/query/password_complexity_policy.go b/internal/query/password_complexity_policy.go index 1fde884a6f..409370b2b5 100644 --- a/internal/query/password_complexity_policy.go +++ b/internal/query/password_complexity_policy.go @@ -70,40 +70,52 @@ var ( name: projection.PasswordComplexityTable, } PasswordComplexityColID = Column{ - name: projection.ComplexityPolicyIDCol, + name: projection.ComplexityPolicyIDCol, + table: passwordComplexityTable, } PasswordComplexityColSequence = Column{ - name: projection.ComplexityPolicySequenceCol, + name: projection.ComplexityPolicySequenceCol, + table: passwordComplexityTable, } PasswordComplexityColCreationDate = Column{ - name: projection.ComplexityPolicyCreationDateCol, + name: projection.ComplexityPolicyCreationDateCol, + table: passwordComplexityTable, } PasswordComplexityColChangeDate = Column{ - name: projection.ComplexityPolicyChangeDateCol, + name: projection.ComplexityPolicyChangeDateCol, + table: passwordComplexityTable, } PasswordComplexityColResourceOwner = Column{ - name: projection.ComplexityPolicyResourceOwnerCol, + name: projection.ComplexityPolicyResourceOwnerCol, + table: passwordComplexityTable, } PasswordComplexityColMinLength = Column{ - name: projection.ComplexityPolicyMinLengthCol, + name: projection.ComplexityPolicyMinLengthCol, + table: passwordComplexityTable, } PasswordComplexityColHasLowercase = Column{ - name: projection.ComplexityPolicyHasLowercaseCol, + name: projection.ComplexityPolicyHasLowercaseCol, + table: passwordComplexityTable, } PasswordComplexityColHasUpperCase = Column{ - name: projection.ComplexityPolicyHasUppercaseCol, + name: projection.ComplexityPolicyHasUppercaseCol, + table: passwordComplexityTable, } PasswordComplexityColHasNumber = Column{ - name: projection.ComplexityPolicyHasNumberCol, + name: projection.ComplexityPolicyHasNumberCol, + table: passwordComplexityTable, } PasswordComplexityColHasSymbol = Column{ - name: projection.ComplexityPolicyHasSymbolCol, + name: projection.ComplexityPolicyHasSymbolCol, + table: passwordComplexityTable, } PasswordComplexityColIsDefault = Column{ - name: projection.ComplexityPolicyIsDefaultCol, + name: projection.ComplexityPolicyIsDefaultCol, + table: passwordComplexityTable, } PasswordComplexityColState = Column{ - name: projection.ComplexityPolicyStateCol, + name: projection.ComplexityPolicyStateCol, + table: passwordComplexityTable, } ) diff --git a/internal/query/password_complexity_policy_test.go b/internal/query/password_complexity_policy_test.go new file mode 100644 index 0000000000..55ebfd1b94 --- /dev/null +++ b/internal/query/password_complexity_policy_test.go @@ -0,0 +1,154 @@ +package query + +import ( + "database/sql" + "database/sql/driver" + "errors" + "fmt" + "regexp" + "testing" + + "github.com/caos/zitadel/internal/domain" + errs "github.com/caos/zitadel/internal/errors" +) + +func Test_PasswordComplexityPolicyPrepares(t *testing.T) { + type want struct { + sqlExpectations sqlExpectation + err checkErr + } + tests := []struct { + name string + prepare interface{} + want want + object interface{} + }{ + { + name: "preparePasswordComplexityPolicyQuery no result", + prepare: preparePasswordComplexityPolicyQuery, + want: want{ + sqlExpectations: mockQueries( + regexp.QuoteMeta(`SELECT zitadel.projections.password_complexity_policies.id,`+ + ` zitadel.projections.password_complexity_policies.sequence,`+ + ` zitadel.projections.password_complexity_policies.creation_date,`+ + ` zitadel.projections.password_complexity_policies.change_date,`+ + ` zitadel.projections.password_complexity_policies.resource_owner,`+ + ` zitadel.projections.password_complexity_policies.min_length,`+ + ` zitadel.projections.password_complexity_policies.has_lowercase,`+ + ` zitadel.projections.password_complexity_policies.has_uppercase,`+ + ` zitadel.projections.password_complexity_policies.has_number,`+ + ` zitadel.projections.password_complexity_policies.has_symbol,`+ + ` zitadel.projections.password_complexity_policies.is_default,`+ + ` zitadel.projections.password_complexity_policies.state`+ + ` FROM zitadel.projections.password_complexity_policies`), + nil, + nil, + ), + err: func(err error) (error, bool) { + if !errs.IsNotFound(err) { + return fmt.Errorf("err should be zitadel.NotFoundError got: %w", err), false + } + return nil, true + }, + }, + object: (*PasswordComplexityPolicy)(nil), + }, + { + name: "preparePasswordComplexityPolicyQuery found", + prepare: preparePasswordComplexityPolicyQuery, + want: want{ + sqlExpectations: mockQuery( + regexp.QuoteMeta(`SELECT zitadel.projections.password_complexity_policies.id,`+ + ` zitadel.projections.password_complexity_policies.sequence,`+ + ` zitadel.projections.password_complexity_policies.creation_date,`+ + ` zitadel.projections.password_complexity_policies.change_date,`+ + ` zitadel.projections.password_complexity_policies.resource_owner,`+ + ` zitadel.projections.password_complexity_policies.min_length,`+ + ` zitadel.projections.password_complexity_policies.has_lowercase,`+ + ` zitadel.projections.password_complexity_policies.has_uppercase,`+ + ` zitadel.projections.password_complexity_policies.has_number,`+ + ` zitadel.projections.password_complexity_policies.has_symbol,`+ + ` zitadel.projections.password_complexity_policies.is_default,`+ + ` zitadel.projections.password_complexity_policies.state`+ + ` FROM zitadel.projections.password_complexity_policies`), + []string{ + "id", + "sequence", + "creation_date", + "change_date", + "resource_owner", + "min_length", + "has_lowercase", + "has_uppercase", + "has_number", + "has_symbol", + "is_default", + "state", + }, + []driver.Value{ + "pol-id", + uint64(20211109), + testNow, + testNow, + "ro", + 8, + true, + true, + true, + true, + true, + domain.PolicyStateActive, + }, + ), + }, + object: &PasswordComplexityPolicy{ + ID: "pol-id", + CreationDate: testNow, + ChangeDate: testNow, + Sequence: 20211109, + ResourceOwner: "ro", + State: domain.PolicyStateActive, + MinLength: 8, + HasLowercase: true, + HasUppercase: true, + HasNumber: true, + HasSymbol: true, + IsDefault: true, + }, + }, + { + name: "preparePasswordComplexityPolicyQuery sql err", + prepare: preparePasswordComplexityPolicyQuery, + want: want{ + sqlExpectations: mockQueryErr( + regexp.QuoteMeta(`SELECT zitadel.projections.password_complexity_policies.id,`+ + ` zitadel.projections.password_complexity_policies.sequence,`+ + ` zitadel.projections.password_complexity_policies.creation_date,`+ + ` zitadel.projections.password_complexity_policies.change_date,`+ + ` zitadel.projections.password_complexity_policies.resource_owner,`+ + ` zitadel.projections.password_complexity_policies.min_length,`+ + ` zitadel.projections.password_complexity_policies.has_lowercase,`+ + ` zitadel.projections.password_complexity_policies.has_uppercase,`+ + ` zitadel.projections.password_complexity_policies.has_number,`+ + ` zitadel.projections.password_complexity_policies.has_symbol,`+ + ` zitadel.projections.password_complexity_policies.is_default,`+ + ` zitadel.projections.password_complexity_policies.state`+ + ` FROM zitadel.projections.password_complexity_policies`), + sql.ErrConnDone, + ), + err: func(err error) (error, bool) { + if !errors.Is(err, sql.ErrConnDone) { + return fmt.Errorf("err should be sql.ErrConnDone got: %w", err), false + } + return nil, true + }, + }, + object: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assertPrepare(t, tt.prepare, tt.object, tt.want.sqlExpectations, tt.want.err) + }) + } +} diff --git a/internal/query/privacy_policy.go b/internal/query/privacy_policy.go index 8791464a52..e21054e6b4 100644 --- a/internal/query/privacy_policy.go +++ b/internal/query/privacy_policy.go @@ -31,31 +31,40 @@ var ( name: projection.PrivacyPolicyTable, } PrivacyColID = Column{ - name: projection.PrivacyPolicyIDCol, + name: projection.PrivacyPolicyIDCol, + table: privacyTable, } PrivacyColSequence = Column{ - name: projection.PrivacyPolicySequenceCol, + name: projection.PrivacyPolicySequenceCol, + table: privacyTable, } PrivacyColCreationDate = Column{ - name: projection.PrivacyPolicyCreationDateCol, + name: projection.PrivacyPolicyCreationDateCol, + table: privacyTable, } PrivacyColChangeDate = Column{ - name: projection.PrivacyPolicyChangeDateCol, + name: projection.PrivacyPolicyChangeDateCol, + table: privacyTable, } PrivacyColResourceOwner = Column{ - name: projection.PrivacyPolicyResourceOwnerCol, + name: projection.PrivacyPolicyResourceOwnerCol, + table: privacyTable, } PrivacyColPrivacyLink = Column{ - name: projection.PrivacyPolicyPrivacyLinkCol, + name: projection.PrivacyPolicyPrivacyLinkCol, + table: privacyTable, } PrivacyColTOSLink = Column{ - name: projection.PrivacyPolicyTOSLinkCol, + name: projection.PrivacyPolicyTOSLinkCol, + table: privacyTable, } PrivacyColIsDefault = Column{ - name: projection.PrivacyPolicyIsDefaultCol, + name: projection.PrivacyPolicyIsDefaultCol, + table: privacyTable, } PrivacyColState = Column{ - name: projection.PrivacyPolicyStateCol, + name: projection.PrivacyPolicyStateCol, + table: privacyTable, } ) diff --git a/internal/query/privacy_policy_test.go b/internal/query/privacy_policy_test.go new file mode 100644 index 0000000000..0bbeaa052c --- /dev/null +++ b/internal/query/privacy_policy_test.go @@ -0,0 +1,136 @@ +package query + +import ( + "database/sql" + "database/sql/driver" + "errors" + "fmt" + "regexp" + "testing" + + "github.com/caos/zitadel/internal/domain" + errs "github.com/caos/zitadel/internal/errors" +) + +func Test_PrivacyPolicyPrepares(t *testing.T) { + type want struct { + sqlExpectations sqlExpectation + err checkErr + } + tests := []struct { + name string + prepare interface{} + want want + object interface{} + }{ + { + name: "preparePrivacyPolicyQuery no result", + prepare: preparePrivacyPolicyQuery, + want: want{ + sqlExpectations: mockQueries( + regexp.QuoteMeta(`SELECT zitadel.projections.privacy_policies.id,`+ + ` zitadel.projections.privacy_policies.sequence,`+ + ` zitadel.projections.privacy_policies.creation_date,`+ + ` zitadel.projections.privacy_policies.change_date,`+ + ` zitadel.projections.privacy_policies.resource_owner,`+ + ` zitadel.projections.privacy_policies.privacy_link,`+ + ` zitadel.projections.privacy_policies.tos_link,`+ + ` zitadel.projections.privacy_policies.is_default,`+ + ` zitadel.projections.privacy_policies.state`+ + ` FROM zitadel.projections.privacy_policies`), + nil, + nil, + ), + err: func(err error) (error, bool) { + if !errs.IsNotFound(err) { + return fmt.Errorf("err should be zitadel.NotFoundError got: %w", err), false + } + return nil, true + }, + }, + object: (*PrivacyPolicy)(nil), + }, + { + name: "preparePrivacyPolicyQuery found", + prepare: preparePrivacyPolicyQuery, + want: want{ + sqlExpectations: mockQuery( + regexp.QuoteMeta(`SELECT zitadel.projections.privacy_policies.id,`+ + ` zitadel.projections.privacy_policies.sequence,`+ + ` zitadel.projections.privacy_policies.creation_date,`+ + ` zitadel.projections.privacy_policies.change_date,`+ + ` zitadel.projections.privacy_policies.resource_owner,`+ + ` zitadel.projections.privacy_policies.privacy_link,`+ + ` zitadel.projections.privacy_policies.tos_link,`+ + ` zitadel.projections.privacy_policies.is_default,`+ + ` zitadel.projections.privacy_policies.state`+ + ` FROM zitadel.projections.privacy_policies`), + []string{ + "id", + "sequence", + "creation_date", + "change_date", + "resource_owner", + "privacy_link", + "tos_link", + "is_default", + "state", + }, + []driver.Value{ + "pol-id", + uint64(20211109), + testNow, + testNow, + "ro", + "privacy.ch", + "tos.ch", + true, + domain.PolicyStateActive, + }, + ), + }, + object: &PrivacyPolicy{ + ID: "pol-id", + CreationDate: testNow, + ChangeDate: testNow, + Sequence: 20211109, + ResourceOwner: "ro", + State: domain.PolicyStateActive, + PrivacyLink: "privacy.ch", + TOSLink: "tos.ch", + IsDefault: true, + }, + }, + { + name: "preparePrivacyPolicyQuery sql err", + prepare: preparePrivacyPolicyQuery, + want: want{ + sqlExpectations: mockQueryErr( + regexp.QuoteMeta(`SELECT zitadel.projections.privacy_policies.id,`+ + ` zitadel.projections.privacy_policies.sequence,`+ + ` zitadel.projections.privacy_policies.creation_date,`+ + ` zitadel.projections.privacy_policies.change_date,`+ + ` zitadel.projections.privacy_policies.resource_owner,`+ + ` zitadel.projections.privacy_policies.privacy_link,`+ + ` zitadel.projections.privacy_policies.tos_link,`+ + ` zitadel.projections.privacy_policies.is_default,`+ + ` zitadel.projections.privacy_policies.state`+ + ` FROM zitadel.projections.privacy_policies`), + sql.ErrConnDone, + ), + err: func(err error) (error, bool) { + if !errors.Is(err, sql.ErrConnDone) { + return fmt.Errorf("err should be sql.ErrConnDone got: %w", err), false + } + return nil, true + }, + }, + object: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assertPrepare(t, tt.prepare, tt.object, tt.want.sqlExpectations, tt.want.err) + }) + } +}