Skip to content

armgit / memos

Public Imported from GitHub
0

Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.

20.6 KB
Raw Blame
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/server/api"
	"github.com/usememos/memos/store"
)

func TestCreateIdentityProvider(t *testing.T) {
	ctx := context.Background()

	t.Run("CreateIdentityProvider success", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create host user
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		// Set user context
		ctx := ts.CreateUserContext(ctx, hostUser.ID)

		// Create OAuth2 identity provider
		req := &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title:            "Test OAuth2 Provider",
				IdentifierFilter: "",
				Type:             apipb.IdentityProvider_OAUTH2,
				Config: &apipb.IdentityProviderConfig{
					Config: &apipb.IdentityProviderConfig_Oauth2Config{
						Oauth2Config: &apipb.OAuth2Config{
							ClientId:     "test-client-id",
							ClientSecret: "test-client-secret",
							AuthUrl:      "https://example.com/oauth/authorize",
							TokenUrl:     "https://example.com/oauth/token",
							UserInfoUrl:  "https://example.com/oauth/userinfo",
							Scopes:       []string{"openid", "profile", "email"},
							FieldMapping: &apipb.FieldMapping{
								Identifier:  "id",
								DisplayName: "name",
								Email:       "email",
								AvatarUrl:   "avatar_url",
							},
						},
					},
				},
			},
		}

		resp, err := ts.Service.CreateIdentityProvider(ctx, req)
		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Equal(t, "Test OAuth2 Provider", resp.Title)
		require.Equal(t, apipb.IdentityProvider_OAUTH2, resp.Type)
		require.Contains(t, resp.Name, "identity-providers/")
		require.NotNil(t, resp.Config.GetOauth2Config())
		require.Equal(t, "test-client-id", resp.Config.GetOauth2Config().ClientId)
	})

	t.Run("CreateIdentityProvider permission denied for non-host user", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create regular user
		regularUser, err := ts.CreateRegularUser(ctx, "user")
		require.NoError(t, err)

		// Set user context
		ctx := ts.CreateUserContext(ctx, regularUser.ID)

		req := &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title: "Test Provider",
				Type:  apipb.IdentityProvider_OAUTH2,
			},
		}

		_, err = ts.Service.CreateIdentityProvider(ctx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "permission denied")
	})

	t.Run("CreateIdentityProvider unauthenticated", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		req := &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title: "Test Provider",
				Type:  apipb.IdentityProvider_OAUTH2,
			},
		}

		_, err := ts.Service.CreateIdentityProvider(ctx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "user not authenticated")
	})
}

func TestListIdentityProviders(t *testing.T) {
	ctx := context.Background()

	t.Run("ListIdentityProviders empty", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		req := &apipb.ListIdentityProvidersRequest{}
		resp, err := ts.Service.ListIdentityProviders(ctx, req)
		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Empty(t, resp.IdentityProviders)
	})

	t.Run("ListIdentityProviders with providers", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create host user
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		// Set user context
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		// Create a couple of identity providers
		createReq1 := &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title: "Provider 1",
				Type:  apipb.IdentityProvider_OAUTH2,
				Config: &apipb.IdentityProviderConfig{
					Config: &apipb.IdentityProviderConfig_Oauth2Config{
						Oauth2Config: &apipb.OAuth2Config{
							ClientId:    "client1",
							AuthUrl:     "https://example1.com/auth",
							TokenUrl:    "https://example1.com/token",
							UserInfoUrl: "https://example1.com/user",
							FieldMapping: &apipb.FieldMapping{
								Identifier: "id",
							},
						},
					},
				},
			},
		}

		createReq2 := &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title: "Provider 2",
				Type:  apipb.IdentityProvider_OAUTH2,
				Config: &apipb.IdentityProviderConfig{
					Config: &apipb.IdentityProviderConfig_Oauth2Config{
						Oauth2Config: &apipb.OAuth2Config{
							ClientId:    "client2",
							AuthUrl:     "https://example2.com/auth",
							TokenUrl:    "https://example2.com/token",
							UserInfoUrl: "https://example2.com/user",
							FieldMapping: &apipb.FieldMapping{
								Identifier: "id",
							},
						},
					},
				},
			},
		}

		_, err = ts.Service.CreateIdentityProvider(userCtx, createReq1)
		require.NoError(t, err)
		_, err = ts.Service.CreateIdentityProvider(userCtx, createReq2)
		require.NoError(t, err)

		// List providers
		listReq := &apipb.ListIdentityProvidersRequest{}
		resp, err := ts.Service.ListIdentityProviders(ctx, listReq)
		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Len(t, resp.IdentityProviders, 2)

		// Verify response contains expected providers
		titles := []string{resp.IdentityProviders[0].Title, resp.IdentityProviders[1].Title}
		require.Contains(t, titles, "Provider 1")
		require.Contains(t, titles, "Provider 2")
	})
}

