hoernschen/dendrite
1
0
Fork 0
mirror of https://github.com/hoernschen/dendrite.git synced 2024-12-27 07:28:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Don't use in-memory db for userapi tests (#2417)

Browse source 
* Don't use in-memory db

* Use WithAllDatabases where possible
This commit is contained in:
Till 2022-05-05 12:00:18 +02:00 committed by GitHub
parent 5c37f165ae
commit 658e82f8bc
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 109 additions and 96 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

205
userapi/userapi_test.go
View file

@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
package userapi package userapi_test
import ( import (
"context" "context"
@ -23,15 +23,17 @@ import (
"time" "time"
"github.com/gorilla/mux" "github.com/gorilla/mux"
"github.com/matrix-org/dendrite/internal/httputil"
internalTest "github.com/matrix-org/dendrite/internal/test"
"github.com/matrix-org/dendrite/test"
"github.com/matrix-org/dendrite/userapi"
"github.com/matrix-org/dendrite/userapi/inthttp"
"github.com/matrix-org/gomatrixserverlib" "github.com/matrix-org/gomatrixserverlib"
"golang.org/x/crypto/bcrypt" "golang.org/x/crypto/bcrypt"
"github.com/matrix-org/dendrite/internal/httputil"
"github.com/matrix-org/dendrite/internal/test"
"github.com/matrix-org/dendrite/setup/config" "github.com/matrix-org/dendrite/setup/config"
"github.com/matrix-org/dendrite/userapi/api" "github.com/matrix-org/dendrite/userapi/api"
"github.com/matrix-org/dendrite/userapi/internal" "github.com/matrix-org/dendrite/userapi/internal"
"github.com/matrix-org/dendrite/userapi/inthttp"
"github.com/matrix-org/dendrite/userapi/storage" "github.com/matrix-org/dendrite/userapi/storage"
) )
@ -43,16 +45,15 @@ type apiTestOpts struct {
loginTokenLifetime time.Duration loginTokenLifetime time.Duration
} }
func MustMakeInternalAPI(t *testing.T, opts apiTestOpts) (api.UserInternalAPI, storage.Database) { func MustMakeInternalAPI(t *testing.T, opts apiTestOpts, dbType test.DBType) (api.UserInternalAPI, storage.Database, func()) {
if opts.loginTokenLifetime == 0 { if opts.loginTokenLifetime == 0 {
opts.loginTokenLifetime = api.DefaultLoginTokenLifetime * time.Millisecond opts.loginTokenLifetime = api.DefaultLoginTokenLifetime * time.Millisecond
} }
dbopts := &config.DatabaseOptions{ connStr, close := test.PrepareDBConnectionString(t, dbType)
ConnectionString: "file::memory:",
MaxOpenConnections: 1, accountDB, err := storage.NewUserAPIDatabase(nil, &config.DatabaseOptions{
MaxIdleConnections: 1, ConnectionString: config.DataSource(connStr),
} }, serverName, bcrypt.MinCost, config.DefaultOpenIDTokenLifetimeMS, opts.loginTokenLifetime, "")
accountDB, err := storage.NewUserAPIDatabase(nil, dbopts, serverName, bcrypt.MinCost, config.DefaultOpenIDTokenLifetimeMS, opts.loginTokenLifetime, "")
if err != nil { if err != nil {
t.Fatalf("failed to create account DB: %s", err) t.Fatalf("failed to create account DB: %s", err)
} }
@ -66,13 +67,15 @@ func MustMakeInternalAPI(t *testing.T, opts apiTestOpts) (api.UserInternalAPI, s
return &internal.UserInternalAPI{ return &internal.UserInternalAPI{
DB: accountDB, DB: accountDB,
ServerName: cfg.Matrix.ServerName, ServerName: cfg.Matrix.ServerName,
}, accountDB }, accountDB, close
} }
func TestQueryProfile(t *testing.T) { func TestQueryProfile(t *testing.T) {
aliceAvatarURL := "mxc://example.com/alice" aliceAvatarURL := "mxc://example.com/alice"
aliceDisplayName := "Alice" aliceDisplayName := "Alice"
userAPI, accountDB := MustMakeInternalAPI(t, apiTestOpts{}) // only one DBType, since userapi.AddInternalRoutes complains about multiple prometheus counters added
userAPI, accountDB, close := MustMakeInternalAPI(t, apiTestOpts{}, test.DBTypeSQLite)
defer close()
_, err := accountDB.CreateAccount(context.TODO(), "alice", "foobar", "", api.AccountTypeUser) _, err := accountDB.CreateAccount(context.TODO(), "alice", "foobar", "", api.AccountTypeUser)
if err != nil { if err != nil {
t.Fatalf("failed to make account: %s", err) t.Fatalf("failed to make account: %s", err)
@ -131,8 +134,8 @@ func TestQueryProfile(t *testing.T) {
t.Run("HTTP API", func(t *testing.T) { t.Run("HTTP API", func(t *testing.T) {
router := mux.NewRouter().PathPrefix(httputil.InternalPathPrefix).Subrouter() router := mux.NewRouter().PathPrefix(httputil.InternalPathPrefix).Subrouter()
AddInternalRoutes(router, userAPI) userapi.AddInternalRoutes(router, userAPI)
apiURL, cancel := test.ListenAndServe(t, router, false) apiURL, cancel := internalTest.ListenAndServe(t, router, false)
defer cancel() defer cancel()
httpAPI, err := inthttp.NewUserAPIClient(apiURL, &http.Client{}) httpAPI, err := inthttp.NewUserAPIClient(apiURL, &http.Client{})
if err != nil { if err != nil {
@ -149,110 +152,120 @@ func TestLoginToken(t *testing.T) {
ctx := context.Background() ctx := context.Background()
t.Run("tokenLoginFlow", func(t *testing.T) { t.Run("tokenLoginFlow", func(t *testing.T) {
userAPI, accountDB := MustMakeInternalAPI(t, apiTestOpts{}) test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {
userAPI, accountDB, close := MustMakeInternalAPI(t, apiTestOpts{}, dbType)
defer close()
_, err := accountDB.CreateAccount(ctx, "auser", "apassword", "", api.AccountTypeUser)
if err != nil {
t.Fatalf("failed to make account: %s", err)
}
_, err := accountDB.CreateAccount(ctx, "auser", "apassword", "", api.AccountTypeUser) t.Log("Creating a login token like the SSO callback would...")
if err != nil {
t.Fatalf("failed to make account: %s", err)
}
t.Log("Creating a login token like the SSO callback would...") creq := api.PerformLoginTokenCreationRequest{
Data: api.LoginTokenData{UserID: "@auser:example.com"},
}
var cresp api.PerformLoginTokenCreationResponse
if err := userAPI.PerformLoginTokenCreation(ctx, &creq, &cresp); err != nil {
t.Fatalf("PerformLoginTokenCreation failed: %v", err)
}
creq := api.PerformLoginTokenCreationRequest{ if cresp.Metadata.Token == "" {
Data: api.LoginTokenData{UserID: "@auser:example.com"}, t.Errorf("PerformLoginTokenCreation Token: got %q, want non-empty", cresp.Metadata.Token)
} }
var cresp api.PerformLoginTokenCreationResponse if cresp.Metadata.Expiration.Before(time.Now()) {
if err := userAPI.PerformLoginTokenCreation(ctx, &creq, &cresp); err != nil { t.Errorf("PerformLoginTokenCreation Expiration: got %v, want non-expired", cresp.Metadata.Expiration)
t.Fatalf("PerformLoginTokenCreation failed: %v", err) }
}
if cresp.Metadata.Token == "" { t.Log("Querying the login token like /login with m.login.token would...")
t.Errorf("PerformLoginTokenCreation Token: got %q, want non-empty", cresp.Metadata.Token)
}
if cresp.Metadata.Expiration.Before(time.Now()) {
t.Errorf("PerformLoginTokenCreation Expiration: got %v, want non-expired", cresp.Metadata.Expiration)
}
t.Log("Querying the login token like /login with m.login.token would...") qreq := api.QueryLoginTokenRequest{Token: cresp.Metadata.Token}
var qresp api.QueryLoginTokenResponse
if err := userAPI.QueryLoginToken(ctx, &qreq, &qresp); err != nil {
t.Fatalf("QueryLoginToken failed: %v", err)
}
qreq := api.QueryLoginTokenRequest{Token: cresp.Metadata.Token} if qresp.Data == nil {
var qresp api.QueryLoginTokenResponse t.Errorf("QueryLoginToken Data: got %v, want non-nil", qresp.Data)
if err := userAPI.QueryLoginToken(ctx, &qreq, &qresp); err != nil { } else if want := "@auser:example.com"; qresp.Data.UserID != want {
t.Fatalf("QueryLoginToken failed: %v", err) t.Errorf("QueryLoginToken UserID: got %q, want %q", qresp.Data.UserID, want)
} }
if qresp.Data == nil { t.Log("Deleting the login token like /login with m.login.token would...")
t.Errorf("QueryLoginToken Data: got %v, want non-nil", qresp.Data)
} else if want := "@auser:example.com"; qresp.Data.UserID != want {
t.Errorf("QueryLoginToken UserID: got %q, want %q", qresp.Data.UserID, want)
}
t.Log("Deleting the login token like /login with m.login.token would...") dreq := api.PerformLoginTokenDeletionRequest{Token: cresp.Metadata.Token}
var dresp api.PerformLoginTokenDeletionResponse
dreq := api.PerformLoginTokenDeletionRequest{Token: cresp.Metadata.Token} if err := userAPI.PerformLoginTokenDeletion(ctx, &dreq, &dresp); err != nil {
var dresp api.PerformLoginTokenDeletionResponse t.Fatalf("PerformLoginTokenDeletion failed: %v", err)
if err := userAPI.PerformLoginTokenDeletion(ctx, &dreq, &dresp); err != nil { }
t.Fatalf("PerformLoginTokenDeletion failed: %v", err) })
}
}) })
t.Run("expiredTokenIsNotReturned", func(t *testing.T) { t.Run("expiredTokenIsNotReturned", func(t *testing.T) {
userAPI, _ := MustMakeInternalAPI(t, apiTestOpts{loginTokenLifetime: -1 * time.Second}) test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {
userAPI, _, close := MustMakeInternalAPI(t, apiTestOpts{loginTokenLifetime: -1 * time.Second}, dbType)
defer close()
creq := api.PerformLoginTokenCreationRequest{ creq := api.PerformLoginTokenCreationRequest{
Data: api.LoginTokenData{UserID: "@auser:example.com"}, Data: api.LoginTokenData{UserID: "@auser:example.com"},
} }
var cresp api.PerformLoginTokenCreationResponse var cresp api.PerformLoginTokenCreationResponse
if err := userAPI.PerformLoginTokenCreation(ctx, &creq, &cresp); err != nil { if err := userAPI.PerformLoginTokenCreation(ctx, &creq, &cresp); err != nil {
t.Fatalf("PerformLoginTokenCreation failed: %v", err) t.Fatalf("PerformLoginTokenCreation failed: %v", err)
} }
qreq := api.QueryLoginTokenRequest{Token: cresp.Metadata.Token} qreq := api.QueryLoginTokenRequest{Token: cresp.Metadata.Token}
var qresp api.QueryLoginTokenResponse var qresp api.QueryLoginTokenResponse
if err := userAPI.QueryLoginToken(ctx, &qreq, &qresp); err != nil { if err := userAPI.QueryLoginToken(ctx, &qreq, &qresp); err != nil {
t.Fatalf("QueryLoginToken failed: %v", err) t.Fatalf("QueryLoginToken failed: %v", err)
} }
if qresp.Data != nil { if qresp.Data != nil {
t.Errorf("QueryLoginToken Data: got %v, want nil", qresp.Data) t.Errorf("QueryLoginToken Data: got %v, want nil", qresp.Data)
} }
})
}) })
t.Run("deleteWorks", func(t *testing.T) { t.Run("deleteWorks", func(t *testing.T) {
userAPI, _ := MustMakeInternalAPI(t, apiTestOpts{}) test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {
userAPI, _, close := MustMakeInternalAPI(t, apiTestOpts{}, dbType)
defer close()
creq := api.PerformLoginTokenCreationRequest{ creq := api.PerformLoginTokenCreationRequest{
Data: api.LoginTokenData{UserID: "@auser:example.com"}, Data: api.LoginTokenData{UserID: "@auser:example.com"},
} }
var cresp api.PerformLoginTokenCreationResponse var cresp api.PerformLoginTokenCreationResponse
if err := userAPI.PerformLoginTokenCreation(ctx, &creq, &cresp); err != nil { if err := userAPI.PerformLoginTokenCreation(ctx, &creq, &cresp); err != nil {
t.Fatalf("PerformLoginTokenCreation failed: %v", err) t.Fatalf("PerformLoginTokenCreation failed: %v", err)
} }
dreq := api.PerformLoginTokenDeletionRequest{Token: cresp.Metadata.Token} dreq := api.PerformLoginTokenDeletionRequest{Token: cresp.Metadata.Token}
var dresp api.PerformLoginTokenDeletionResponse var dresp api.PerformLoginTokenDeletionResponse
if err := userAPI.PerformLoginTokenDeletion(ctx, &dreq, &dresp); err != nil { if err := userAPI.PerformLoginTokenDeletion(ctx, &dreq, &dresp); err != nil {
t.Fatalf("PerformLoginTokenDeletion failed: %v", err) t.Fatalf("PerformLoginTokenDeletion failed: %v", err)
} }
qreq := api.QueryLoginTokenRequest{Token: cresp.Metadata.Token} qreq := api.QueryLoginTokenRequest{Token: cresp.Metadata.Token}
var qresp api.QueryLoginTokenResponse var qresp api.QueryLoginTokenResponse
if err := userAPI.QueryLoginToken(ctx, &qreq, &qresp); err != nil { if err := userAPI.QueryLoginToken(ctx, &qreq, &qresp); err != nil {
t.Fatalf("QueryLoginToken failed: %v", err) t.Fatalf("QueryLoginToken failed: %v", err)
} }
if qresp.Data != nil { if qresp.Data != nil {
t.Errorf("QueryLoginToken Data: got %v, want nil", qresp.Data) t.Errorf("QueryLoginToken Data: got %v, want nil", qresp.Data)
} }
})
}) })
t.Run("deleteUnknownIsNoOp", func(t *testing.T) { t.Run("deleteUnknownIsNoOp", func(t *testing.T) {
userAPI, _ := MustMakeInternalAPI(t, apiTestOpts{}) test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {
userAPI, _, close := MustMakeInternalAPI(t, apiTestOpts{}, dbType)
dreq := api.PerformLoginTokenDeletionRequest{Token: "non-existent token"} defer close()
var dresp api.PerformLoginTokenDeletionResponse dreq := api.PerformLoginTokenDeletionRequest{Token: "non-existent token"}
if err := userAPI.PerformLoginTokenDeletion(ctx, &dreq, &dresp); err != nil { var dresp api.PerformLoginTokenDeletionResponse
t.Fatalf("PerformLoginTokenDeletion failed: %v", err) if err := userAPI.PerformLoginTokenDeletion(ctx, &dreq, &dresp); err != nil {
} t.Fatalf("PerformLoginTokenDeletion failed: %v", err)
}
})
}) })
} }