initial public commit

core/settings_test.go

@@ -0,0 +1,606 @@
+package core_test
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/auth"
+)
+
+func TestSettingsValidate(t *testing.T) {
+	s := core.NewSettings()
+
+	// set invalid settings data
+	s.Meta.AppName = ""
+	s.Logs.MaxDays = -10
+	s.Smtp.Enabled = true
+	s.Smtp.Host = ""
+	s.S3.Enabled = true
+	s.S3.Endpoint = "invalid"
+	s.AdminAuthToken.Duration = -10
+	s.AdminPasswordResetToken.Duration = -10
+	s.UserAuthToken.Duration = -10
+	s.UserPasswordResetToken.Duration = -10
+	s.UserEmailChangeToken.Duration = -10
+	s.UserVerificationToken.Duration = -10
+	s.EmailAuth.Enabled = true
+	s.EmailAuth.MinPasswordLength = -10
+	s.GoogleAuth.Enabled = true
+	s.GoogleAuth.ClientId = ""
+	s.FacebookAuth.Enabled = true
+	s.FacebookAuth.ClientId = ""
+	s.GithubAuth.Enabled = true
+	s.GithubAuth.ClientId = ""
+	s.GitlabAuth.Enabled = true
+	s.GitlabAuth.ClientId = ""
+
+	// check if Validate() is triggering the members validate methods.
+	err := s.Validate()
+	if err == nil {
+		t.Fatalf("Expected error, got nil")
+	}
+
+	expectations := []string{
+		`"meta":{`,
+		`"logs":{`,
+		`"smtp":{`,
+		`"s3":{`,
+		`"adminAuthToken":{`,
+		`"adminPasswordResetToken":{`,
+		`"userAuthToken":{`,
+		`"userPasswordResetToken":{`,
+		`"userEmailChangeToken":{`,
+		`"userVerificationToken":{`,
+		`"emailAuth":{`,
+		`"googleAuth":{`,
+		`"facebookAuth":{`,
+		`"githubAuth":{`,
+		`"gitlabAuth":{`,
+	}
+
+	errBytes, _ := json.Marshal(err)
+	jsonErr := string(errBytes)
+	for _, expected := range expectations {
+		if !strings.Contains(jsonErr, expected) {
+			t.Errorf("Expected error key %s in %v", expected, jsonErr)
+		}
+	}
+}
+
+func TestSettingsMerge(t *testing.T) {
+	s1 := core.NewSettings()
+	s1.Meta.AppUrl = "old_app_url"
+
+	s2 := core.NewSettings()
+	s2.Meta.AppName = "test"
+	s2.Logs.MaxDays = 123
+	s2.Smtp.Host = "test"
+	s2.Smtp.Enabled = true
+	s2.S3.Enabled = true
+	s2.S3.Endpoint = "test"
+	s2.AdminAuthToken.Duration = 1
+	s2.AdminPasswordResetToken.Duration = 2
+	s2.UserAuthToken.Duration = 3
+	s2.UserPasswordResetToken.Duration = 4
+	s2.UserEmailChangeToken.Duration = 5
+	s2.UserVerificationToken.Duration = 6
+	s2.EmailAuth.Enabled = false
+	s2.EmailAuth.MinPasswordLength = 30
+	s2.GoogleAuth.Enabled = true
+	s2.GoogleAuth.ClientId = "google_test"
+	s2.FacebookAuth.Enabled = true
+	s2.FacebookAuth.ClientId = "facebook_test"
+	s2.GithubAuth.Enabled = true
+	s2.GithubAuth.ClientId = "github_test"
+	s2.GitlabAuth.Enabled = true
+	s2.GitlabAuth.ClientId = "gitlab_test"
+
+	if err := s1.Merge(s2); err != nil {
+		t.Fatal(err)
+	}
+
+	s1Encoded, err := json.Marshal(s1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	s2Encoded, err := json.Marshal(s2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(s1Encoded) != string(s2Encoded) {
+		t.Fatalf("Expected the same serialization, got %v VS %v", string(s1Encoded), string(s2Encoded))
+	}
+}
+
+func TestSettingsClone(t *testing.T) {
+	s1 := core.NewSettings()
+
+	s2, err := s1.Clone()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	s1Bytes, err := json.Marshal(s1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	s2Bytes, err := json.Marshal(s2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(s1Bytes) != string(s2Bytes) {
+		t.Fatalf("Expected equivalent serialization, got %v VS %v", string(s1Bytes), string(s2Bytes))
+	}
+
+	// verify that it is a deep copy
+	s1.Meta.AppName = "new"
+	if s1.Meta.AppName == s2.Meta.AppName {
+		t.Fatalf("Expected s1 and s2 to have different Meta.AppName, got %s", s1.Meta.AppName)
+	}
+}
+
+func TestSettingsRedactClone(t *testing.T) {
+	s1 := core.NewSettings()
+	s1.Meta.AppName = "test123" // control field
+	s1.Smtp.Password = "test123"
+	s1.Smtp.Tls = true
+	s1.S3.Secret = "test123"
+	s1.AdminAuthToken.Secret = "test123"
+	s1.AdminPasswordResetToken.Secret = "test123"
+	s1.UserAuthToken.Secret = "test123"
+	s1.UserPasswordResetToken.Secret = "test123"
+	s1.UserEmailChangeToken.Secret = "test123"
+	s1.UserVerificationToken.Secret = "test123"
+	s1.GoogleAuth.ClientSecret = "test123"
+	s1.FacebookAuth.ClientSecret = "test123"
+	s1.GithubAuth.ClientSecret = "test123"
+	s1.GitlabAuth.ClientSecret = "test123"
+
+	s2, err := s1.RedactClone()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	encoded, err := json.Marshal(s2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := `{"meta":{"appName":"test123","appUrl":"http://localhost:8090","senderName":"Support","senderAddress":"support@example.com","userVerificationUrl":"%APP_URL%/_/#/users/confirm-verification/%TOKEN%","userResetPasswordUrl":"%APP_URL%/_/#/users/confirm-password-reset/%TOKEN%","userConfirmEmailChangeUrl":"%APP_URL%/_/#/users/confirm-email-change/%TOKEN%"},"logs":{"maxDays":7},"smtp":{"enabled":false,"host":"smtp.example.com","port":587,"username":"","password":"******","tls":true},"s3":{"enabled":false,"bucket":"","region":"","endpoint":"","accessKey":"","secret":"******"},"adminAuthToken":{"secret":"******","duration":1209600},"adminPasswordResetToken":{"secret":"******","duration":1800},"userAuthToken":{"secret":"******","duration":1209600},"userPasswordResetToken":{"secret":"******","duration":1800},"userEmailChangeToken":{"secret":"******","duration":1800},"userVerificationToken":{"secret":"******","duration":604800},"emailAuth":{"enabled":true,"exceptDomains":null,"onlyDomains":null,"minPasswordLength":8},"googleAuth":{"enabled":false,"allowRegistrations":true,"clientSecret":"******"},"facebookAuth":{"enabled":false,"allowRegistrations":true,"clientSecret":"******"},"githubAuth":{"enabled":false,"allowRegistrations":true,"clientSecret":"******"},"gitlabAuth":{"enabled":false,"allowRegistrations":true,"clientSecret":"******"}}`
+
+	if encodedStr := string(encoded); encodedStr != expected {
+		t.Fatalf("Expected %v, got \n%v", expected, encodedStr)
+	}
+}
+
+func TestNamedAuthProviderConfigs(t *testing.T) {
+	s := core.NewSettings()
+
+	s.GoogleAuth.ClientId = "google_test"
+	s.FacebookAuth.ClientId = "facebook_test"
+	s.GithubAuth.ClientId = "github_test"
+	s.GitlabAuth.ClientId = "gitlab_test"
+	s.GitlabAuth.Enabled = true
+
+	result := s.NamedAuthProviderConfigs()
+
+	encoded, err := json.Marshal(result)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := `{"facebook":{"enabled":false,"allowRegistrations":true,"clientId":"facebook_test"},"github":{"enabled":false,"allowRegistrations":true,"clientId":"github_test"},"gitlab":{"enabled":true,"allowRegistrations":true,"clientId":"gitlab_test"},"google":{"enabled":false,"allowRegistrations":true,"clientId":"google_test"}}`
+
+	if encodedStr := string(encoded); encodedStr != expected {
+		t.Fatalf("Expected the same serialization, got %v", encodedStr)
+	}
+}
+
+func TestTokenConfigValidate(t *testing.T) {
+	scenarios := []struct {
+		config      core.TokenConfig
+		expectError bool
+	}{
+		// zero values
+		{
+			core.TokenConfig{},
+			true,
+		},
+		// invalid data
+		{
+			core.TokenConfig{
+				Secret:   "test",
+				Duration: 4,
+			},
+			true,
+		},
+		// valid data
+		{
+			core.TokenConfig{
+				Secret:   "testtesttesttesttesttesttestte",
+				Duration: 100,
+			},
+			false,
+		},
+	}
+
+	for i, scenario := range scenarios {
+		result := scenario.config.Validate()
+
+		if result != nil && !scenario.expectError {
+			t.Errorf("(%d) Didn't expect error, got %v", i, result)
+		}
+
+		if result == nil && scenario.expectError {
+			t.Errorf("(%d) Expected error, got nil", i)
+		}
+	}
+}
+
+func TestSmtpConfigValidate(t *testing.T) {
+	scenarios := []struct {
+		config      core.SmtpConfig
+		expectError bool
+	}{
+		// zero values (disabled)
+		{
+			core.SmtpConfig{},
+			false,
+		},
+		// zero values (enabled)
+		{
+			core.SmtpConfig{Enabled: true},
+			true,
+		},
+		// invalid data
+		{
+			core.SmtpConfig{
+				Enabled: true,
+				Host:    "test:test:test",
+				Port:    -10,
+			},
+			true,
+		},
+		// valid data
+		{
+			core.SmtpConfig{
+				Enabled: true,
+				Host:    "example.com",
+				Port:    100,
+				Tls:     true,
+			},
+			false,
+		},
+	}
+
+	for i, scenario := range scenarios {
+		result := scenario.config.Validate()
+
+		if result != nil && !scenario.expectError {
+			t.Errorf("(%d) Didn't expect error, got %v", i, result)
+		}
+
+		if result == nil && scenario.expectError {
+			t.Errorf("(%d) Expected error, got nil", i)
+		}
+	}
+}
+
+func TestS3ConfigValidate(t *testing.T) {
+	scenarios := []struct {
+		config      core.S3Config
+		expectError bool
+	}{
+		// zero values (disabled)
+		{
+			core.S3Config{},
+			false,
+		},
+		// zero values (enabled)
+		{
+			core.S3Config{Enabled: true},
+			true,
+		},
+		// invalid data
+		{
+			core.S3Config{
+				Enabled:  true,
+				Endpoint: "test:test:test",
+			},
+			true,
+		},
+		// valid data
+		{
+			core.S3Config{
+				Enabled:   true,
+				Endpoint:  "example.com",
+				Bucket:    "test",
+				Region:    "test",
+				AccessKey: "test",
+				Secret:    "test",
+			},
+			false,
+		},
+	}
+
+	for i, scenario := range scenarios {
+		result := scenario.config.Validate()
+
+		if result != nil && !scenario.expectError {
+			t.Errorf("(%d) Didn't expect error, got %v", i, result)
+		}
+
+		if result == nil && scenario.expectError {
+			t.Errorf("(%d) Expected error, got nil", i)
+		}
+	}
+}
+
+func TestMetaConfigValidate(t *testing.T) {
+	scenarios := []struct {
+		config      core.MetaConfig
+		expectError bool
+	}{
+		// zero values
+		{
+			core.MetaConfig{},
+			true,
+		},
+		// invalid data
+		{
+			core.MetaConfig{
+				AppName:                   strings.Repeat("a", 300),
+				AppUrl:                    "test",
+				SenderName:                strings.Repeat("a", 300),
+				SenderAddress:             "invalid_email",
+				UserVerificationUrl:       "test",
+				UserResetPasswordUrl:      "test",
+				UserConfirmEmailChangeUrl: "test",
+			},
+			true,
+		},
+		// invalid data (missing required placeholders)
+		{
+			core.MetaConfig{
+				AppName:                   "test",
+				AppUrl:                    "https://example.com",
+				SenderName:                "test",
+				SenderAddress:             "test@example.com",
+				UserVerificationUrl:       "https://example.com",
+				UserResetPasswordUrl:      "https://example.com",
+				UserConfirmEmailChangeUrl: "https://example.com",
+			},
+			true,
+		},
+		// valid data
+		{
+			core.MetaConfig{
+				AppName:                   "test",
+				AppUrl:                    "https://example.com",
+				SenderName:                "test",
+				SenderAddress:             "test@example.com",
+				UserVerificationUrl:       "https://example.com/" + core.EmailPlaceholderToken,
+				UserResetPasswordUrl:      "https://example.com/" + core.EmailPlaceholderToken,
+				UserConfirmEmailChangeUrl: "https://example.com/" + core.EmailPlaceholderToken,
+			},
+			false,
+		},
+	}
+
+	for i, scenario := range scenarios {
+		result := scenario.config.Validate()
+
+		if result != nil && !scenario.expectError {
+			t.Errorf("(%d) Didn't expect error, got %v", i, result)
+		}
+
+		if result == nil && scenario.expectError {
+			t.Errorf("(%d) Expected error, got nil", i)
+		}
+	}
+}
+
+func TestLogsConfigValidate(t *testing.T) {
+	scenarios := []struct {
+		config      core.LogsConfig
+		expectError bool
+	}{
+		// zero values
+		{
+			core.LogsConfig{},
+			false,
+		},
+		// invalid data
+		{
+			core.LogsConfig{MaxDays: -10},
+			true,
+		},
+		// valid data
+		{
+			core.LogsConfig{MaxDays: 1},
+			false,
+		},
+	}
+
+	for i, scenario := range scenarios {
+		result := scenario.config.Validate()
+
+		if result != nil && !scenario.expectError {
+			t.Errorf("(%d) Didn't expect error, got %v", i, result)
+		}
+
+		if result == nil && scenario.expectError {
+			t.Errorf("(%d) Expected error, got nil", i)
+		}
+	}
+}
+
+func TestAuthProviderConfigValidate(t *testing.T) {
+	scenarios := []struct {
+		config      core.AuthProviderConfig
+		expectError bool
+	}{
+		// zero values (disabled)
+		{
+			core.AuthProviderConfig{},
+			false,
+		},
+		// zero values (enabled)
+		{
+			core.AuthProviderConfig{Enabled: true},
+			true,
+		},
+		// invalid data
+		{
+			core.AuthProviderConfig{
+				Enabled:      true,
+				ClientId:     "",
+				ClientSecret: "",
+				AuthUrl:      "test",
+				TokenUrl:     "test",
+				UserApiUrl:   "test",
+			},
+			true,
+		},
+		// valid data (only the required)
+		{
+			core.AuthProviderConfig{
+				Enabled:      true,
+				ClientId:     "test",
+				ClientSecret: "test",
+			},
+			false,
+		},
+		// valid data (fill all fields)
+		{
+			core.AuthProviderConfig{
+				Enabled:      true,
+				ClientId:     "test",
+				ClientSecret: "test",
+				AuthUrl:      "https://example.com",
+				TokenUrl:     "https://example.com",
+				UserApiUrl:   "https://example.com",
+			},
+			false,
+		},
+	}
+
+	for i, scenario := range scenarios {
+		result := scenario.config.Validate()
+
+		if result != nil && !scenario.expectError {
+			t.Errorf("(%d) Didn't expect error, got %v", i, result)
+		}
+
+		if result == nil && scenario.expectError {
+			t.Errorf("(%d) Expected error, got nil", i)
+		}
+	}
+}
+
+func TestAuthProviderConfigSetupProvider(t *testing.T) {
+	provider := auth.NewGithubProvider()
+
+	// disabled config
+	c1 := core.AuthProviderConfig{Enabled: false}
+	if err := c1.SetupProvider(provider); err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+
+	c2 := core.AuthProviderConfig{
+		Enabled:      true,
+		ClientId:     "test_ClientId",
+		ClientSecret: "test_ClientSecret",
+		AuthUrl:      "test_AuthUrl",
+		UserApiUrl:   "test_UserApiUrl",
+		TokenUrl:     "test_TokenUrl",
+	}
+	if err := c2.SetupProvider(provider); err != nil {
+		t.Error(err)
+	}
+	encoded, _ := json.Marshal(c2)
+	expected := `{"enabled":true,"allowRegistrations":false,"clientId":"test_ClientId","clientSecret":"test_ClientSecret","authUrl":"test_AuthUrl","tokenUrl":"test_TokenUrl","userApiUrl":"test_UserApiUrl"}`
+	if string(encoded) != expected {
+		t.Errorf("Expected %s, got %s", expected, string(encoded))
+	}
+}
+
+func TestEmailAuthConfigValidate(t *testing.T) {
+	scenarios := []struct {
+		config      core.EmailAuthConfig
+		expectError bool
+	}{
+		// zero values (disabled)
+		{
+			core.EmailAuthConfig{},
+			false,
+		},
+		// zero values (enabled)
+		{
+			core.EmailAuthConfig{Enabled: true},
+			true,
+		},
+		// invalid data (only the required)
+		{
+			core.EmailAuthConfig{
+				Enabled:           true,
+				MinPasswordLength: 4,
+			},
+			true,
+		},
+		// valid data (only the required)
+		{
+			core.EmailAuthConfig{
+				Enabled:           true,
+				MinPasswordLength: 5,
+			},
+			false,
+		},
+		// invalid data (both OnlyDomains and ExceptDomains set)
+		{
+			core.EmailAuthConfig{
+				Enabled:           true,
+				MinPasswordLength: 5,
+				OnlyDomains:       []string{"example.com", "test.com"},
+				ExceptDomains:     []string{"example.com", "test.com"},
+			},
+			true,
+		},
+		// valid data (only onlyDomains set)
+		{
+			core.EmailAuthConfig{
+				Enabled:           true,
+				MinPasswordLength: 5,
+				OnlyDomains:       []string{"example.com", "test.com"},
+			},
+			false,
+		},
+		// valid data (only exceptDomains set)
+		{
+			core.EmailAuthConfig{
+				Enabled:           true,
+				MinPasswordLength: 5,
+				ExceptDomains:     []string{"example.com", "test.com"},
+			},
+			false,
+		},
+	}
+
+	for i, scenario := range scenarios {
+		result := scenario.config.Validate()
+
+		if result != nil && !scenario.expectError {
+			t.Errorf("(%d) Didn't expect error, got %v", i, result)
+		}
+
+		if result == nil && scenario.expectError {
+			t.Errorf("(%d) Expected error, got nil", i)
+		}
+	}
+}