func TestGetIdentityProvider(t *testing.T) {
	ctx := context.Background()

	t.Run("GetIdentityProvider success", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create host user
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		// Set user context
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		// Create identity provider
		createReq := &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title: "Test Provider",
				Type:  apipb.IdentityProvider_OAUTH2,
				Config: &apipb.IdentityProviderConfig{
					Config: &apipb.IdentityProviderConfig_Oauth2Config{
						Oauth2Config: &apipb.OAuth2Config{
							ClientId:     "test-client",
							ClientSecret: "test-secret",
							AuthUrl:      "https://example.com/auth",
							TokenUrl:     "https://example.com/token",
							UserInfoUrl:  "https://example.com/user",
							Scopes:       []string{"openid", "profile"},
							FieldMapping: &apipb.FieldMapping{
								Identifier:  "id",
								DisplayName: "name",
								Email:       "email",
							},
						},
					},
				},
			},
		}

		created, err := ts.Service.CreateIdentityProvider(userCtx, createReq)
		require.NoError(t, err)

		// Get identity provider
		getReq := &apipb.GetIdentityProviderRequest{
			Name: created.Name,
		}

		// ClientSecret is write-only: never returned in responses, even to admins.
		resp, err := ts.Service.GetIdentityProvider(ctx, getReq)
		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Equal(t, created.Name, resp.Name)
		require.Equal(t, "Test Provider", resp.Title)
		require.Equal(t, apipb.IdentityProvider_OAUTH2, resp.Type)
		require.NotNil(t, resp.Config.GetOauth2Config())
		require.Equal(t, "test-client", resp.Config.GetOauth2Config().ClientId)
		require.Empty(t, resp.Config.GetOauth2Config().ClientSecret,
			"ClientSecret must never be returned in responses")

		// Same for admin: secret is still write-only.
		respAdmin, err := ts.Service.GetIdentityProvider(userCtx, getReq)
		require.NoError(t, err)
		require.NotNil(t, respAdmin)
		require.Equal(t, "test-client", respAdmin.Config.GetOauth2Config().ClientId)
		require.Empty(t, respAdmin.Config.GetOauth2Config().ClientSecret,
			"ClientSecret must never be returned in responses, even to admins")
	})

	t.Run("GetIdentityProvider not found", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		req := &apipb.GetIdentityProviderRequest{
			Name: "identity-providers/999",
		}

		_, err := ts.Service.GetIdentityProvider(ctx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "not found")
	})

	t.Run("GetIdentityProvider invalid name", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		req := &apipb.GetIdentityProviderRequest{
			Name: "invalid-name",
		}

		_, err := ts.Service.GetIdentityProvider(ctx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "invalid identity provider name")
	})
}

