2021-05-26 19:43:36 -05:00
package migration
import (
2021-09-30 08:47:34 -04:00
"context"
"database/sql"
2021-05-26 19:43:36 -05:00
"fmt"
"testing"
"time"
2021-09-30 08:47:34 -04:00
"github.com/hashicorp/boundary/internal/db"
2021-05-26 19:43:36 -05:00
"github.com/hashicorp/boundary/internal/servers/controller"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func Test_ManagedGroupTable ( t * testing . T ) {
t . Parallel ()
tc := controller . NewTestController ( t , nil )
defer tc . Shutdown ()
2021-09-30 08:47:34 -04:00
rw := db . New ( tc . DbConn ())
2021-05-26 19:43:36 -05:00
managedGroupId := "a_bcdefghijk"
defaultPasswordAuthMethodId := "ampw_1234567890"
defaultOidcAuthMethodId := "amoidc_1234567890"
insertTests := [] struct {
testName string
publicId string
authMethodId string
wantErr bool
}{
{
testName : "invalid auth method" ,
publicId : managedGroupId ,
authMethodId : "amoid_1234567890" ,
wantErr : true ,
},
{
testName : "valid" ,
publicId : managedGroupId ,
authMethodId : defaultOidcAuthMethodId ,
wantErr : false ,
},
}
for _ , tt := range insertTests {
t . Run ( "insert: " + tt . testName , func ( t * testing . T ) {
require := require . New ( t )
2021-09-30 08:47:34 -04:00
_ , err := rw . Exec ( context . Background (), "insert into auth_managed_group values (@public_id, @auth_method_id)" ,
[] interface {}{
sql . Named ( "public_id" , tt . publicId ),
sql . Named ( "auth_method_id" , tt . authMethodId ),
})
2021-05-26 19:43:36 -05:00
require . True ( tt . wantErr == ( err != nil ))
})
}
updateTests := [] struct {
testName string
column string
value string
publicId string
wantErr bool
}{
{
testName : "immutable public id" ,
column : "public_id" ,
value : "z_yxwvutsrqp" ,
publicId : managedGroupId ,
wantErr : true ,
},
{
testName : "immutable auth method" ,
column : "auth_method_id" ,
value : defaultPasswordAuthMethodId ,
publicId : managedGroupId ,
wantErr : true ,
},
}
for _ , tt := range updateTests {
t . Run ( "update: " + tt . testName , func ( t * testing . T ) {
assert := assert . New ( t )
2021-09-30 08:47:34 -04:00
_ , err := rw . Exec ( context . Background (), fmt . Sprintf ( "update auth_managed_group set %s = @value where public_id = @public_id" , tt . column ),
[] interface {}{
sql . Named ( "value" , tt . value ),
sql . Named ( "public_id" , tt . publicId ),
})
2021-05-26 19:43:36 -05:00
assert . True ( tt . wantErr == ( err != nil ))
})
}
}
func Test_OidcManagedGroupTable ( t * testing . T ) {
t . Parallel ()
tc := controller . NewTestController ( t , nil )
defer tc . Shutdown ()
2021-09-30 08:47:34 -04:00
ctx := context . Background ()
rw := db . New ( tc . DbConn ())
2021-05-26 19:43:36 -05:00
managedGroupId := "a_bcdefghijk"
defaultPasswordAuthMethodId := "ampw_1234567890"
defaultOidcAuthMethodId := "amoidc_1234567890"
name := "this is the name"
filter := "this is a filter"
// The first set of tests is for initial insertion
{
insertTests := [] struct {
testName string
publicId string
authMethodId string
name string
filter string
wantErr bool
}{
{
testName : "null filter" ,
publicId : managedGroupId ,
authMethodId : "amoid_1234567890" ,
name : name ,
filter : "" ,
wantErr : true ,
},
{
testName : "invalid auth method" ,
publicId : managedGroupId ,
authMethodId : defaultPasswordAuthMethodId ,
name : name ,
filter : filter ,
wantErr : true ,
},
{
testName : "valid" ,
publicId : managedGroupId ,
authMethodId : defaultOidcAuthMethodId ,
name : name ,
filter : filter ,
wantErr : false ,
},
{
testName : "duplicate public id" ,
publicId : managedGroupId ,
authMethodId : defaultOidcAuthMethodId ,
name : name ,
filter : filter ,
wantErr : true ,
},
{
testName : "duplicate name" ,
publicId : "z_yxwvutsrqp" ,
authMethodId : defaultOidcAuthMethodId ,
name : name ,
filter : filter ,
wantErr : true ,
},
}
for _ , tt := range insertTests {
t . Run ( "insert: " + tt . testName , func ( t * testing . T ) {
require := require . New ( t )
2021-09-30 08:47:34 -04:00
_ , err := rw . Exec ( ctx , "insert into auth_oidc_managed_group (public_id, auth_method_id, name, filter) values (@public_id, @auth_method_id, @name, @filter)" ,
[] interface {}{
sql . Named ( "public_id" , tt . publicId ),
sql . Named ( "auth_method_id" , tt . authMethodId ),
sql . Named ( "name" , tt . name ),
sql . Named ( "filter" , tt . filter ),
})
2021-05-26 19:43:36 -05:00
require . True ( tt . wantErr == ( err != nil ))
})
}
}
// Read some values to validate that things were set automatically
2021-09-30 08:47:34 -04:00
rows , err := rw . Query ( ctx , "select create_time, update_time, version from auth_oidc_managed_group" , nil )
2021-05-26 19:43:36 -05:00
require . NoError ( t , err )
require . True ( t , rows . Next ())
var create_time , update_time time . Time
var version int
require . NoError ( t , rows . Scan ( & create_time , & update_time , & version ))
assert . False ( t , create_time . IsZero ())
assert . Equal ( t , update_time , create_time )
assert . Equal ( t , 1 , version )
// These update tests check immutability
{
updateTests := [] struct {
testName string
column string
value interface {}
wantErr bool
}{
{
testName : "immutable public id" ,
column : "public_id" ,
value : "z_yxwvutsrqp" ,
wantErr : true ,
},
{
testName : "immutable auth method" ,
column : "auth_method_id" ,
value : defaultPasswordAuthMethodId ,
wantErr : true ,
},
{
testName : "immutable creation time" ,
column : "create_time" ,
value : time . Now (),
wantErr : true ,
},
{
testName : "valid" ,
column : "description" ,
value : "this is the description" ,
wantErr : false ,
},
}
for _ , tt := range updateTests {
t . Run ( "update: " + tt . testName , func ( t * testing . T ) {
require := require . New ( t )
2021-09-30 08:47:34 -04:00
_ , err = rw . Exec ( ctx , fmt . Sprintf ( "update auth_oidc_managed_group set %s = @value where public_id = @public_id" , tt . column ),
[] interface {}{
sql . Named ( "value" , tt . value ), sql . Named ( "public_id" , managedGroupId ),
})
2021-05-26 19:43:36 -05:00
require . True ( tt . wantErr == ( err != nil ))
})
}
}
// Read values again to validate that things were updated automatically
2021-09-30 08:47:34 -04:00
rows , err = rw . Query ( ctx , "select create_time, update_time, version from auth_oidc_managed_group" , nil )
2021-05-26 19:43:36 -05:00
require . NoError ( t , err )
require . True ( t , rows . Next ())
var updated_create_time , updated_update_time time . Time
require . NoError ( t , rows . Scan ( & updated_create_time , & updated_update_time , & version ))
assert . Equal ( t , create_time , updated_create_time )
assert . NotEqual ( t , update_time , updated_update_time )
assert . Equal ( t , 2 , version )
// Read values from auth_managed_group to ensure it was populated automatically
2021-09-30 08:47:34 -04:00
rows , err = rw . Query ( ctx , "select public_id, auth_method_id from auth_managed_group" , nil )
2021-05-26 19:43:36 -05:00
require . NoError ( t , err )
require . True ( t , rows . Next ())
var public_id , auth_method_id string
require . NoError ( t , rows . Scan ( & public_id , & auth_method_id ))
assert . Equal ( t , managedGroupId , public_id )
assert . Equal ( t , defaultOidcAuthMethodId , auth_method_id )
// Delete the value from the subtype table
2021-09-30 08:47:34 -04:00
affected , err := rw . Exec ( ctx , "delete from auth_oidc_managed_group where public_id = @public_id" , [] interface {}{ sql . Named ( "public_id" , managedGroupId )})
2021-05-26 19:43:36 -05:00
require . EqualValues ( t , 1 , affected )
// It should no longer be in the base table
2021-09-30 08:47:34 -04:00
rows , err = rw . Query ( ctx , "select public_id, auth_method_id from auth_managed_group" , nil )
2021-05-26 19:43:36 -05:00
require . NoError ( t , err )
require . False ( t , rows . Next ())
}
func Test_AuthManagedOidcGroupMemberAccountTable ( t * testing . T ) {
t . Parallel ()
tc := controller . NewTestController ( t , nil )
defer tc . Shutdown ()
2021-09-30 08:47:34 -04:00
ctx := context . Background ()
rw := db . New ( tc . DbConn ())
2021-05-26 19:43:36 -05:00
managedGroupId := "a_bcdefghijk"
defaultOidcAuthMethodId := "amoidc_1234567890"
name := "this is the name"
filter := "this is a filter"
// Insert valid data in auth_oidc_managed_group to use for the following tests
2021-09-30 08:47:34 -04:00
_ , err := rw . Exec ( ctx , "insert into auth_oidc_managed_group (public_id, auth_method_id, name, filter) values (@public_id, @auth_method_id, @name, @filter)" ,
[] interface {}{
sql . Named ( "public_id" , managedGroupId ),
sql . Named ( "auth_method_id" , defaultOidcAuthMethodId ),
sql . Named ( "name" , name ),
sql . Named ( "filter" , filter ),
})
2021-05-26 19:43:36 -05:00
require . NoError ( t , err )
// Fetch a valid (oidc) account ID to use in insertion
2021-09-30 08:47:34 -04:00
rows , err := rw . Query ( ctx , "select public_id from auth_oidc_account limit 1" , nil )
2021-05-26 19:43:36 -05:00
require . NoError ( t , err )
require . True ( t , rows . Next ())
var accountId string
require . NoError ( t , rows . Scan ( & accountId ))
require . NotEmpty ( t , accountId )
// The first set of tests is for initial insertion
{
insertTests := [] struct {
testName string
managedGroupId string
memberId string
wantErr bool
}{
{
testName : "invalid managed group id" ,
managedGroupId : "z_yxwvutsrqp" ,
memberId : accountId ,
wantErr : true ,
},
{
testName : "invalid member id" ,
managedGroupId : managedGroupId ,
memberId : "acct_1234567890" ,
wantErr : true ,
},
{
testName : "valid" ,
managedGroupId : managedGroupId ,
memberId : accountId ,
wantErr : false ,
},
{
testName : "duplicate values" ,
managedGroupId : managedGroupId ,
memberId : accountId ,
wantErr : true ,
},
}
for _ , tt := range insertTests {
t . Run ( "insert: " + tt . testName , func ( t * testing . T ) {
assert := assert . New ( t )
2021-09-30 08:47:34 -04:00
_ , err = rw . Exec ( ctx , "insert into auth_oidc_managed_group_member_account (managed_group_id, member_id) values (@group_id, @member_id)" ,
[] interface {}{
sql . Named ( "group_id" , tt . managedGroupId ),
sql . Named ( "member_id" , tt . memberId ),
})
2021-05-26 19:43:36 -05:00
assert . True ( tt . wantErr == ( err != nil ))
})
}
}
// Read some values to validate that things were set automatically
2021-09-30 08:47:34 -04:00
rows , err = rw . Query ( ctx , "select create_time, managed_group_id, member_id from auth_oidc_managed_group_member_account" , nil )
2021-05-26 19:43:36 -05:00
require . NoError ( t , err )
require . True ( t , rows . Next ())
var create_time time . Time
var managed_group_id , member_id string
require . NoError ( t , rows . Scan ( & create_time , & managed_group_id , & member_id ))
assert . False ( t , create_time . IsZero ())
// These update tests check immutability
{
updateTests := [] struct {
testName string
column string
value interface {}
wantErr bool
}{
{
testName : "immutable managed group id" ,
column : "managed_group_id" ,
value : "z_yxwvutsrqp" ,
wantErr : true ,
},
{
testName : "immutable member_id" ,
column : "member_id" ,
value : "acct_1234567890" ,
wantErr : true ,
},
{
testName : "immutable creation time" ,
column : "create_time" ,
value : time . Now (),
wantErr : true ,
},
}
for _ , tt := range updateTests {
t . Run ( "update: " + tt . testName , func ( t * testing . T ) {
assert := assert . New ( t )
2021-09-30 08:47:34 -04:00
_ , err = rw . Exec ( ctx , fmt . Sprintf ( "update auth_managed_group_member_account set %s = ? where managed_group_id = @group_id and member_id = @member_id" , tt . column ),
[] interface {}{
sql . Named ( "group_id" , managedGroupId ),
sql . Named ( "member_id" , accountId ),
})
2021-05-26 19:43:36 -05:00
assert . True ( tt . wantErr == ( err != nil ))
})
}
}
// Read from the view to ensure we see it there
2021-09-30 08:47:34 -04:00
rows , err = rw . Query ( ctx , "select create_time, managed_group_id, member_id from auth_managed_group_member_account" , nil )
2021-05-26 19:43:36 -05:00
require . NoError ( t , err )
require . True ( t , rows . Next ())
var view_create_time time . Time
var view_managed_group_id , view_member_id string
require . NoError ( t , rows . Scan ( & view_create_time , & view_managed_group_id , & view_member_id ))
assert . Equal ( t , create_time , view_create_time )
assert . Equal ( t , managed_group_id , view_managed_group_id )
assert . Equal ( t , member_id , view_member_id )
}