mirror
/
dex
mirror of https://github.com/dexidp/dex.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

functional: clean up functional tests 

Adjust logic and remove panics from functional tests.
pull/304/head
Eric Chiang 10 years ago
parent
bfd63b7514
commit
5052d8007f
9 changed files with 118 additions and 176 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      .travis.yml
  2. 31
      functional/db_test.go
  3. 3
      functional/dexctl_test.go
  4. 46
      functional/repo/client_repo_test.go
  5. 31
      functional/repo/connector_repo_test.go
  6. 37
      functional/repo/password_repo_test.go
  7. 60
      functional/repo/session_repo_test.go
  8. 28
      functional/repo/testutil.go
  9. 57
      functional/repo/user_repo_test.go

1
.travis.yml
Unescape View File

@ -28,6 +28,7 @@ script:
- docker cp ${LDAPCONTAINER}:container/service/slapd/assets/certs/ldap.crt /tmp/ldap.crt
- sudo sh -c 'echo "127.0.0.1 tlstest.local" >> /etc/hosts'
- ./test-functional
- DEX_TEST_DSN="sqlite3://:memory:" ./test-functional
deploy:
provider: script

31
functional/db_test.go
Unescape View File

@ -36,17 +36,16 @@ func connect(t *testing.T) *gorp.DbMap {
if err != nil {
t.Fatalf("Unable to connect to database: %v", err)
}
if err = c.DropTablesIfExists(); err != nil {
t.Fatalf("Unable to drop database tables: %v", err)
}
if err = db.DropMigrationsTable(c); err != nil {
panic(fmt.Sprintf("Unable to drop migration table: %v", err))
t.Fatalf("Unable to drop migration table: %v", err)
}
if _, err = db.MigrateToLatest(c); err != nil {
panic(fmt.Sprintf("Unable to migrate: %v", err))
t.Fatalf("Unable to migrate: %v", err)
}
return c
@ -157,12 +156,13 @@ func TestDBPrivateKeySetRepoSetGet(t *testing.T) {
}
for i, tt := range tests {
setRepo, err := db.NewPrivateKeySetRepo(connect(t), false, tt.setSecrets...)
dbMap := connect(t)
setRepo, err := db.NewPrivateKeySetRepo(dbMap, false, tt.setSecrets...)
if err != nil {
t.Fatalf(err.Error())
}
getRepo, err := db.NewPrivateKeySetRepo(connect(t), false, tt.getSecrets...)
getRepo, err := db.NewPrivateKeySetRepo(dbMap, false, tt.getSecrets...)
if err != nil {
t.Fatalf(err.Error())
}
@ -377,9 +377,24 @@ func TestDBRefreshRepoCreate(t *testing.T) {
}
for i, tt := range tests {
_, err := r.Create(tt.userID, tt.clientID)
if err != tt.err {
t.Errorf("Case #%d: expected: %v, got: %v", i, tt.err, err)
token, err := r.Create(tt.userID, tt.clientID)
if err != nil {
if tt.err == nil {
t.Errorf("case %d: create failed: %v", i, err)
}
continue
}
if tt.err != nil {
t.Errorf("case %d: expected error, didn't get one", i)
continue
}
userID, err := r.Verify(tt.clientID, token)
if err != nil {
t.Errorf("case %d: failed to verify good token: %v", i, err)
continue
}
if userID != tt.userID {
t.Errorf("case %d: want userID=%s, got userID=%s", i, tt.userID, userID)
}
}
}

3
functional/dexctl_test.go
Unescape View File

@ -28,6 +28,9 @@ var connConfigExample = []byte(`[
]`)
func TestDexctlCommands(t *testing.T) {
if strings.HasPrefix(dsn, "sqlite3://") {
t.Skip("only test dexctl conmand with postgres")
}
tempFile, err := ioutil.TempFile("", "dexctl_functional_tests_")
if err != nil {
t.Fatal(err)

46
functional/repo/client_repo_test.go
Unescape View File

@ -1,7 +1,6 @@
package repo
import (
"fmt"
"net/url"
"os"
"testing"
@ -12,8 +11,6 @@ import (
"github.com/coreos/dex/db"
)
var makeTestClientIdentityRepoFromClients func(clients []oidc.ClientIdentity) client.ClientIdentityRepo
var (
testClients = []oidc.ClientIdentity{
oidc.ClientIdentity{
@ -47,34 +44,17 @@ var (
}
)
func init() {
func newClientIdentityRepo(t *testing.T) client.ClientIdentityRepo {
dsn := os.Getenv("DEX_TEST_DSN")
if dsn == "" {
makeTestClientIdentityRepoFromClients = makeTestClientIdentityRepoMem
} else {
makeTestClientIdentityRepoFromClients = makeTestClientIdentityRepoDB(dsn)
return client.NewClientIdentityRepo(testClients)
}
}
func makeTestClientIdentityRepoMem(clients []oidc.ClientIdentity) client.ClientIdentityRepo {
return client.NewClientIdentityRepo(clients)
}
func makeTestClientIdentityRepoDB(dsn string) func([]oidc.ClientIdentity) client.ClientIdentityRepo {
return func(clients []oidc.ClientIdentity) client.ClientIdentityRepo {
c := initDB(dsn)
repo, err := db.NewClientIdentityRepoFromClients(c, clients)
if err != nil {
panic(fmt.Sprintf("Unable to add clients: %v", err))
}
return repo
dbMap := connect(t)
repo, err := db.NewClientIdentityRepoFromClients(dbMap, testClients)
if err != nil {
t.Fatalf("failed to create client repo from clients: %v", err)
}
}
func makeTestClientIdentityRepo() client.ClientIdentityRepo {
return makeTestClientIdentityRepoFromClients(testClients)
return repo
}
func TestGetSetAdminClient(t *testing.T) {
@ -113,12 +93,14 @@ func TestGetSetAdminClient(t *testing.T) {
},
}
Tests:
for i, tt := range tests {
repo := makeTestClientIdentityRepo()
repo := newClientIdentityRepo(t)
for _, cid := range startAdmins {
err := repo.SetDexAdmin(cid, true)
if err != nil {
t.Fatalf("case %d: unexpected error: %v", i, err)
t.Errorf("case %d: failed to set dex admin: %v", i, err)
continue Tests
}
}
@ -130,7 +112,7 @@ func TestGetSetAdminClient(t *testing.T) {
continue
}
if err != nil {
t.Fatalf("case %d: unexpected error: %v", i, err)
t.Errorf("case %d: unexpected error: %v", i, err)
}
if gotAdmin != tt.wantAdmin {
t.Errorf("case %d: want=%v, got=%v", i, tt.wantAdmin, gotAdmin)
@ -138,12 +120,12 @@ func TestGetSetAdminClient(t *testing.T) {
err = repo.SetDexAdmin(tt.cid, tt.setAdmin)
if err != nil {
t.Fatalf("case %d: unexpected error: %v", i, err)
t.Errorf("case %d: unexpected error: %v", i, err)
}
gotAdmin, err = repo.IsDexAdmin(tt.cid)
if err != nil {
t.Fatalf("case %d: unexpected error: %v", i, err)
t.Errorf("case %d: unexpected error: %v", i, err)
}
if gotAdmin != tt.setAdmin {
t.Errorf("case %d: want=%v, got=%v", i, tt.setAdmin, gotAdmin)

31
functional/repo/connector_repo_test.go
Unescape View File

@ -1,7 +1,6 @@
package repo
import (
"fmt"
"os"
"testing"
@ -9,28 +8,16 @@ import (
"github.com/coreos/dex/db"
)
type connectorConfigRepoFactory func(cfgs []connector.ConnectorConfig) connector.ConnectorConfigRepo
var makeTestConnectorConfigRepoFromConfigs connectorConfigRepoFactory
func init() {
if dsn := os.Getenv("DEX_TEST_DSN"); dsn == "" {
makeTestConnectorConfigRepoFromConfigs = connector.NewConnectorConfigRepoFromConfigs
} else {
makeTestConnectorConfigRepoFromConfigs = makeTestConnectorConfigRepoMem(dsn)
func newConnectorConfigRepo(t *testing.T, configs []connector.ConnectorConfig) connector.ConnectorConfigRepo {
if os.Getenv("DEX_TEST_DSN") == "" {
return connector.NewConnectorConfigRepoFromConfigs(configs)
}
}
func makeTestConnectorConfigRepoMem(dsn string) connectorConfigRepoFactory {
return func(cfgs []connector.ConnectorConfig) connector.ConnectorConfigRepo {
dbMap := initDB(dsn)
repo := db.NewConnectorConfigRepo(dbMap)
if err := repo.Set(cfgs); err != nil {
panic(fmt.Sprintf("Unable to set connector configs: %v", err))
}
return repo
dbMap := connect(t)
repo := db.NewConnectorConfigRepo(dbMap)
if err := repo.Set(configs); err != nil {
t.Fatalf("Unable to set connector configs: %v", err)
}
return repo
}
func TestConnectorConfigRepoGetByID(t *testing.T) {
@ -63,7 +50,7 @@ func TestConnectorConfigRepoGetByID(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestConnectorConfigRepoFromConfigs(tt.cfgs)
repo := newConnectorConfigRepo(t, tt.cfgs)
if _, err := repo.GetConnectorByID(nil, tt.id); err != tt.err {
t.Errorf("case %d: want=%v, got=%v", i, tt.err, err)
}

37
functional/repo/password_repo_test.go
Unescape View File

@ -1,7 +1,6 @@
package repo
import (
"fmt"
"os"
"testing"
"time"
@ -12,8 +11,6 @@ import (
"github.com/coreos/dex/user"
)
var makeTestPasswordInfoRepo func() user.PasswordInfoRepo
var (
testPWs = []user.PasswordInfo{
{
@ -23,30 +20,16 @@ var (
}
)
func init() {
dsn := os.Getenv("DEX_TEST_DSN")
if dsn == "" {
makeTestPasswordInfoRepo = makeTestPasswordInfoRepoMem
} else {
makeTestPasswordInfoRepo = makeTestPasswordInfoRepoDB(dsn)
func newPasswordInfoRepo(t *testing.T) user.PasswordInfoRepo {
if os.Getenv("DEX_TEST_DSN") == "" {
return user.NewPasswordInfoRepoFromPasswordInfos(testPWs)
}
}
func makeTestPasswordInfoRepoMem() user.PasswordInfoRepo {
return user.NewPasswordInfoRepoFromPasswordInfos(testPWs)
}
func makeTestPasswordInfoRepoDB(dsn string) func() user.PasswordInfoRepo {
return func() user.PasswordInfoRepo {
c := initDB(dsn)
repo := db.NewPasswordInfoRepo(c)
err := user.LoadPasswordInfos(repo, testPWs)
if err != nil {
panic(fmt.Sprintf("Unable to add passwordInfos: %v", err))
}
return repo
dbMap := connect(t)
repo := db.NewPasswordInfoRepo(dbMap)
if err := user.LoadPasswordInfos(repo, testPWs); err != nil {
t.Fatalf("Unable to add password infos: %v", err)
}
return repo
}
func TestCreatePasswordInfo(t *testing.T) {
@ -87,7 +70,7 @@ func TestCreatePasswordInfo(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestPasswordInfoRepo()
repo := newPasswordInfoRepo(t)
err := repo.Create(nil, tt.pw)
if tt.err != nil {
if err != tt.err {
@ -142,7 +125,7 @@ func TestUpdatePasswordInfo(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestPasswordInfoRepo()
repo := newPasswordInfoRepo(t)
err := repo.Update(nil, tt.pw)
if tt.err != nil {
if err != tt.err {

60
functional/repo/session_repo_test.go
Unescape View File

@ -12,48 +12,26 @@ import (
"github.com/coreos/dex/session"
)
var makeTestSessionRepo func() (session.SessionRepo, clockwork.FakeClock)
var makeTestSessionKeyRepo func() (session.SessionKeyRepo, clockwork.FakeClock)
func init() {
dsn := os.Getenv("DEX_TEST_DSN")
if dsn == "" {
makeTestSessionRepo = makeTestSessionRepoMem
makeTestSessionKeyRepo = makeTestSessionKeyRepoMem
} else {
makeTestSessionRepo = makeTestSessionRepoDB(dsn)
makeTestSessionKeyRepo = makeTestSessionKeyRepoDB(dsn)
func newSessionRepo(t *testing.T) (session.SessionRepo, clockwork.FakeClock) {
clock := clockwork.NewFakeClock()
if os.Getenv("DEX_TEST_DSN") == "" {
return session.NewSessionRepoWithClock(clock), clock
}
dbMap := connect(t)
return db.NewSessionRepoWithClock(dbMap, clock), clock
}
func makeTestSessionRepoMem() (session.SessionRepo, clockwork.FakeClock) {
fc := clockwork.NewFakeClock()
return session.NewSessionRepoWithClock(fc), fc
}
func makeTestSessionRepoDB(dsn string) func() (session.SessionRepo, clockwork.FakeClock) {
return func() (session.SessionRepo, clockwork.FakeClock) {
c := initDB(dsn)
fc := clockwork.NewFakeClock()
return db.NewSessionRepoWithClock(c, fc), fc
}
}
func makeTestSessionKeyRepoMem() (session.SessionKeyRepo, clockwork.FakeClock) {
fc := clockwork.NewFakeClock()
return session.NewSessionKeyRepoWithClock(fc), fc
}
func makeTestSessionKeyRepoDB(dsn string) func() (session.SessionKeyRepo, clockwork.FakeClock) {
return func() (session.SessionKeyRepo, clockwork.FakeClock) {
c := initDB(dsn)
fc := clockwork.NewFakeClock()
return db.NewSessionKeyRepoWithClock(c, fc), fc
func newSessionKeyRepo(t *testing.T) (session.SessionKeyRepo, clockwork.FakeClock) {
clock := clockwork.NewFakeClock()
if os.Getenv("DEX_TEST_DSN") == "" {
return session.NewSessionKeyRepoWithClock(clock), clock
}
dbMap := connect(t)
return db.NewSessionKeyRepoWithClock(dbMap, clock), clock
}
func TestSessionKeyRepoPopNoExist(t *testing.T) {
r, _ := makeTestSessionKeyRepo()
r, _ := newSessionKeyRepo(t)
_, err := r.Pop("123")
if err == nil {
@ -62,7 +40,7 @@ func TestSessionKeyRepoPopNoExist(t *testing.T) {
}
func TestSessionKeyRepoPushPop(t *testing.T) {
r, _ := makeTestSessionKeyRepo()
r, _ := newSessionKeyRepo(t)
key := "123"
sessionID := "456"
@ -80,7 +58,7 @@ func TestSessionKeyRepoPushPop(t *testing.T) {
}
func TestSessionKeyRepoExpired(t *testing.T) {
r, fc := makeTestSessionKeyRepo()
r, fc := newSessionKeyRepo(t)
key := "123"
sessionID := "456"
@ -96,7 +74,7 @@ func TestSessionKeyRepoExpired(t *testing.T) {
}
func TestSessionRepoGetNoExist(t *testing.T) {
r, _ := makeTestSessionRepo()
r, _ := newSessionRepo(t)
ses, err := r.Get("123")
if ses != nil {
@ -129,7 +107,7 @@ func TestSessionRepoCreateGet(t *testing.T) {
}
for i, tt := range tests {
r, _ := makeTestSessionRepo()
r, _ := newSessionRepo(t)
r.Create(tt)
@ -166,7 +144,7 @@ func TestSessionRepoCreateUpdate(t *testing.T) {
}
for i, tt := range tests {
r, _ := makeTestSessionRepo()
r, _ := newSessionRepo(t)
r.Create(tt.initial)
ses, _ := r.Get(tt.initial.ID)
@ -186,7 +164,7 @@ func TestSessionRepoCreateUpdate(t *testing.T) {
}
func TestSessionRepoUpdateNoExist(t *testing.T) {
r, _ := makeTestSessionRepo()
r, _ := newSessionRepo(t)
err := r.Update(session.Session{ID: "123", ClientState: "boom"})
if err == nil {

28
functional/repo/testutil.go
Unescape View File

@ -1,28 +1,38 @@
package repo
import (
"fmt"
"os"
"testing"
"github.com/coreos/dex/db"
"github.com/go-gorp/gorp"
"github.com/coreos/dex/db"
)
func initDB(dsn string) *gorp.DbMap {
func connect(t *testing.T) *gorp.DbMap {
dsn := os.Getenv("DEX_TEST_DSN")
if dsn == "" {
t.Fatal("DEX_TEST_DSN environment variable not set")
}
c, err := db.NewConnection(db.Config{DSN: dsn})
if err != nil {
panic(fmt.Sprintf("Unable to connect to database: %v", err))
t.Fatalf("Unable to connect to database: %v", err)
}
if err = c.DropTablesIfExists(); err != nil {
panic(fmt.Sprintf("Unable to drop database tables: %v", err))
t.Fatalf("Unable to drop database tables: %v", err)
}
if err = db.DropMigrationsTable(c); err != nil {
panic(fmt.Sprintf("Unable to drop migration table: %v", err))
t.Fatalf("Unable to drop migration table: %v", err)
}
if _, err = db.MigrateToLatest(c); err != nil {
panic(fmt.Sprintf("Unable to migrate: %v", err))
n, err := db.MigrateToLatest(c)
if err != nil {
t.Fatalf("Unable to migrate: %v", err)
}
if n == 0 {
t.Fatalf("No migrations performed")
}
return c
}

57
functional/repo/user_repo_test.go
Unescape View File

@ -13,8 +13,6 @@ import (
"github.com/coreos/dex/user"
)
var makeTestUserRepoFromUsers func(users []user.UserWithRemoteIdentities) user.UserRepo
var (
testUsers = []user.UserWithRemoteIdentities{
{
@ -47,34 +45,19 @@ var (
}
)
func init() {
dsn := os.Getenv("DEX_TEST_DSN")
if dsn == "" {
makeTestUserRepoFromUsers = makeTestUserRepoMem
} else {
makeTestUserRepoFromUsers = makeTestUserRepoDB(dsn)
func newUserRepo(t *testing.T, users []user.UserWithRemoteIdentities) user.UserRepo {
if users == nil {
users = []user.UserWithRemoteIdentities{}
}
}
func makeTestUserRepoMem(users []user.UserWithRemoteIdentities) user.UserRepo {
return user.NewUserRepoFromUsers(users)
}
func makeTestUserRepoDB(dsn string) func([]user.UserWithRemoteIdentities) user.UserRepo {
return func(users []user.UserWithRemoteIdentities) user.UserRepo {
c := initDB(dsn)
repo, err := db.NewUserRepoFromUsers(c, users)
if err != nil {
panic(fmt.Sprintf("Unable to add users: %v", err))
}
return repo
if os.Getenv("DEX_TEST_DSN") == "" {
return user.NewUserRepoFromUsers(users)
}
}
func makeTestUserRepo() user.UserRepo {
return makeTestUserRepoFromUsers(testUsers)
dbMap := connect(t)
repo, err := db.NewUserRepoFromUsers(dbMap, users)
if err != nil {
t.Fatalf("Unable to add users: %v", err)
}
return repo
}
func TestNewUser(t *testing.T) {
@ -137,7 +120,7 @@ func TestNewUser(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestUserRepo()
repo := newUserRepo(t, testUsers)
err := repo.Create(nil, tt.user)
if tt.err != nil {
if err != tt.err {
@ -209,7 +192,7 @@ func TestUpdateUser(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestUserRepo()
repo := newUserRepo(t, testUsers)
err := repo.Update(nil, tt.user)
if tt.err != nil {
if err != tt.err {
@ -269,7 +252,7 @@ func TestDisableUser(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestUserRepo()
repo := newUserRepo(t, testUsers)
err := repo.Disable(nil, tt.id, tt.disable)
switch {
case err != tt.err:
@ -320,7 +303,7 @@ func TestAttachRemoteIdentity(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestUserRepo()
repo := newUserRepo(t, testUsers)
err := repo.AddRemoteIdentity(nil, tt.id, tt.rid)
if tt.err != nil {
if err != tt.err {
@ -390,7 +373,7 @@ func TestRemoveRemoteIdentity(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestUserRepo()
repo := newUserRepo(t, testUsers)
err := repo.RemoveRemoteIdentity(nil, tt.id, tt.rid)
if tt.err != nil {
if err != tt.err {
@ -502,7 +485,7 @@ func TestGetByEmail(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestUserRepo()
repo := newUserRepo(t, testUsers)
gotUser, gotErr := repo.GetByEmail(nil, tt.email)
if tt.wantErr != nil {
if tt.wantErr != gotErr {
@ -566,7 +549,7 @@ func TestGetAdminCount(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestUserRepo()
repo := newUserRepo(t, testUsers)
for _, addUser := range tt.addUsers {
err := repo.Create(nil, addUser)
if err != nil {
@ -621,7 +604,7 @@ func TestList(t *testing.T) {
}
for i, tt := range tests {
repo := makeTestUserRepoFromUsers(repoUsers)
repo := newUserRepo(t, repoUsers)
var tok string
gotIDs := [][]string{}
done := false
@ -651,7 +634,7 @@ func TestList(t *testing.T) {
}
func TestListErrorNotFound(t *testing.T) {
repo := makeTestUserRepoFromUsers(nil)
repo := newUserRepo(t, nil)
_, _, err := repo.List(nil, user.UserFilter{}, 10, "")
if err != user.ErrorNotFound {
t.Errorf("want=%q, got=%q", user.ErrorNotFound, err)

Write Preview
Loading…
Cancel
Save