func TestUpdateIdentityProvider(t *testing.T) {
	ctx := context.Background()

	t.Run("UpdateIdentityProvider success", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create host user
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		// Set user context
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		// Create identity provider
		createReq := &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title:            "Original Provider",
				IdentifierFilter: "",
				Type:             apipb.IdentityProvider_OAUTH2,
				Config: &apipb.IdentityProviderConfig{
					Config: &apipb.IdentityProviderConfig_Oauth2Config{
						Oauth2Config: &apipb.OAuth2Config{
							ClientId:    "original-client",
							AuthUrl:     "https://original.com/auth",
							TokenUrl:    "https://original.com/token",
							UserInfoUrl: "https://original.com/user",
							FieldMapping: &apipb.FieldMapping{
								Identifier: "id",
							},
						},
					},
				},
			},
		}

		created, err := ts.Service.CreateIdentityProvider(userCtx, createReq)
		require.NoError(t, err)

		// Update identity provider
		updateReq := &apipb.UpdateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Name:             created.Name,
				Title:            "Updated Provider",
				IdentifierFilter: "[email protected]",
				Type:             apipb.IdentityProvider_OAUTH2,
				Config: &apipb.IdentityProviderConfig{
					Config: &apipb.IdentityProviderConfig_Oauth2Config{
						Oauth2Config: &apipb.OAuth2Config{
							ClientId:     "updated-client",
							ClientSecret: "updated-secret",
							AuthUrl:      "https://updated.com/auth",
							TokenUrl:     "https://updated.com/token",
							UserInfoUrl:  "https://updated.com/user",
							Scopes:       []string{"openid", "profile", "email"},
							FieldMapping: &apipb.FieldMapping{
								Identifier:  "sub",
								DisplayName: "given_name",
								Email:       "email",
								AvatarUrl:   "picture",
							},
						},
					},
				},
			},
			UpdateMask: &fieldmaskpb.FieldMask{
				Paths: []string{"title", "identifier_filter", "config"},
			},
		}

		updated, err := ts.Service.UpdateIdentityProvider(userCtx, updateReq)
		require.NoError(t, err)
		require.NotNil(t, updated)
		require.Equal(t, "Updated Provider", updated.Title)
		require.Equal(t, "[email protected]", updated.IdentifierFilter)
		require.Equal(t, "updated-client", updated.Config.GetOauth2Config().ClientId)
	})

	t.Run("UpdateIdentityProvider empty ClientSecret preserves existing credential", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		// Create IDP with a real secret.
		created, err := ts.Service.CreateIdentityProvider(userCtx, &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title: "Preserve Secret Test",
				Type:  apipb.IdentityProvider_OAUTH2,
				Config: &apipb.IdentityProviderConfig{
					Config: &apipb.IdentityProviderConfig_Oauth2Config{
						Oauth2Config: &apipb.OAuth2Config{
							ClientId:     "cid",
							ClientSecret: "original-secret",
							AuthUrl:      "https://ex.com/auth",
							TokenUrl:     "https://ex.com/token",
							UserInfoUrl:  "https://ex.com/user",
							FieldMapping: &apipb.FieldMapping{Identifier: "id"},
						},
					},
				},
			},
		})
		require.NoError(t, err)

		// Update with empty ClientSecret (simulating UI that doesn't resend the secret).
		_, err = ts.Service.UpdateIdentityProvider(userCtx, &apipb.UpdateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Name:  created.Name,
				Title: "Updated Title",
				Type:  apipb.IdentityProvider_OAUTH2,
				Config: &apipb.IdentityProviderConfig{
					Config: &apipb.IdentityProviderConfig_Oauth2Config{
						Oauth2Config: &apipb.OAuth2Config{
							ClientId:     "cid",
							ClientSecret: "", // empty = preserve existing
							AuthUrl:      "https://ex.com/auth",
							TokenUrl:     "https://ex.com/token",
							UserInfoUrl:  "https://ex.com/user",
							FieldMapping: &apipb.FieldMapping{Identifier: "id"},
						},
					},
				},
			},
			UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title", "config"}},
		})
		require.NoError(t, err)

		// Verify the stored secret was preserved by reading from store directly.
		uid, _ := api.ExtractIdentityProviderUIDFromName(created.Name)
		stored, err := ts.Store.GetIdentityProvider(ctx, &store.FindIdentityProvider{UID: &uid})
		require.NoError(t, err)
		require.Equal(t, "original-secret", stored.Config.GetOauth2Config().ClientSecret,
			"existing ClientSecret must be preserved when an empty value is sent")
		require.Equal(t, "Updated Title", stored.Name)
	})

	t.Run("UpdateIdentityProvider missing update mask", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create host user
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		// Set user context
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		req := &apipb.UpdateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Name:  "identity-providers/1",
				Title: "Updated Provider",
			},
		}

		_, err = ts.Service.UpdateIdentityProvider(userCtx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "update_mask is required")
	})

	t.Run("UpdateIdentityProvider invalid name", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create host user
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		// Set user context
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		req := &apipb.UpdateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Name:  "invalid-name",
				Title: "Updated Provider",
			},
			UpdateMask: &fieldmaskpb.FieldMask{
				Paths: []string{"title"},
			},
		}

		_, err = ts.Service.UpdateIdentityProvider(userCtx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "invalid identity provider name")
	})
}

func TestDeleteIdentityProvider(t *testing.T) {
	ctx := context.Background()

	t.Run("DeleteIdentityProvider success", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create host user
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		// Set user context
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		// Create identity provider
		createReq := &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title: "Provider to Delete",
				Type:  apipb.IdentityProvider_OAUTH2,
				Config: &apipb.IdentityProviderConfig{
					Config: &apipb.IdentityProviderConfig_Oauth2Config{
						Oauth2Config: &apipb.OAuth2Config{
							ClientId:    "client-to-delete",
							AuthUrl:     "https://example.com/auth",
							TokenUrl:    "https://example.com/token",
							UserInfoUrl: "https://example.com/user",
							FieldMapping: &apipb.FieldMapping{
								Identifier: "id",
							},
						},
					},
				},
			},
		}

		created, err := ts.Service.CreateIdentityProvider(userCtx, createReq)
		require.NoError(t, err)

		// Delete identity provider
		deleteReq := &apipb.DeleteIdentityProviderRequest{
			Name: created.Name,
		}

		_, err = ts.Service.DeleteIdentityProvider(userCtx, deleteReq)
		require.NoError(t, err)

		// Verify deletion
		getReq := &apipb.GetIdentityProviderRequest{
			Name: created.Name,
		}

		_, err = ts.Service.GetIdentityProvider(ctx, getReq)
		require.Error(t, err)
		require.Contains(t, err.Error(), "not found")
	})

	t.Run("DeleteIdentityProvider invalid name", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create host user
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		// Set user context
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		req := &apipb.DeleteIdentityProviderRequest{
			Name: "invalid-name",
		}

		_, err = ts.Service.DeleteIdentityProvider(userCtx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "invalid identity provider name")
	})

	t.Run("DeleteIdentityProvider not found", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create host user
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		// Set user context
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		req := &apipb.DeleteIdentityProviderRequest{
			Name: "identity-providers/999",
		}

		_, err = ts.Service.DeleteIdentityProvider(userCtx, req)
		require.Error(t, err)
		// Note: Delete might succeed even if item doesn't exist, depending on store implementation
	})
}

