package memory import ( "fmt" "os" "strings" "testing" "github.com/coreos/dex/storage" "github.com/sirupsen/logrus" ) func TestStaticClients(t *testing.T) { logger := &logrus.Logger{ Out: os.Stderr, Formatter: &logrus.TextFormatter{DisableColors: true}, Level: logrus.DebugLevel, } backing := New(logger) c1 := storage.Client{ID: "foo", Secret: "foo_secret"} c2 := storage.Client{ID: "bar", Secret: "bar_secret"} c3 := storage.Client{ID: "spam", Secret: "spam_secret"} backing.CreateClient(c1) s := storage.WithStaticClients(backing, []storage.Client{c2}) tests := []struct { name string action func() error wantErr bool }{ { name: "get client from static storage", action: func() error { _, err := s.GetClient(c2.ID) return err }, }, { name: "get client from backing storage", action: func() error { _, err := s.GetClient(c1.ID) return err }, }, { name: "update static client", action: func() error { updater := func(c storage.Client) (storage.Client, error) { c.Secret = "new_" + c.Secret return c, nil } return s.UpdateClient(c2.ID, updater) }, wantErr: true, }, { name: "update non-static client", action: func() error { updater := func(c storage.Client) (storage.Client, error) { c.Secret = "new_" + c.Secret return c, nil } return s.UpdateClient(c1.ID, updater) }, }, { name: "list clients", action: func() error { clients, err := s.ListClients() if err != nil { return err } if n := len(clients); n != 2 { return fmt.Errorf("expected 2 clients got %d", n) } return nil }, }, { name: "create client", action: func() error { return s.CreateClient(c3) }, }, } for _, tc := range tests { err := tc.action() if err != nil && !tc.wantErr { t.Errorf("%s: %v", tc.name, err) } if err == nil && tc.wantErr { t.Errorf("%s: expected error, didn't get one", tc.name) } } } func TestStaticPasswords(t *testing.T) { logger := &logrus.Logger{ Out: os.Stderr, Formatter: &logrus.TextFormatter{DisableColors: true}, Level: logrus.DebugLevel, } backing := New(logger) p1 := storage.Password{Email: "foo@example.com", Username: "foo_secret"} p2 := storage.Password{Email: "bar@example.com", Username: "bar_secret"} p3 := storage.Password{Email: "spam@example.com", Username: "spam_secret"} p4 := storage.Password{Email: "Spam@example.com", Username: "Spam_secret"} backing.CreatePassword(p1) s := storage.WithStaticPasswords(backing, []storage.Password{p2}, logger) tests := []struct { name string action func() error wantErr bool }{ { name: "get password from static storage", action: func() error { _, err := s.GetPassword(p2.Email) return err }, }, { name: "get password from backing storage", action: func() error { _, err := s.GetPassword(p1.Email) return err }, }, { name: "get password from static storage with casing", action: func() error { _, err := s.GetPassword(strings.ToUpper(p2.Email)) return err }, }, { name: "update static password", action: func() error { updater := func(p storage.Password) (storage.Password, error) { p.Username = "new_" + p.Username return p, nil } return s.UpdatePassword(p2.Email, updater) }, wantErr: true, }, { name: "update non-static password", action: func() error { updater := func(p storage.Password) (storage.Password, error) { p.Username = "new_" + p.Username return p, nil } return s.UpdatePassword(p1.Email, updater) }, }, { name: "create passwords", action: func() error { if err := s.CreatePassword(p4); err != nil { return err } return s.CreatePassword(p3) }, wantErr: true, }, { name: "get password", action: func() error { p, err := s.GetPassword(p4.Email) if err != nil { return err } if strings.Compare(p.Email, p4.Email) != 0 { return fmt.Errorf("expected %s passwords got %s", p4.Email, p.Email) } return nil }, }, { name: "list passwords", action: func() error { passwords, err := s.ListPasswords() if err != nil { return err } if n := len(passwords); n != 3 { return fmt.Errorf("expected 3 passwords got %d", n) } return nil }, }, } for _, tc := range tests { err := tc.action() if err != nil && !tc.wantErr { t.Errorf("%s: %v", tc.name, err) } if err == nil && tc.wantErr { t.Errorf("%s: expected error, didn't get one", tc.name) } } } func TestStaticConnectors(t *testing.T) { logger := &logrus.Logger{ Out: os.Stderr, Formatter: &logrus.TextFormatter{DisableColors: true}, Level: logrus.DebugLevel, } backing := New(logger) config1 := []byte(`{"issuer": "https://accounts.google.com"}`) config2 := []byte(`{"host": "ldap.example.com:636"}`) config3 := []byte(`{"issuer": "https://example.com"}`) c1 := storage.Connector{ID: storage.NewID(), Type: "oidc", Name: "oidc", ResourceVersion: "1", Config: config1} c2 := storage.Connector{ID: storage.NewID(), Type: "ldap", Name: "ldap", ResourceVersion: "1", Config: config2} c3 := storage.Connector{ID: storage.NewID(), Type: "saml", Name: "saml", ResourceVersion: "1", Config: config3} backing.CreateConnector(c1) s := storage.WithStaticConnectors(backing, []storage.Connector{c2}) tests := []struct { name string action func() error wantErr bool }{ { name: "get connector from static storage", action: func() error { _, err := s.GetConnector(c2.ID) return err }, }, { name: "get connector from backing storage", action: func() error { _, err := s.GetConnector(c1.ID) return err }, }, { name: "update static connector", action: func() error { updater := func(c storage.Connector) (storage.Connector, error) { c.Name = "New" return c, nil } return s.UpdateConnector(c2.ID, updater) }, wantErr: true, }, { name: "update non-static connector", action: func() error { updater := func(c storage.Connector) (storage.Connector, error) { c.Name = "New" return c, nil } return s.UpdateConnector(c1.ID, updater) }, }, { name: "list connectors", action: func() error { connectors, err := s.ListConnectors() if err != nil { return err } if n := len(connectors); n != 2 { return fmt.Errorf("expected 2 connectors got %d", n) } return nil }, }, { name: "create connector", action: func() error { return s.CreateConnector(c3) }, }, } for _, tc := range tests { err := tc.action() if err != nil && !tc.wantErr { t.Errorf("%s: %v", tc.name, err) } if err == nil && tc.wantErr { t.Errorf("%s: expected error, didn't get one", tc.name) } } }