Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package gitrepo
import (
"context"
"errors"
"fmt"
"strings"
"testing"
"github.com/getarcaneapp/arcane/types/v2/base"
"github.com/getarcaneapp/arcane/types/v2/gitops"
"github.com/getarcaneapp/arcane/types/v2/user"
"github.com/libtnb/sqlite"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.getarcane.app/kit/pkg/mapping"
"go.getarcane.app/sys/crypto"
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/event"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
)
func setupGitRepositoryServiceTestInternal(t *testing.T) *GitRepositoryService {
t.Helper()
dsn := fmt.Sprintf("file:%s?mode=memory&cache=shared", strings.NewReplacer("/", "_", " ", "_").Replace(t.Name()))
db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, db.AutoMigrate(
&GitRepository{},
&event.Event{},
&settings.SettingVariable{},
))
// DeleteRepository only counts gitops_syncs rows; the model lives in the
// project domain, which this package cannot import from an in-package test.
require.NoError(t, db.Exec("CREATE TABLE IF NOT EXISTS gitops_syncs (id text PRIMARY KEY, repository_id text)").Error)
sqlDB, err := db.DB()
require.NoError(t, err)
sqlDB.SetMaxOpenConns(1)
sqlDB.SetMaxIdleConns(1)
crypto.InitEncryption(&crypto.Config{
EncryptionKey: "test-encryption-key-for-git-repos-32bytes-min",
Environment: "test",
})
wrappedDB := &database.DB{DB: db}
settingsService, err := newSettingsServiceForTestInternal(t, t.Context(), wrappedDB)
require.NoError(t, err)
eventService := event.NewEventService(wrappedDB, &config.Config{}, nil)
return NewGitRepositoryService(wrappedDB, t.TempDir(), eventService, settingsService)
}
func newSettingsServiceForTestInternal(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
return svc, err
}
func createGitRepositoryServiceTestRepoInternal(t *testing.T, svc *GitRepositoryService, req gitops.CreateRepositoryRequest) *GitRepository {
t.Helper()
repo, err := svc.CreateRepository(t.Context(), req, user.Actor{
ID: "admin-1",
Username: "admin",
})
require.NoError(t, err)
mapped, err := mapping.MapOne[*GitRepository, gitops.GitRepository](repo)
require.NoError(t, err)
assert.Equal(t, req.Token != "", mapped.HasToken)
assert.Equal(t, req.SSHKey != "", mapped.HasSshKey)
repositories, _, err := svc.GetRepositoriesPaginated(t.Context(), pagination.QueryParams{Limit: -1})
require.NoError(t, err)
require.Len(t, repositories, 1)
assert.Equal(t, mapped.HasToken, repositories[0].HasToken)
assert.Equal(t, mapped.HasSshKey, repositories[0].HasSshKey)
return repo
}
func TestGitRepositoryService_UpdateRepository_RejectsURLChangeWhenStoredTokenWouldBeReused(t *testing.T) {
svc := setupGitRepositoryServiceTestInternal(t)
repo := createGitRepositoryServiceTestRepoInternal(t, svc, gitops.CreateRepositoryRequest{
Name: "prod-repo",
URL: "https://github.com/acme/private.git",
AuthType: "http",
Username: "deploy",
Token: "ghp_old_token",
})
_, err := svc.UpdateRepository(t.Context(), repo.ID, gitops.UpdateRepositoryRequest{
URL: new("https://attacker.tld/repo.git"),
}, user.Actor{})
require.Error(t, err)
require.ErrorIs(t, err, common.ErrValidation)
fieldErr, ok := errors.AsType[*base.FieldError](err)
require.True(t, ok)
assert.Equal(t, "token", fieldErr.Field)
assert.Contains(t, err.Error(), "repository URL")
stored, loadErr := svc.GetRepositoryByID(t.Context(), repo.ID)
require.NoError(t, loadErr)
assert.Equal(t, "https://github.com/acme/private.git", stored.URL)
assert.Equal(t, repo.Token, stored.Token)
}
func TestGitRepositoryService_UpdateRepository_RejectsURLChangeWhenStoredSSHKeyWouldBeReused(t *testing.T) {
svc := setupGitRepositoryServiceTestInternal(t)
repo := createGitRepositoryServiceTestRepoInternal(t, svc, gitops.CreateRepositoryRequest{
Name: "infra-repo",
URL: "[email protected]:acme/private.git",
AuthType: "ssh",
SSHKey: "-----BEGIN OPENSSH PRIVATE KEY-----\nkey-material\n-----END OPENSSH PRIVATE KEY-----",
})
_, err := svc.UpdateRepository(t.Context(), repo.ID, gitops.UpdateRepositoryRequest{
URL: new("[email protected]:acme/private.git"),
}, user.Actor{})
require.Error(t, err)
require.ErrorIs(t, err, common.ErrValidation)
fieldErr, ok := errors.AsType[*base.FieldError](err)
require.True(t, ok)
assert.Equal(t, "sshKey", fieldErr.Field)
assert.Contains(t, err.Error(), "repository URL")
stored, loadErr := svc.GetRepositoryByID(t.Context(), repo.ID)
require.NoError(t, loadErr)
assert.Equal(t, "[email protected]:acme/private.git", stored.URL)
assert.Equal(t, repo.SSHKey, stored.SSHKey)
}
func TestGitRepositoryService_UpdateRepository_RejectsURLChangeWhenStoredTokenAndSSHKeyWouldBeReused(t *testing.T) {
svc := setupGitRepositoryServiceTestInternal(t)
repo := createGitRepositoryServiceTestRepoInternal(t, svc, gitops.CreateRepositoryRequest{
Name: "hybrid-repo",
URL: "https://github.com/acme/private.git",
AuthType: "http",
Username: "deploy",
Token: "ghp_old_token",
SSHKey: "-----BEGIN OPENSSH PRIVATE KEY-----\nkey-material\n-----END OPENSSH PRIVATE KEY-----",
})
_, err := svc.UpdateRepository(t.Context(), repo.ID, gitops.UpdateRepositoryRequest{
URL: new("https://attacker.tld/repo.git"),
}, user.Actor{})
require.Error(t, err)
var apiErr *common.APIError
require.ErrorAs(t, err, &apiErr)
assert.Equal(t, common.APIErrorCodeValidationError, apiErr.Code)
assert.Contains(t, apiErr.Message, "repository URL")
assert.Equal(t, map[string]any{"fields": []string{"sshKey", "token"}}, apiErr.Details)
}
func TestGitRepositoryService_UpdateRepository_AllowsURLChangeWhenTokenIsResupplied(t *testing.T) {
svc := setupGitRepositoryServiceTestInternal(t)
repo := createGitRepositoryServiceTestRepoInternal(t, svc, gitops.CreateRepositoryRequest{
Name: "prod-repo",
URL: "https://github.com/acme/private.git",
AuthType: "http",
Username: "deploy",
Token: "ghp_old_token",
})
updated, err := svc.UpdateRepository(t.Context(), repo.ID, gitops.UpdateRepositoryRequest{
URL: new("https://github.com/acme/private-rotated.git"),
Token: new("ghp_new_token"),
}, user.Actor{})
require.NoError(t, err)
assert.Equal(t, "https://github.com/acme/private-rotated.git", updated.URL)
decryptedToken, decryptErr := crypto.Decrypt(updated.Token)
require.NoError(t, decryptErr)
assert.Equal(t, "ghp_new_token", decryptedToken)
mapped, err := mapping.MapOne[*GitRepository, gitops.GitRepository](updated)
require.NoError(t, err)
assert.True(t, mapped.HasToken)
assert.False(t, mapped.HasSshKey)
}
func TestGitRepositoryService_UpdateRepository_AllowsURLChangeWhenTokenIsCleared(t *testing.T) {
svc := setupGitRepositoryServiceTestInternal(t)
repo := createGitRepositoryServiceTestRepoInternal(t, svc, gitops.CreateRepositoryRequest{
Name: "prod-repo",
URL: "https://github.com/acme/private.git",
AuthType: "http",
Username: "deploy",
Token: "ghp_old_token",
})
updated, err := svc.UpdateRepository(t.Context(), repo.ID, gitops.UpdateRepositoryRequest{
URL: new("https://github.com/acme/public.git"),
Token: new(""),
}, user.Actor{})
require.NoError(t, err)
assert.Equal(t, "https://github.com/acme/public.git", updated.URL)
assert.Empty(t, updated.Token)
mapped, err := mapping.MapOne[*GitRepository, gitops.GitRepository](updated)
require.NoError(t, err)
assert.False(t, mapped.HasToken)
assert.False(t, mapped.HasSshKey)
}
func TestGitRepositoryService_UpdateRepository_AllowsSameURLWithoutCredentialResupply(t *testing.T) {
svc := setupGitRepositoryServiceTestInternal(t)
repo := createGitRepositoryServiceTestRepoInternal(t, svc, gitops.CreateRepositoryRequest{
Name: "prod-repo",
URL: "https://github.com/acme/private.git",
AuthType: "http",
Username: "deploy",
Token: "ghp_old_token",
})
updated, err := svc.UpdateRepository(t.Context(), repo.ID, gitops.UpdateRepositoryRequest{
URL: new("https://github.com/acme/private.git"),
Username: new("deploy-bot"),
}, user.Actor{})
require.NoError(t, err)
assert.Equal(t, "deploy-bot", updated.Username)
decryptedToken, decryptErr := crypto.Decrypt(updated.Token)
require.NoError(t, decryptErr)
assert.Equal(t, "ghp_old_token", decryptedToken)
}