test: add e2e tests with local Forgejo instance (#201)

* feat(forge): add new forge for forgejo

We only support repositories hosted on Forgejo instances, but not
Forgejo Actions or Woodpecker as CI solutions for now.

* test(e2e): introduce e2e test framework with local forgejo

test/e2e/forge.go

@@ -0,0 +1,19 @@
+package e2e
+
+import (
+	"context"
+	"testing"
+)
+
+type TestForge interface {
+	Init(ctx context.Context, runID string) error
+	CreateRepo(t *testing.T, opts CreateRepoOpts) (*Repository, error)
+
+	RunArguments() []string
+}
+
+type CreateRepoOpts struct {
+	Name          string
+	Description   string
+	DefaultBranch string
+}

test/e2e/forgejo/app.ini

@@ -0,0 +1,23 @@
+WORK_PATH = /data/gitea
+
+[database]
+DB_TYPE = sqlite3
+PATH = /data/gitea/forgejo.db
+
+[security]
+INSTALL_LOCK = true
+SECRET_KEY = releaser-pleaser
+INTERNAL_TOKEN = releaser-pleaser
+
+[service]
+REGISTER_EMAIL_CONFIRM = false
+ENABLE_NOTIFY_MAIL = false
+DISABLE_REGISTRATION = true
+
+[server]
+DOMAIN = localhost
+HTTP_PORT = 3000
+ROOT_URL = http://localhost:3000/
+
+[oauth2]
+JWT_SECRET = rTD-FL2n_aBB6v4AOcr5lBvwgZ6PSr3HGZAuNH6nMu8

test/e2e/forgejo/compose.yaml

@@ -0,0 +1,16 @@
+services:
+  forgejo:
+    image: codeberg.org/forgejo/forgejo:11
+    ports:
+      - '3000:3000'
+      - '222:22'
+    volumes:
+      - data:/data/gitea
+      - ./app.ini:/data/gitea/conf/app.ini:ro
+
+    healthcheck:
+      test: ["CMD", "curl", "localhost:3000/api/healthz"]
+
+
+volumes:
+  data:

test/e2e/forgejo/forge.go

@@ -0,0 +1,113 @@
+package forgejo
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"os/exec"
+	"strings"
+	"testing"
+
+	"codeberg.org/mvdkleijn/forgejo-sdk/forgejo/v2"
+
+	"github.com/apricote/releaser-pleaser/test/e2e"
+)
+
+const (
+	TestAPIURL = "http://localhost:3000"
+
+	TestUserNameTemplate  = "rp-%s"
+	TestUserPassword      = "releaser-pleaser"
+	TestUserEmailTemplate = "releaser-pleaser-%s@example.com"
+	TestTokenName         = "rp"
+	TestTokenScopes       = "write:user,write:issue,write:repository"
+)
+
+type TestForge struct {
+	username string
+	token    string
+	client   *forgejo.Client
+}
+
+func (f *TestForge) Init(ctx context.Context, runID string) error {
+	if err := f.initUser(ctx, runID); err != nil {
+		return err
+	}
+	if err := f.initClient(ctx); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (f *TestForge) initUser(ctx context.Context, runID string) error {
+	f.username = fmt.Sprintf(TestUserNameTemplate, runID)
+
+	//gosec:disable G204
+	if output, err := exec.CommandContext(ctx,
+		"docker", "compose", "exec", "--user=1000", "forgejo",
+		"forgejo", "admin", "user", "create",
+		"--username", f.username,
+		"--password", TestUserPassword,
+		"--email", fmt.Sprintf(TestUserEmailTemplate, runID),
+		"--must-change-password=false",
+	).CombinedOutput(); err != nil {
+		slog.Debug("create forgejo user output", "output", output)
+		return fmt.Errorf("failed to create forgejo user: %w", err)
+	}
+
+	//gosec:disable G204
+	token, err := exec.CommandContext(ctx,
+		"docker", "compose", "exec", "--user=1000", "forgejo",
+		"forgejo", "admin", "user", "generate-access-token",
+		"--username", f.username,
+		"--token-name", TestTokenName,
+		"--scopes", TestTokenScopes,
+		"--raw",
+	).Output()
+	if err != nil {
+		return fmt.Errorf("failed to create forgejo token: %w", err)
+	}
+
+	f.token = strings.TrimSpace(string(token))
+
+	return nil
+}
+
+func (f *TestForge) initClient(ctx context.Context) (err error) {
+	f.client, err = forgejo.NewClient(TestAPIURL,
+		forgejo.SetToken(f.token),
+		forgejo.SetUserAgent("releaser-pleaser-e2e-tests"),
+		forgejo.SetContext(ctx),
+		// forgejo.SetDebugMode(),
+	)
+	return err
+}
+
+func (f *TestForge) CreateRepo(t *testing.T, opts e2e.CreateRepoOpts) (*e2e.Repository, error) {
+	t.Helper()
+
+	repo, _, err := f.client.CreateRepo(forgejo.CreateRepoOption{
+		Name:          opts.Name,
+		Description:   opts.Description,
+		DefaultBranch: opts.DefaultBranch,
+		Readme:        "Default",
+		AutoInit:      true,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &e2e.Repository{
+		Name: repo.Name,
+	}, nil
+}
+
+func (f *TestForge) RunArguments() []string {
+	return []string{"--forge=forgejo",
+		fmt.Sprintf("--owner=%s", f.username),
+		fmt.Sprintf("--api-url=%s", TestAPIURL),
+		fmt.Sprintf("--api-token=%s", f.token),
+		fmt.Sprintf("--username=%s", f.username),
+	}
+}

test/e2e/forgejo/forgejo_test.go

@@ -0,0 +1,39 @@
+//go:build e2e_forgejo
+
+package forgejo
+
+import (
+	"context"
+	"log/slog"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/apricote/releaser-pleaser/test/e2e"
+)
+
+var (
+	f *e2e.Framework
+)
+
+func TestMain(m *testing.M) {
+	ctx := context.Background()
+
+	var err error
+	f, err = e2e.NewFramework(ctx, &TestForge{})
+	if err != nil {
+		slog.Error("failed to set up test framework", "err", err)
+	}
+
+	os.Exit(m.Run())
+}
+
+func TestCreateRepository(t *testing.T) {
+	_ = f.NewRepository(t, t.Name())
+}
+
+func TestRun(t *testing.T) {
+	repo := f.NewRepository(t, t.Name())
+	require.NoError(t, f.Run(t, repo, []string{}))
+}

test/e2e/framework.go

@@ -0,0 +1,96 @@
+package e2e
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/apricote/releaser-pleaser/cmd/rp/cmd"
+)
+
+const (
+	TestDefaultBranch = "main"
+)
+
+func randomString() string {
+	randomBytes := make([]byte, 4)
+	if _, err := rand.Read(randomBytes); err != nil {
+		panic(err)
+	}
+	return hex.EncodeToString(randomBytes)
+}
+
+type Framework struct {
+	runID string
+	forge TestForge
+}
+
+func NewFramework(ctx context.Context, forge TestForge) (*Framework, error) {
+	f := &Framework{
+		runID: randomString(),
+		forge: forge,
+	}
+
+	err := forge.Init(ctx, f.runID)
+	if err != nil {
+		return nil, err
+	}
+
+	return f, nil
+}
+
+type Repository struct {
+	Name string
+}
+
+func (f *Framework) NewRepository(t *testing.T, name string) *Repository {
+	t.Helper()
+
+	r := &Repository{
+		Name: fmt.Sprintf("%s-%s-%s", name, f.runID, randomString()),
+	}
+
+	repo, err := f.forge.CreateRepo(t, CreateRepoOpts{
+		Name:          r.Name,
+		Description:   name,
+		DefaultBranch: TestDefaultBranch,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, repo)
+
+	return r
+}
+
+func (f *Framework) Run(t *testing.T, r *Repository, extraFiles []string) error {
+	t.Helper()
+
+	ctx := t.Context()
+
+	rootCmd := cmd.NewRootCmd()
+	rootCmd.SetArgs(append([]string{
+		"run",
+		fmt.Sprintf("--repo=%s", r.Name),
+		fmt.Sprintf("--extra-files=%q", strings.Join(extraFiles, "\n")),
+	}, f.forge.RunArguments()...))
+
+	var stdout, stderr bytes.Buffer
+
+	rootCmd.SetOut(&stdout)
+	rootCmd.SetErr(&stderr)
+
+	err := rootCmd.ExecuteContext(ctx)
+
+	stdoutString := stdout.String()
+	stderrString := stderr.String()
+
+	t.Log(stdoutString)
+	t.Log(stderrString)
+
+	return err
+}