mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
201 lines
6.9 KiB
Go
201 lines
6.9 KiB
Go
package test
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/types/known/fieldmaskpb"
|
|
|
|
apipb "github.com/usememos/memos/proto/gen/api"
|
|
"github.com/usememos/memos/store"
|
|
)
|
|
|
|
func TestUserServiceUniqueEmail(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
newAdminContext := func(t *testing.T, ts *TestService) context.Context {
|
|
t.Helper()
|
|
admin, err := ts.CreateHostUser(ctx, "admin")
|
|
require.NoError(t, err)
|
|
return ts.CreateUserContext(ctx, admin.ID)
|
|
}
|
|
|
|
t.Run("CreateUser stores the canonical form", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
adminCtx := newAdminContext(t, ts)
|
|
|
|
created, err := ts.Service.CreateUser(adminCtx, &apipb.CreateUserRequest{
|
|
User: &apipb.User{Username: "bob", Email: " Bob@Example.COM ", Password: "password123"},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "bob@example.com", created.Email)
|
|
})
|
|
|
|
t.Run("CreateUser rejects a malformed address", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
adminCtx := newAdminContext(t, ts)
|
|
|
|
for _, email := range []string{"not-an-address", "Bob <bob@example.com>", "bob@example.com@example.com"} {
|
|
_, err := ts.Service.CreateUser(adminCtx, &apipb.CreateUserRequest{
|
|
User: &apipb.User{Username: "bob", Email: email, Password: "password123"},
|
|
})
|
|
require.Equal(t, codes.InvalidArgument, status.Code(err), "email %q", email)
|
|
}
|
|
})
|
|
|
|
t.Run("CreateUser refuses an address another account holds", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
adminCtx := newAdminContext(t, ts)
|
|
|
|
_, err := ts.CreateRegularUser(ctx, "holder")
|
|
require.NoError(t, err)
|
|
|
|
_, err = ts.Service.CreateUser(adminCtx, &apipb.CreateUserRequest{
|
|
User: &apipb.User{Username: "claimant", Email: "Holder@Example.com", Password: "password123"},
|
|
})
|
|
require.Equal(t, codes.AlreadyExists, status.Code(err))
|
|
|
|
_, err = ts.Service.CreateUser(adminCtx, &apipb.CreateUserRequest{
|
|
User: &apipb.User{Username: "claimant", Email: "holder@example.com", Password: "password123"},
|
|
ValidateOnly: true,
|
|
})
|
|
require.Equal(t, codes.AlreadyExists, status.Code(err), "validate_only gives the same answer")
|
|
|
|
validated, err := ts.Service.CreateUser(adminCtx, &apipb.CreateUserRequest{
|
|
User: &apipb.User{Username: "claimant", Email: "Claimant@Example.com", Password: "password123"},
|
|
ValidateOnly: true,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "claimant@example.com", validated.Email)
|
|
})
|
|
|
|
t.Run("first user setup applies the same rules", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
_, err := ts.Service.CreateUser(ctx, &apipb.CreateUserRequest{
|
|
User: &apipb.User{Username: "owner", Email: "owner@example", Password: "password123"},
|
|
})
|
|
require.NoError(t, err, "a dotless domain is allowed")
|
|
|
|
owner, err := ts.Store.GetUser(ctx, &store.FindUser{Username: func() *string { s := "owner"; return &s }()})
|
|
require.NoError(t, err)
|
|
require.Equal(t, store.RoleAdmin, owner.Role)
|
|
require.Equal(t, "owner@example", owner.Email)
|
|
})
|
|
|
|
t.Run("UpdateUser enforces uniqueness and clears with an empty value", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
holder, err := ts.CreateRegularUser(ctx, "holder")
|
|
require.NoError(t, err)
|
|
mover, err := ts.CreateRegularUser(ctx, "mover")
|
|
require.NoError(t, err)
|
|
moverCtx := ts.CreateUserContext(ctx, mover.ID)
|
|
|
|
update := func(email string) (*apipb.User, error) {
|
|
return ts.Service.UpdateUser(moverCtx, &apipb.UpdateUserRequest{
|
|
User: &apipb.User{Name: "users/mover", Email: email},
|
|
UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"email"}},
|
|
})
|
|
}
|
|
|
|
_, err = update("HOLDER@example.com")
|
|
require.Equal(t, codes.AlreadyExists, status.Code(err))
|
|
|
|
_, err = update("mover <mover@example.com>")
|
|
require.Equal(t, codes.InvalidArgument, status.Code(err))
|
|
|
|
updated, err := update(" Mover.New@Example.com ")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "mover.new@example.com", updated.Email)
|
|
|
|
cleared, err := update("")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "", cleared.Email)
|
|
|
|
// The holder's address was never touched by any of the above.
|
|
reloaded, err := ts.Store.GetUser(ctx, &store.FindUser{ID: &holder.ID})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "holder@example.com", reloaded.Email)
|
|
})
|
|
}
|
|
|
|
func TestSSOSignInEmailHandling(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
t.Run("stores the canonical form of the provider address", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
mockIDP := newMockOAuthServer(t, "valid-code", "valid-token", map[string]any{
|
|
"sub": "carol",
|
|
"name": "Carol",
|
|
"email": " Carol@Example.COM ",
|
|
})
|
|
defer mockIDP.Close()
|
|
|
|
idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "email-canonical")
|
|
response, err := signInWithTestingSSO(ctx, ts, idpName, "valid-code")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "carol", response.User.Username)
|
|
require.Equal(t, "carol@example.com", response.User.Email)
|
|
})
|
|
|
|
t.Run("provisions without an address when another account holds it", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
holder, err := ts.CreateRegularUser(ctx, "holder")
|
|
require.NoError(t, err)
|
|
|
|
mockIDP := newMockOAuthServer(t, "valid-code", "valid-token", map[string]any{
|
|
"sub": "holder-sso",
|
|
"name": "Holder Via SSO",
|
|
"email": "Holder@Example.com",
|
|
})
|
|
defer mockIDP.Close()
|
|
|
|
idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "email-collision")
|
|
response, err := signInWithTestingSSO(ctx, ts, idpName, "valid-code")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "holder-sso", response.User.Username)
|
|
require.Equal(t, "", response.User.Email, "the address is dropped, never the account")
|
|
require.NotEqual(t, holder.Username, response.User.Username)
|
|
|
|
// The identity is linked to the new account only; the holder is untouched.
|
|
assertSingleSSOLink(ctx, t, ts, "email-collision", "holder-sso", "holder-sso")
|
|
holderIdentities, err := ts.Store.ListUserIdentities(ctx, &store.FindUserIdentity{UserID: &holder.ID})
|
|
require.NoError(t, err)
|
|
require.Empty(t, holderIdentities)
|
|
reloaded, err := ts.Store.GetUser(ctx, &store.FindUser{ID: &holder.ID})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "holder@example.com", reloaded.Email)
|
|
})
|
|
|
|
t.Run("provisions without an address when the provider address is malformed", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
mockIDP := newMockOAuthServer(t, "valid-code", "valid-token", map[string]any{
|
|
"sub": "dave",
|
|
"name": "Dave",
|
|
"email": "Dave <dave@example.com>",
|
|
})
|
|
defer mockIDP.Close()
|
|
|
|
idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "email-malformed")
|
|
response, err := signInWithTestingSSO(ctx, ts, idpName, "valid-code")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "dave", response.User.Username)
|
|
require.Equal(t, "", response.User.Email)
|
|
})
|
|
}
|