39dc22ec3a
Generates a new repo from mathias/template-go-web via Gitea's generate API, then substitutes __PROJECT_NAME__ and __MODULE_PATH__ placeholders in six known files (best-effort, partial failure surfaced in result). Validates name regex, allowlist, template flag, and destination non-existence before generating. Adds Template field to gitea.Repo. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
267 lines
11 KiB
Go
267 lines
11 KiB
Go
package tools_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.d-ma.be/mathias/gitea-mcp/internal/allowlist"
|
|
"gitea.d-ma.be/mathias/gitea-mcp/internal/gitea"
|
|
"gitea.d-ma.be/mathias/gitea-mcp/internal/tools"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// substitutionFileList matches the tool's internal list — used to drive fake server routing.
|
|
var substitutionFileList = []string{
|
|
"go.mod",
|
|
"Taskfile.yml",
|
|
"Dockerfile",
|
|
".gitea/workflows/cd.yml",
|
|
"README.md",
|
|
".context/PROJECT.md",
|
|
}
|
|
|
|
// contentWithPlaceholder is a template file body that contains the placeholder.
|
|
const contentWithPlaceholder = "# __PROJECT_NAME__\nmodule __MODULE_PATH__\n"
|
|
|
|
func encodedContent(s string) string {
|
|
return base64.StdEncoding.EncodeToString([]byte(s))
|
|
}
|
|
|
|
// fileContentsJSON returns a JSON FileContents object for the given path.
|
|
func fileContentsJSON(path string) string {
|
|
enc := encodedContent(contentWithPlaceholder)
|
|
return fmt.Sprintf(`{"path":%q,"sha":"sha-%s","size":40,"content":%q,"encoding":"base64"}`,
|
|
path, strings.ReplaceAll(path, "/", "-"), enc)
|
|
}
|
|
|
|
// fileWriteResultJSON returns a minimal FileWriteResult JSON.
|
|
func fileWriteResultJSON(path string) string {
|
|
return fmt.Sprintf(`{"content":{"path":%q,"sha":"newsha","html_url":""},"commit":{"sha":"c","html_url":""}}`, path)
|
|
}
|
|
|
|
// newTemplateRepoJSON returns a JSON Repo marked as template.
|
|
func newTemplateRepoJSON(name string, isTemplate bool) string {
|
|
return fmt.Sprintf(`{"name":%q,"full_name":"mathias/%s","default_branch":"main","description":"","private":false,"clone_url":"http://gitea.example.com/mathias/%s.git","html_url":"http://gitea.example.com/mathias/%s","template":%v}`,
|
|
name, name, name, name, isTemplate)
|
|
}
|
|
|
|
// newGeneratedRepoJSON returns the JSON for the newly generated repo.
|
|
func newGeneratedRepoJSON(name string) string {
|
|
return fmt.Sprintf(`{"name":%q,"full_name":"mathias/%s","default_branch":"main","description":"","private":false,"clone_url":"http://gitea.example.com/mathias/%s.git","html_url":"http://gitea.example.com/mathias/%s","template":false}`,
|
|
name, name, name, name)
|
|
}
|
|
|
|
func newCreateProjectTool(srvURL string) *tools.CreateProjectFromTemplate {
|
|
c := gitea.NewClient(srvURL, "tok")
|
|
a := allowlist.New([]string{"mathias"})
|
|
return tools.NewCreateProjectFromTemplate(c, a, "mathias", "template-go-web")
|
|
}
|
|
|
|
// TestCreateProjectHappyPath: all 6 files served and substituted.
|
|
func TestCreateProjectHappyPath(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
switch {
|
|
// Template repo lookup
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/v1/repos/mathias/template-go-web":
|
|
_, _ = w.Write([]byte(newTemplateRepoJSON("template-go-web", true)))
|
|
|
|
// Destination repo lookup — 404 means it doesn't exist yet
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/v1/repos/mathias/new-svc":
|
|
w.WriteHeader(http.StatusNotFound)
|
|
_, _ = w.Write([]byte(`{"message":"not found"}`))
|
|
|
|
// Generate
|
|
case r.Method == http.MethodPost && r.URL.Path == "/api/v1/repos/mathias/template-go-web/generate":
|
|
w.WriteHeader(http.StatusCreated)
|
|
_, _ = w.Write([]byte(newGeneratedRepoJSON("new-svc")))
|
|
|
|
// File contents GET — handle all 6 substitution files
|
|
case r.Method == http.MethodGet && strings.HasPrefix(r.URL.Path, "/api/v1/repos/mathias/new-svc/contents/"):
|
|
filePath := strings.TrimPrefix(r.URL.Path, "/api/v1/repos/mathias/new-svc/contents/")
|
|
_, _ = w.Write([]byte(fileContentsJSON(filePath)))
|
|
|
|
// File contents PUT — handle all 6 substitution files
|
|
case r.Method == http.MethodPut && strings.HasPrefix(r.URL.Path, "/api/v1/repos/mathias/new-svc/contents/"):
|
|
filePath := strings.TrimPrefix(r.URL.Path, "/api/v1/repos/mathias/new-svc/contents/")
|
|
w.WriteHeader(http.StatusOK)
|
|
_, _ = w.Write([]byte(fileWriteResultJSON(filePath)))
|
|
|
|
default:
|
|
t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
|
|
w.WriteHeader(http.StatusNotFound)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
tool := newCreateProjectTool(srv.URL)
|
|
result, err := tool.Call(context.Background(), json.RawMessage(`{"owner":"mathias","name":"new-svc","description":"A new service"}`))
|
|
require.NoError(t, err)
|
|
|
|
var out struct {
|
|
FullName string `json:"full_name"`
|
|
HTMLURL string `json:"html_url"`
|
|
CloneURL string `json:"clone_url"`
|
|
DefaultBranch string `json:"default_branch"`
|
|
FilesSubstituted []string `json:"files_substituted"`
|
|
PartialFailure string `json:"partial_failure,omitempty"`
|
|
}
|
|
require.NoError(t, json.Unmarshal(result, &out))
|
|
|
|
assert.Equal(t, "mathias/new-svc", out.FullName)
|
|
assert.Equal(t, "http://gitea.example.com/mathias/new-svc", out.HTMLURL)
|
|
assert.Equal(t, "main", out.DefaultBranch)
|
|
assert.ElementsMatch(t, substitutionFileList, out.FilesSubstituted)
|
|
assert.Empty(t, out.PartialFailure)
|
|
}
|
|
|
|
// TestCreateProjectNameRegexFailure: invalid name returns ErrValidation without hitting network.
|
|
func TestCreateProjectNameRegexFailure(t *testing.T) {
|
|
tool := tools.NewCreateProjectFromTemplate(
|
|
gitea.NewClient("http://unused", ""),
|
|
allowlist.New([]string{"mathias"}),
|
|
"mathias", "template-go-web",
|
|
)
|
|
_, err := tool.Call(context.Background(), json.RawMessage(`{"owner":"mathias","name":"INVALID_NAME"}`))
|
|
require.Error(t, err)
|
|
assert.ErrorIs(t, err, gitea.ErrValidation)
|
|
}
|
|
|
|
// TestCreateProjectAllowlistRejects: owner not in allowlist returns error.
|
|
func TestCreateProjectAllowlistRejects(t *testing.T) {
|
|
tool := tools.NewCreateProjectFromTemplate(
|
|
gitea.NewClient("http://unused", ""),
|
|
allowlist.New([]string{"mathias"}),
|
|
"mathias", "template-go-web",
|
|
)
|
|
_, err := tool.Call(context.Background(), json.RawMessage(`{"owner":"evil","name":"new-svc"}`))
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "allowlist")
|
|
}
|
|
|
|
// TestCreateProjectTemplateNotTemplate: template repo exists but is not marked as template.
|
|
func TestCreateProjectTemplateNotTemplate(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
// Template lookup returns a non-template repo.
|
|
if r.Method == http.MethodGet && r.URL.Path == "/api/v1/repos/mathias/template-go-web" {
|
|
_, _ = w.Write([]byte(newTemplateRepoJSON("template-go-web", false)))
|
|
return
|
|
}
|
|
t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
|
|
w.WriteHeader(http.StatusNotFound)
|
|
}))
|
|
defer srv.Close()
|
|
|
|
tool := newCreateProjectTool(srv.URL)
|
|
_, err := tool.Call(context.Background(), json.RawMessage(`{"owner":"mathias","name":"new-svc"}`))
|
|
require.Error(t, err)
|
|
assert.ErrorIs(t, err, gitea.ErrValidation)
|
|
}
|
|
|
|
// TestCreateProjectDestinationExists: destination repo already exists.
|
|
func TestCreateProjectDestinationExists(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
switch {
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/v1/repos/mathias/template-go-web":
|
|
_, _ = w.Write([]byte(newTemplateRepoJSON("template-go-web", true)))
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/v1/repos/mathias/new-svc":
|
|
// Destination exists — return 200.
|
|
_, _ = w.Write([]byte(newTemplateRepoJSON("new-svc", false)))
|
|
default:
|
|
t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
|
|
w.WriteHeader(http.StatusNotFound)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
tool := newCreateProjectTool(srv.URL)
|
|
_, err := tool.Call(context.Background(), json.RawMessage(`{"owner":"mathias","name":"new-svc"}`))
|
|
require.Error(t, err)
|
|
assert.ErrorIs(t, err, gitea.ErrConflict)
|
|
}
|
|
|
|
// TestCreateProjectMidPassSubstitutionFailure: the 4th file (.gitea/workflows/cd.yml) PUT fails;
|
|
// the first 3 are substituted, partial_failure is populated, no Go error is returned.
|
|
func TestCreateProjectMidPassSubstitutionFailure(t *testing.T) {
|
|
// Files that should succeed (index 0-2 in substitutionFileList).
|
|
successFiles := map[string]bool{
|
|
"go.mod": true,
|
|
"Taskfile.yml": true,
|
|
"Dockerfile": true,
|
|
}
|
|
// The 4th file (index 3) is .gitea/workflows/cd.yml — its PUT returns 500.
|
|
failFile := ".gitea/workflows/cd.yml"
|
|
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
switch {
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/v1/repos/mathias/template-go-web":
|
|
_, _ = w.Write([]byte(newTemplateRepoJSON("template-go-web", true)))
|
|
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/v1/repos/mathias/new-svc":
|
|
w.WriteHeader(http.StatusNotFound)
|
|
_, _ = w.Write([]byte(`{"message":"not found"}`))
|
|
|
|
case r.Method == http.MethodPost && r.URL.Path == "/api/v1/repos/mathias/template-go-web/generate":
|
|
w.WriteHeader(http.StatusCreated)
|
|
_, _ = w.Write([]byte(newGeneratedRepoJSON("new-svc")))
|
|
|
|
case r.Method == http.MethodGet && strings.HasPrefix(r.URL.Path, "/api/v1/repos/mathias/new-svc/contents/"):
|
|
filePath := strings.TrimPrefix(r.URL.Path, "/api/v1/repos/mathias/new-svc/contents/")
|
|
_, _ = w.Write([]byte(fileContentsJSON(filePath)))
|
|
|
|
case r.Method == http.MethodPut && strings.HasPrefix(r.URL.Path, "/api/v1/repos/mathias/new-svc/contents/"):
|
|
filePath := strings.TrimPrefix(r.URL.Path, "/api/v1/repos/mathias/new-svc/contents/")
|
|
if filePath == failFile {
|
|
// Simulate upstream 500.
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
_, _ = w.Write([]byte(`{"message":"internal server error"}`))
|
|
return
|
|
}
|
|
if !successFiles[filePath] {
|
|
t.Errorf("unexpected PUT for file: %s", filePath)
|
|
w.WriteHeader(http.StatusNotFound)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusOK)
|
|
_, _ = w.Write([]byte(fileWriteResultJSON(filePath)))
|
|
|
|
default:
|
|
t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
|
|
w.WriteHeader(http.StatusNotFound)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
tool := newCreateProjectTool(srv.URL)
|
|
result, err := tool.Call(context.Background(), json.RawMessage(`{"owner":"mathias","name":"new-svc"}`))
|
|
// Best-effort: no Go error returned, partial state in result.
|
|
require.NoError(t, err)
|
|
|
|
var out struct {
|
|
FullName string `json:"full_name"`
|
|
FilesSubstituted []string `json:"files_substituted"`
|
|
PartialFailure string `json:"partial_failure,omitempty"`
|
|
}
|
|
require.NoError(t, json.Unmarshal(result, &out))
|
|
|
|
// First 3 files should be in FilesSubstituted.
|
|
assert.Len(t, out.FilesSubstituted, 3)
|
|
assert.Contains(t, out.FilesSubstituted, "go.mod")
|
|
assert.Contains(t, out.FilesSubstituted, "Taskfile.yml")
|
|
assert.Contains(t, out.FilesSubstituted, "Dockerfile")
|
|
assert.NotContains(t, out.FilesSubstituted, failFile)
|
|
|
|
// partial_failure should be non-empty.
|
|
assert.NotEmpty(t, out.PartialFailure, "partial_failure should be populated on mid-pass failure")
|
|
}
|