From c83e90ed38c8229b202c794da18cbac635ff78cb Mon Sep 17 00:00:00 2001 From: Jim Date: Fri, 17 Jul 2020 16:20:56 -0400 Subject: [PATCH] implement SetTableName patttern that allows table name to be set back to the default for the storage type. (#196) --- internal/authtoken/gorm.go | 12 ++- internal/authtoken/gorm_test.go | 45 ++++++++ internal/db/db_test/db.go | 35 ++++-- internal/host/static/gorm.go | 47 +++++--- internal/host/static/gorm_test.go | 159 ++++++++++++++++++++++++++++ internal/iam/auth_account.go | 15 ++- internal/iam/auth_account_test.go | 39 +++++++ internal/iam/group.go | 15 ++- internal/iam/group_member_test.go | 74 +++++++++++++ internal/iam/group_test.go | 37 +++++++ internal/iam/principal_role_test.go | 110 +++++++++++++++++++ internal/iam/role.go | 15 ++- internal/iam/role_grant.go | 4 +- internal/iam/role_grant_test.go | 36 +++++++ internal/iam/role_test.go | 37 +++++++ internal/iam/scope.go | 15 ++- internal/iam/scope_test.go | 36 +++++++ internal/iam/user.go | 15 ++- internal/iam/user_test.go | 37 +++++++ internal/oplog/oplog_test/db.go | 31 ++++-- 20 files changed, 768 insertions(+), 46 deletions(-) create mode 100644 internal/authtoken/gorm_test.go create mode 100644 internal/host/static/gorm_test.go diff --git a/internal/authtoken/gorm.go b/internal/authtoken/gorm.go index 1f68184b3f..4b4343b4bc 100644 --- a/internal/authtoken/gorm.go +++ b/internal/authtoken/gorm.go @@ -1,16 +1,22 @@ package authtoken +const defaultAuthTokenTableName = "auth_token" + // TableName returns the table name for the auth token. func (s *AuthToken) TableName() string { if s.tableName != "" { return s.tableName } - return "auth_token" + return defaultAuthTokenTableName } -// SetTableName sets the table name. +// SetTableName sets the table name. If the caller attempts to +// set the name to "" the name will be reset to the default name. func (s *AuthToken) SetTableName(n string) { - if n != "" { + switch n { + case "": + s.tableName = defaultAuthTokenTableName + default: s.tableName = n } } diff --git a/internal/authtoken/gorm_test.go b/internal/authtoken/gorm_test.go new file mode 100644 index 0000000000..3205650660 --- /dev/null +++ b/internal/authtoken/gorm_test.go @@ -0,0 +1,45 @@ +package authtoken + +import ( + "testing" + + "github.com/hashicorp/watchtower/internal/authtoken/store" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestAuthToken_SetTableName(t *testing.T) { + defaultTableName := defaultAuthTokenTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := allocAuthToken() + require.Equal(defaultTableName, def.TableName()) + s := &AuthToken{ + AuthToken: &store.AuthToken{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} diff --git a/internal/db/db_test/db.go b/internal/db/db_test/db.go index 34cf0489de..a21f44eb8d 100644 --- a/internal/db/db_test/db.go +++ b/internal/db/db_test/db.go @@ -6,6 +6,13 @@ import ( "google.golang.org/protobuf/proto" ) +const ( + defaultUserTablename = "db_test_user" + defaultCarTableName = "db_test_car" + defaultRentalTableName = "db_test_rental" + defaultScooterTableName = "db_test_scooter" +) + type TestUser struct { *StoreTestUser table string `gorm:"-"` @@ -40,11 +47,14 @@ func (u *TestUser) TableName() string { if u.table != "" { return u.table } - return "db_test_user" + return defaultUserTablename } func (u *TestUser) SetTableName(name string) { - if name != "" { + switch name { + case "": + u.table = defaultUserTablename + default: u.table = name } } @@ -71,10 +81,13 @@ func (c *TestCar) TableName() string { return c.table } - return "db_test_car" + return defaultCarTableName } func (c *TestCar) SetTableName(name string) { - if name != "" { + switch name { + case "": + c.table = defaultCarTableName + default: c.table = name } } @@ -100,10 +113,13 @@ func (r *TestRental) TableName() string { return r.table } - return "db_test_rental" + return defaultRentalTableName } func (r *TestRental) SetTableName(name string) { - if name != "" { + switch name { + case "": + r.table = defaultRentalTableName + default: r.table = name } } @@ -135,11 +151,14 @@ func (t *TestScooter) TableName() string { if t.table != "" { return t.table } - return "db_test_scooter" + return defaultScooterTableName } func (t *TestScooter) SetTableName(name string) { - if name != "" { + switch name { + case "": + t.table = defaultScooterTableName + default: t.table = name } } diff --git a/internal/host/static/gorm.go b/internal/host/static/gorm.go index c4ba617385..d661f50ef7 100644 --- a/internal/host/static/gorm.go +++ b/internal/host/static/gorm.go @@ -1,16 +1,27 @@ package static +const ( + defaultHostCatalogTableName = "static_host_catalog" + defaultHostTableName = "static_host" + defaultHostSetTableName = "static_host_set" + defaultHostSetMemberTableName = "static_host_set_member" +) + // TableName returns the table name for the host catalog. func (c *HostCatalog) TableName() string { if c.tableName != "" { return c.tableName } - return "static_host_catalog" + return defaultHostCatalogTableName } -// SetTableName sets the table name. +// SetTableName sets the table name. If the caller attempts to +// set the name to "" the name will be reset to the default name. func (c *HostCatalog) SetTableName(n string) { - if n != "" { + switch n { + case "": + c.tableName = defaultHostCatalogTableName + default: c.tableName = n } } @@ -20,12 +31,16 @@ func (h *Host) TableName() string { if h.tableName != "" { return h.tableName } - return "static_host" + return defaultHostTableName } -// SetTableName sets the table name. +// SetTableName sets the table name. If the caller attempts to +// set the name to "" the name will be reset to the default name. func (h *Host) SetTableName(n string) { - if n != "" { + switch n { + case "": + h.tableName = defaultHostTableName + default: h.tableName = n } } @@ -35,12 +50,16 @@ func (s *HostSet) TableName() string { if s.tableName != "" { return s.tableName } - return "static_host_set" + return defaultHostSetTableName } -// SetTableName sets the table name. +// SetTableName sets the table name. If the caller attempts to +// set the name to "" the name will be reset to the default name. func (s *HostSet) SetTableName(n string) { - if n != "" { + switch n { + case "": + s.tableName = defaultHostSetTableName + default: s.tableName = n } } @@ -50,12 +69,16 @@ func (m *HostSetMember) TableName() string { if m.tableName != "" { return m.tableName } - return "static_host_set_member" + return defaultHostSetMemberTableName } -// SetTableName sets the table name. +// SetTableName sets the table name. If the caller attempts to +// set the name to "" the name will be reset to the default name. func (m *HostSetMember) SetTableName(n string) { - if n != "" { + switch n { + case "": + m.tableName = defaultHostSetMemberTableName + default: m.tableName = n } } diff --git a/internal/host/static/gorm_test.go b/internal/host/static/gorm_test.go new file mode 100644 index 0000000000..6d07139ff5 --- /dev/null +++ b/internal/host/static/gorm_test.go @@ -0,0 +1,159 @@ +package static + +import ( + "testing" + + "github.com/hashicorp/watchtower/internal/host/static/store" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestHostCatalog_SetTableName(t *testing.T) { + defaultTableName := defaultHostCatalogTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := allocCatalog() + require.Equal(defaultTableName, def.TableName()) + s := &HostCatalog{ + HostCatalog: &store.HostCatalog{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} + +func TestHost_SetTableName(t *testing.T) { + defaultTableName := defaultHostTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := &Host{ + Host: &store.Host{}, + } + require.Equal(defaultTableName, def.TableName()) + s := &Host{ + Host: &store.Host{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} + +func TestHostSet_SetTableName(t *testing.T) { + defaultTableName := defaultHostSetTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := &HostSet{ + HostSet: &store.HostSet{}, + } + require.Equal(defaultTableName, def.TableName()) + s := &HostSet{ + HostSet: &store.HostSet{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} + +func TestHostSetMember_SetTableName(t *testing.T) { + defaultTableName := defaultHostSetMemberTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := &HostSetMember{ + HostSetMember: &store.HostSetMember{}, + } + require.Equal(defaultTableName, def.TableName()) + s := &HostSetMember{ + HostSetMember: &store.HostSetMember{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} diff --git a/internal/iam/auth_account.go b/internal/iam/auth_account.go index b59f38b232..0c7328c2e0 100644 --- a/internal/iam/auth_account.go +++ b/internal/iam/auth_account.go @@ -11,6 +11,10 @@ import ( "google.golang.org/protobuf/proto" ) +const ( + defaultAuthAccountTableName = "auth_account" +) + // AuthAccount is from the auth subsystem and iam is only allowed to: lookup and // update auth accounts. That's why there is no "new" factory for AuthAccounts. type AuthAccount struct { @@ -61,12 +65,17 @@ func (a *AuthAccount) TableName() string { if a.tableName != "" { return a.tableName } - return "auth_account" + return defaultAuthAccountTableName } -// SetTableName sets the tablename and satisfies the ReplayableMessage interface. +// SetTableName sets the tablename and satisfies the ReplayableMessage +// interface. If the caller attempts to set the name to "" the name will be +// reset to the default name. func (a *AuthAccount) SetTableName(n string) { - if n != "" { + switch n { + case "": + a.tableName = defaultAuthAccountTableName + default: a.tableName = n } } diff --git a/internal/iam/auth_account_test.go b/internal/iam/auth_account_test.go index 101ff7d983..2136476380 100644 --- a/internal/iam/auth_account_test.go +++ b/internal/iam/auth_account_test.go @@ -6,6 +6,7 @@ import ( "github.com/hashicorp/watchtower/internal/db" dbassert "github.com/hashicorp/watchtower/internal/db/assert" + "github.com/hashicorp/watchtower/internal/iam/store" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "google.golang.org/protobuf/proto" @@ -83,3 +84,41 @@ func TestAuthAccount_Clone(t *testing.T) { assert.True(!proto.Equal(cp.(*AuthAccount).AuthAccount, acct2.AuthAccount)) }) } + +func TestAuthAccount_SetTableName(t *testing.T) { + defaultTableName := defaultAuthAccountTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := &AuthAccount{ + AuthAccount: &store.AuthAccount{}, + } + require.Equal(defaultTableName, def.TableName()) + s := &AuthAccount{ + AuthAccount: &store.AuthAccount{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} diff --git a/internal/iam/group.go b/internal/iam/group.go index 59e492cc54..5896090240 100644 --- a/internal/iam/group.go +++ b/internal/iam/group.go @@ -12,6 +12,10 @@ import ( "google.golang.org/protobuf/proto" ) +const ( + defaultGroupTableName = "iam_group" +) + // Group is made up of principals which are scoped to an org. type Group struct { *store.Group @@ -88,12 +92,17 @@ func (g *Group) TableName() string { if g.tableName != "" { return g.tableName } - return "iam_group" + return defaultGroupTableName } -// SetTableName sets the tablename and satisfies the ReplayableMessage interface. +// SetTableName sets the tablename and satisfies the ReplayableMessage +// interface. If the caller attempts to set the name to "" the name will be +// reset to the default name. func (g *Group) SetTableName(n string) { - if n != "" { + switch n { + case "": + g.tableName = defaultGroupTableName + default: g.tableName = n } } diff --git a/internal/iam/group_member_test.go b/internal/iam/group_member_test.go index e6a60f07c4..8cbfd76549 100644 --- a/internal/iam/group_member_test.go +++ b/internal/iam/group_member_test.go @@ -352,3 +352,77 @@ func TestGroupMember_Clone(t *testing.T) { assert.True(!proto.Equal(cp.(*GroupMemberUser).GroupMemberUser, gm2.GroupMemberUser)) }) } + +func TestGroupMember_SetTableName(t *testing.T) { + defaultTableName := groupMemberViewDefaultTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := &GroupMember{ + GroupMemberView: &store.GroupMemberView{}, + } + require.Equal(defaultTableName, def.TableName()) + s := &GroupMember{ + GroupMemberView: &store.GroupMemberView{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} + +func TestGroupMemberUser_SetTableName(t *testing.T) { + defaultTableName := groupMemberUserDefaultTable + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := allocGroupMember() + require.Equal(defaultTableName, def.TableName()) + s := &GroupMemberUser{ + GroupMemberUser: &store.GroupMemberUser{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} diff --git a/internal/iam/group_test.go b/internal/iam/group_test.go index a9caaf3ad4..f60891fa14 100644 --- a/internal/iam/group_test.go +++ b/internal/iam/group_test.go @@ -8,6 +8,7 @@ import ( "github.com/hashicorp/watchtower/internal/db" dbassert "github.com/hashicorp/watchtower/internal/db/assert" + "github.com/hashicorp/watchtower/internal/iam/store" "github.com/hashicorp/watchtower/internal/oplog" "github.com/hashicorp/watchtower/internal/types/action" "github.com/hashicorp/watchtower/internal/types/resource" @@ -483,3 +484,39 @@ func TestGroup_Clone(t *testing.T) { assert.True(!proto.Equal(cp.(*Group).Group, grp2.Group)) }) } + +func TestGroup_SetTableName(t *testing.T) { + defaultTableName := defaultGroupTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := allocGroup() + require.Equal(defaultTableName, def.TableName()) + s := &Group{ + Group: &store.Group{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} diff --git a/internal/iam/principal_role_test.go b/internal/iam/principal_role_test.go index df6dbd769e..3531591c53 100644 --- a/internal/iam/principal_role_test.go +++ b/internal/iam/principal_role_test.go @@ -739,3 +739,113 @@ func TestGroupRole_Clone(t *testing.T) { assert.True(!proto.Equal(cp.(*GroupRole).GroupRole, grpRole2.GroupRole)) }) } + +func TestPrincipalRole_SetTableName(t *testing.T) { + defaultTableName := principalRoleViewDefaultTable + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := &PrincipalRole{ + PrincipalRoleView: &store.PrincipalRoleView{}, + } + require.Equal(defaultTableName, def.TableName()) + s := &PrincipalRole{ + PrincipalRoleView: &store.PrincipalRoleView{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} + +func TestUserRole_SetTableName(t *testing.T) { + defaultTableName := userRoleDefaultTable + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := allocUserRole() + require.Equal(defaultTableName, def.TableName()) + s := &UserRole{ + UserRole: &store.UserRole{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} + +func TestGroupRole_SetTableName(t *testing.T) { + defaultTableName := groupRoleDefaultTable + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := allocGroupRole() + require.Equal(defaultTableName, def.TableName()) + s := &GroupRole{ + GroupRole: &store.GroupRole{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} diff --git a/internal/iam/role.go b/internal/iam/role.go index 95d9d94fed..f272b5dd84 100644 --- a/internal/iam/role.go +++ b/internal/iam/role.go @@ -13,6 +13,10 @@ import ( "google.golang.org/protobuf/proto" ) +const ( + defaultRoleTableName = "iam_role" +) + // Roles are granted permissions and assignable to Users and Groups. type Role struct { *store.Role @@ -96,12 +100,17 @@ func (r *Role) TableName() string { if r.tableName != "" { return r.tableName } - return "iam_role" + return defaultRoleTableName } -// SetTableName sets the tablename and satisfies the ReplayableMessage interface. +// SetTableName sets the tablename and satisfies the ReplayableMessage +// interface. If the caller attempts to set the name to "" the name will be +// reset to the default name. func (r *Role) SetTableName(n string) { - if n != "" { + switch n { + case "": + r.tableName = defaultRoleTableName + default: r.tableName = n } } diff --git a/internal/iam/role_grant.go b/internal/iam/role_grant.go index 6efc8104db..35155a875f 100644 --- a/internal/iam/role_grant.go +++ b/internal/iam/role_grant.go @@ -98,7 +98,9 @@ func (g *RoleGrant) TableName() string { return defaultRoleGrantTable } -// SetTableName sets the tablename and satisfies the ReplayableMessage interface +// SetTableName sets the tablename and satisfies the ReplayableMessage +// interface. If the caller attempts to set the name to "" the name will be +// reset to the default name. func (g *RoleGrant) SetTableName(n string) { switch n { case "": diff --git a/internal/iam/role_grant_test.go b/internal/iam/role_grant_test.go index 4c1ddfefe1..3a8d495069 100644 --- a/internal/iam/role_grant_test.go +++ b/internal/iam/role_grant_test.go @@ -261,3 +261,39 @@ func TestRoleGrant_Clone(t *testing.T) { assert.True(!proto.Equal(cp.(*RoleGrant).RoleGrant, g2.RoleGrant)) }) } + +func TestRoleGrant_SetTableName(t *testing.T) { + defaultTableName := defaultRoleGrantTable + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := allocRoleGrant() + require.Equal(defaultTableName, def.TableName()) + s := &RoleGrant{ + RoleGrant: &store.RoleGrant{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} diff --git a/internal/iam/role_test.go b/internal/iam/role_test.go index d25db18e25..08f48cf56d 100644 --- a/internal/iam/role_test.go +++ b/internal/iam/role_test.go @@ -8,6 +8,7 @@ import ( "github.com/hashicorp/watchtower/internal/db" dbassert "github.com/hashicorp/watchtower/internal/db/assert" + "github.com/hashicorp/watchtower/internal/iam/store" "github.com/hashicorp/watchtower/internal/oplog" "github.com/hashicorp/watchtower/internal/types/action" "github.com/hashicorp/watchtower/internal/types/resource" @@ -586,3 +587,39 @@ func TestRole_Clone(t *testing.T) { assert.True(!proto.Equal(cp.(*Role).Role, role2.Role)) }) } + +func TestRole_SetTableName(t *testing.T) { + defaultTableName := defaultRoleTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := allocRole() + require.Equal(defaultTableName, def.TableName()) + s := &Role{ + Role: &store.Role{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} diff --git a/internal/iam/scope.go b/internal/iam/scope.go index c238e90a9a..aedea7cc74 100644 --- a/internal/iam/scope.go +++ b/internal/iam/scope.go @@ -13,6 +13,10 @@ import ( "google.golang.org/protobuf/proto" ) +const ( + defaultScopeTableName = "iam_scope" +) + // Scope is used to create a hierarchy of "containers" that encompass the scope of // an IAM resource. Scopes are Global, Orgs and Projects. type Scope struct { @@ -205,12 +209,17 @@ func (s *Scope) TableName() string { if s.tableName != "" { return s.tableName } - return "iam_scope" + return defaultScopeTableName } -// SetTableName sets the tablename and satisfies the ReplayableMessage interface +// SetTableName sets the tablename and satisfies the ReplayableMessage +// interface. If the caller attempts to set the name to "" the name will be +// reset to the default name. func (s *Scope) SetTableName(n string) { - if n != "" { + switch n { + case "": + s.tableName = defaultScopeTableName + default: s.tableName = n } } diff --git a/internal/iam/scope_test.go b/internal/iam/scope_test.go index edd93ffc1c..855590d6ba 100644 --- a/internal/iam/scope_test.go +++ b/internal/iam/scope_test.go @@ -240,3 +240,39 @@ func TestScope_GlobalErrors(t *testing.T) { assert.Equal(t, 0, rows) }) } + +func TestScope_SetTableName(t *testing.T) { + defaultTableName := defaultScopeTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := allocScope() + require.Equal(defaultTableName, def.TableName()) + s := &Scope{ + Scope: &store.Scope{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} diff --git a/internal/iam/user.go b/internal/iam/user.go index f1df03682c..3bc70aa1c6 100644 --- a/internal/iam/user.go +++ b/internal/iam/user.go @@ -12,6 +12,10 @@ import ( "google.golang.org/protobuf/proto" ) +const ( + defaultUserTableName = "iam_user" +) + // User defines watchtower users which are scoped to an Org type User struct { *store.User @@ -89,12 +93,17 @@ func (u *User) TableName() string { if u.tableName != "" { return u.tableName } - return "iam_user" + return defaultUserTableName } -// SetTableName sets the tablename and satisfies the ReplayableMessage interface +// SetTableName sets the tablename and satisfies the ReplayableMessage +// interface. If the caller attempts to set the name to "" the name will be +// reset to the default name. func (u *User) SetTableName(n string) { - if n != "" { + switch n { + case "": + u.tableName = defaultUserTableName + default: u.tableName = n } } diff --git a/internal/iam/user_test.go b/internal/iam/user_test.go index 2c1ed50868..70b42e60ff 100644 --- a/internal/iam/user_test.go +++ b/internal/iam/user_test.go @@ -6,6 +6,7 @@ import ( "testing" "github.com/hashicorp/watchtower/internal/db" + "github.com/hashicorp/watchtower/internal/iam/store" "github.com/hashicorp/watchtower/internal/types/action" "github.com/hashicorp/watchtower/internal/types/resource" "github.com/stretchr/testify/assert" @@ -380,3 +381,39 @@ func TestUser_ResourceType(t *testing.T) { u := allocUser() assert.Equal(t, resource.User, u.ResourceType()) } + +func TestUser_SetTableName(t *testing.T) { + defaultTableName := defaultUserTableName + tests := []struct { + name string + initialName string + setNameTo string + want string + }{ + { + name: "new-name", + initialName: "", + setNameTo: "new-name", + want: "new-name", + }, + { + name: "reset to default", + initialName: "initial", + setNameTo: "", + want: defaultTableName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + def := allocUser() + require.Equal(defaultTableName, def.TableName()) + s := &User{ + User: &store.User{}, + tableName: tt.initialName, + } + s.SetTableName(tt.setNameTo) + assert.Equal(tt.want, s.TableName()) + }) + } +} diff --git a/internal/oplog/oplog_test/db.go b/internal/oplog/oplog_test/db.go index c3c465aa0e..0f6476901b 100644 --- a/internal/oplog/oplog_test/db.go +++ b/internal/oplog/oplog_test/db.go @@ -3,6 +3,12 @@ package oplog_test import "github.com/jinzhu/gorm" +const ( + defaultTestUserTableName = "oplog_test_user" + defaultTestCarTableName = "oplog_test_car" + defaultTestRentalTableName = "oplog_test_rental" +) + // Init will use gorm migrations to init tables for test models func Init(db *gorm.DB) { db.AutoMigrate(&TestUser{}) @@ -23,12 +29,17 @@ func (u *TestUser) TableName() string { if u.Table != "" { return u.Table } - return "oplog_test_user" + return defaultTestUserTableName } -// SetTableName allows the table name to be overridden and makes a TestUser a ReplayableMessage +// SetTableName allows the table name to be overridden and makes a TestUser a +// ReplayableMessage. If the caller attempts to set the name to "" the name will be +// reset to the default name. func (u *TestUser) SetTableName(n string) { - if n != "" { + switch n { + case "": + u.Table = defaultTestUserTableName + default: u.Table = n } } @@ -38,12 +49,15 @@ func (c *TestCar) TableName() string { if c.Table != "" { return c.Table } - return "oplog_test_car" + return defaultTestCarTableName } // SetTableName allows the table name to be overridden and makes a TestCar a ReplayableMessage func (c *TestCar) SetTableName(n string) { - if n != "" { + switch n { + case "": + c.Table = defaultTestCarTableName + default: c.Table = n } } @@ -53,12 +67,15 @@ func (r *TestRental) TableName() string { if r.Table != "" { return r.Table } - return "oplog_test_rental" + return defaultTestRentalTableName } // SetTableName allows the table name to be overridden and makes a TestRental a ReplayableMessage func (r *TestRental) SetTableName(n string) { - if n != "" { + switch n { + case "": + r.Table = defaultTestRentalTableName + default: r.Table = n } }