func TestIdentityProviderPermissions(t *testing.T) {
	ctx := context.Background()

	t.Run("Only host users can create identity providers", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create regular user
		regularUser, err := ts.CreateRegularUser(ctx, "regularuser")
		require.NoError(t, err)

		// Set user context
		userCtx := ts.CreateUserContext(ctx, regularUser.ID)

		req := &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title: "Test Provider",
				Type:  apipb.IdentityProvider_OAUTH2,
			},
		}

		_, err = ts.Service.CreateIdentityProvider(userCtx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "permission denied")
	})

	t.Run("Authentication required", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		req := &apipb.CreateIdentityProviderRequest{
			IdentityProvider: &apipb.IdentityProvider{
				Title: "Test Provider",
				Type:  apipb.IdentityProvider_OAUTH2,
			},
		}

		_, err := ts.Service.CreateIdentityProvider(ctx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "user not authenticated")
	})
}

func TestIdentityProviderValidation(t *testing.T) {
	ctx := context.Background()
	ts := NewTestService(t)
	defer ts.Cleanup()
	hostUser, err := ts.CreateHostUser(ctx, "admin")
	require.NoError(t, err)
	adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

	oauth2 := func(mutate func(*apipb.OAuth2Config)) *apipb.IdentityProvider {
		config := &apipb.OAuth2Config{
			ClientId:     "client",
			ClientSecret: "secret",
			AuthUrl:      "https://idp.example.com/authorize",
			TokenUrl:     "https://idp.example.com/token",
			UserInfoUrl:  "https://idp.example.com/userinfo",
			FieldMapping: &apipb.FieldMapping{Identifier: "sub"},
		}
		if mutate != nil {
			mutate(config)
		}
		return &apipb.IdentityProvider{
			Title:  "SSO",
			Type:   apipb.IdentityProvider_OAUTH2,
			Config: &apipb.IdentityProviderConfig{Config: &apipb.IdentityProviderConfig_Oauth2Config{Oauth2Config: config}},
		}
	}

	for name, provider := range map[string]*apipb.IdentityProvider{
		"missing field mapping": oauth2(func(c *apipb.OAuth2Config) { c.FieldMapping = nil }),
		"relative token url":    oauth2(func(c *apipb.OAuth2Config) { c.TokenUrl = "/token" }),
		"missing client id":     oauth2(func(c *apipb.OAuth2Config) { c.ClientId = "" }),
		"missing config":        {Title: "SSO", Type: apipb.IdentityProvider_OAUTH2},
	} {
		_, err := ts.Service.CreateIdentityProvider(adminCtx, &apipb.CreateIdentityProviderRequest{IdentityProvider: provider})
		require.Equal(t, codes.InvalidArgument, status.Code(err), name)
	}
	_, err = ts.Service.CreateIdentityProvider(adminCtx, &apipb.CreateIdentityProviderRequest{})
	require.Equal(t, codes.InvalidArgument, status.Code(err))

	created, err := ts.Service.CreateIdentityProvider(adminCtx, &apipb.CreateIdentityProviderRequest{IdentityProvider: oauth2(nil)})
	require.NoError(t, err)

	// An update is validated as the merged provider, so clearing the title fails
	// even though the request only names one field.
	_, err = ts.Service.UpdateIdentityProvider(adminCtx, &apipb.UpdateIdentityProviderRequest{
		IdentityProvider: &apipb.IdentityProvider{Name: created.Name, Title: " "},
		UpdateMask:       &fieldmaskpb.FieldMask{Paths: []string{"title"}},
	})
	require.Equal(t, codes.InvalidArgument, status.Code(err))

	_, err = ts.Service.UpdateIdentityProvider(adminCtx, &apipb.UpdateIdentityProviderRequest{
		IdentityProvider: &apipb.IdentityProvider{Name: created.Name, Title: "Renamed"},
		UpdateMask:       &fieldmaskpb.FieldMask{Paths: []string{"title"}},
	})
	require.NoError(t, err)
}