332 lines
10 KiB
Go
332 lines
10 KiB
Go
package cli
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.knownelement.com/ukrrs/mopac-gitea-go/internal/fakegitea"
|
|
)
|
|
|
|
const fakeToken = "fake-gitea-token-0123456789"
|
|
|
|
// run boots a fake Gitea, points the CLI at it via env, and runs one
|
|
// command; it returns the exit code plus captured output.
|
|
func run(t *testing.T, srv *fakegitea.Server, args ...string) (int, string, string) {
|
|
t.Helper()
|
|
t.Setenv("GITEA_URL", srv.URL)
|
|
t.Setenv("GITEA_KEY", fakeToken)
|
|
var out, errb bytes.Buffer
|
|
code := Run(args, &out, &errb)
|
|
return code, out.String(), errb.String()
|
|
}
|
|
|
|
func newServer(t *testing.T) *fakegitea.Server {
|
|
t.Helper()
|
|
srv := fakegitea.New(fakeToken, "ukrrs")
|
|
t.Cleanup(srv.Close)
|
|
return srv
|
|
}
|
|
|
|
func TestHelpAndUsage(t *testing.T) {
|
|
srv := newServer(t)
|
|
|
|
tests := []struct {
|
|
name string
|
|
args []string
|
|
code int
|
|
}{
|
|
{name: "help", args: []string{"help"}, code: 0},
|
|
{name: "no args", args: nil, code: 1},
|
|
{name: "unknown command", args: []string{"frobnicate"}, code: 1},
|
|
{name: "unknown subcommand", args: []string{"repo", "frob"}, code: 1},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
code, _, errOut := run(t, srv, tt.args...)
|
|
if code != tt.code {
|
|
t.Fatalf("code = %d, want %d (stderr: %s)", code, tt.code, errOut)
|
|
}
|
|
})
|
|
}
|
|
|
|
code, out, _ := run(t, srv, "help")
|
|
if code != 0 || !strings.Contains(out, "mgit repo create") || !strings.Contains(out, "GITEA_URL") {
|
|
t.Fatalf("help output = %q", out)
|
|
}
|
|
}
|
|
|
|
func TestRepoLifecycle(t *testing.T) {
|
|
srv := newServer(t)
|
|
|
|
code, out, errOut := run(t, srv, "repo", "create", "-n", "vertical-x", "--desc", "one vertical",
|
|
"--private", "--auto-init")
|
|
if code != 0 {
|
|
t.Fatalf("repo create: code=%d stderr=%s", code, errOut)
|
|
}
|
|
if !strings.Contains(out, "ukrrs/vertical-x") || !strings.Contains(out, "private") {
|
|
t.Fatalf("out = %q", out)
|
|
}
|
|
|
|
code, out, errOut = run(t, srv, "repo", "create", "-n", "vertical-y", "-o", "json")
|
|
if code != 0 {
|
|
t.Fatalf("repo create json: %s", errOut)
|
|
}
|
|
var repo struct {
|
|
FullName string `json:"full_name"`
|
|
Private bool `json:"private"`
|
|
}
|
|
if err := json.Unmarshal([]byte(out), &repo); err != nil {
|
|
t.Fatalf("json out: %v (%s)", err, out)
|
|
}
|
|
if repo.FullName != "ukrrs/vertical-y" || repo.Private {
|
|
t.Fatalf("json = %+v", repo)
|
|
}
|
|
|
|
code, out, errOut = run(t, srv, "repo", "list")
|
|
if code != 0 {
|
|
t.Fatalf("repo list: %s", errOut)
|
|
}
|
|
if !strings.Contains(out, "ukrrs/vertical-x") || !strings.Contains(out, "ukrrs/vertical-y") {
|
|
t.Fatalf("list = %q", out)
|
|
}
|
|
|
|
code, out, errOut = run(t, srv, "repo", "list", "--owner", "other")
|
|
if code != 0 {
|
|
t.Fatalf("repo list other: %s", errOut)
|
|
}
|
|
if strings.Contains(out, "ukrrs/") {
|
|
t.Fatalf("list other = %q", out)
|
|
}
|
|
|
|
code, out, errOut = run(t, srv, "repo", "show", "ukrrs/vertical-x")
|
|
if code != 0 || !strings.Contains(out, "one vertical") {
|
|
t.Fatalf("repo show: code=%d out=%q err=%s", code, out, errOut)
|
|
}
|
|
|
|
// Duplicate create -> exit 2, one-line stderr with the http code.
|
|
code, out, errOut = run(t, srv, "repo", "create", "-n", "vertical-x")
|
|
if code != 2 {
|
|
t.Fatalf("dup create code = %d, want 2", code)
|
|
}
|
|
if !strings.Contains(errOut, "http 409") || strings.Count(strings.TrimRight(errOut, "\n"), "\n") != 0 {
|
|
t.Fatalf("dup stderr = %q", errOut)
|
|
}
|
|
}
|
|
|
|
func TestRepoCreateMissingName(t *testing.T) {
|
|
srv := newServer(t)
|
|
code, _, errOut := run(t, srv, "repo", "create")
|
|
if code != 1 || !strings.Contains(errOut, "-n") {
|
|
t.Fatalf("code=%d err=%q", code, errOut)
|
|
}
|
|
}
|
|
|
|
func TestBranchList(t *testing.T) {
|
|
srv := newServer(t)
|
|
srv.AddRepo("ukrrs", "MOPAC", "main", "main", "feat/quota")
|
|
|
|
code, out, errOut := run(t, srv, "branch", "list", "ukrrs/MOPAC")
|
|
if code != 0 {
|
|
t.Fatalf("branch list: %s", errOut)
|
|
}
|
|
if !strings.Contains(out, "main") || !strings.Contains(out, "feat/quota") {
|
|
t.Fatalf("out = %q", out)
|
|
}
|
|
|
|
code, out, errOut = run(t, srv, "branch", "list", "ukrrs/MOPAC", "-o", "json")
|
|
if code != 0 {
|
|
t.Fatalf("branch list json: %s", errOut)
|
|
}
|
|
var branches []struct {
|
|
Name string `json:"name"`
|
|
}
|
|
if err := json.Unmarshal([]byte(out), &branches); err != nil || len(branches) != 2 {
|
|
t.Fatalf("json = %s (%v)", out, err)
|
|
}
|
|
|
|
if code, _, errOut = run(t, srv, "branch", "list", "ukrrs/absent"); code != 2 || !strings.Contains(errOut, "http 404") {
|
|
t.Fatalf("missing repo: code=%d err=%q", code, errOut)
|
|
}
|
|
}
|
|
|
|
func TestStatusCommands(t *testing.T) {
|
|
srv := newServer(t)
|
|
srv.AddRepo("ukrrs", "MOPAC", "main", "main")
|
|
sha := srv.AddBranch("ukrrs", "MOPAC", "feat/quota")
|
|
|
|
code, out, errOut := run(t, srv, "status", "create", "ukrrs/MOPAC", sha,
|
|
"--state", "success", "--context", "ci/lint", "--description", "clean")
|
|
if code != 0 {
|
|
t.Fatalf("status create: %s", errOut)
|
|
}
|
|
if !strings.Contains(out, "success") || !strings.Contains(out, "ci/lint") {
|
|
t.Fatalf("out = %q", out)
|
|
}
|
|
|
|
// Invalid state is a usage error before any request.
|
|
if code, _, errOut = run(t, srv, "status", "create", "ukrrs/MOPAC", sha, "--state", "green"); code != 1 {
|
|
t.Fatalf("invalid state code = %d err=%q", code, errOut)
|
|
}
|
|
|
|
code, out, errOut = run(t, srv, "status", "list", "ukrrs/MOPAC", "feat/quota")
|
|
if code != 0 {
|
|
t.Fatalf("status list: %s", errOut)
|
|
}
|
|
if !strings.Contains(out, "success") || !strings.Contains(out, "ci/lint") {
|
|
t.Fatalf("out = %q", out)
|
|
}
|
|
}
|
|
|
|
func TestPullRequestFlow(t *testing.T) {
|
|
srv := newServer(t)
|
|
srv.AddRepo("ukrrs", "MOPAC", "main", "main", "feat/quota")
|
|
|
|
bodyFile := filepath.Join(t.TempDir(), "body.md")
|
|
os.WriteFile(bodyFile, []byte("## Scope\n- quota accounting"), 0o600)
|
|
|
|
code, out, errOut := run(t, srv, "pr", "create", "ukrrs/MOPAC",
|
|
"--title", "Quota accounting", "--body", bodyFile,
|
|
"--base", "main", "--head", "feat/quota", "-o", "json")
|
|
if code != 0 {
|
|
t.Fatalf("pr create: %s", errOut)
|
|
}
|
|
var pr struct {
|
|
Number int64 `json:"number"`
|
|
State string `json:"state"`
|
|
}
|
|
if err := json.Unmarshal([]byte(out), &pr); err != nil || pr.Number != 1 || pr.State != "open" {
|
|
t.Fatalf("json = %s (%v)", out, err)
|
|
}
|
|
|
|
code, out, errOut = run(t, srv, "pr", "list", "ukrrs/MOPAC")
|
|
if code != 0 || !strings.Contains(out, "Quota accounting") || !strings.Contains(out, "#1") {
|
|
t.Fatalf("pr list: code=%d out=%q err=%s", code, out, errOut)
|
|
}
|
|
|
|
code, out, errOut = run(t, srv, "pr", "show", "ukrrs/MOPAC", "1")
|
|
if code != 0 || !strings.Contains(out, "quota accounting") || !strings.Contains(out, "main..feat/quota") {
|
|
t.Fatalf("pr show: code=%d out=%q err=%s", code, out, errOut)
|
|
}
|
|
|
|
code, out, errOut = run(t, srv, "pr", "merge", "ukrrs/MOPAC", "1", "--do", "squash")
|
|
if code != 0 || !strings.Contains(out, "#1") || !strings.Contains(out, "squash") {
|
|
t.Fatalf("pr merge: code=%d out=%q err=%s", code, out, errOut)
|
|
}
|
|
|
|
// Merged: the open list is empty and re-merge fails with 409.
|
|
code, out, _ = run(t, srv, "pr", "list", "ukrrs/MOPAC")
|
|
if code != 0 || strings.Contains(out, "Quota accounting") {
|
|
t.Fatalf("pr list after merge = %q", out)
|
|
}
|
|
if code, _, errOut = run(t, srv, "pr", "merge", "ukrrs/MOPAC", "1"); code != 2 || !strings.Contains(errOut, "http 409") {
|
|
t.Fatalf("re-merge: code=%d err=%q", code, errOut)
|
|
}
|
|
}
|
|
|
|
func TestPullRequestUsageErrors(t *testing.T) {
|
|
srv := newServer(t)
|
|
srv.AddRepo("ukrrs", "MOPAC", "main", "main", "feat/quota")
|
|
|
|
tests := []struct {
|
|
name string
|
|
args []string
|
|
}{
|
|
{"missing title", []string{"pr", "create", "ukrrs/MOPAC", "--base", "main", "--head", "feat/quota"}},
|
|
{"missing base", []string{"pr", "create", "ukrrs/MOPAC", "--title", "t", "--head", "feat/quota"}},
|
|
{"missing head", []string{"pr", "create", "ukrrs/MOPAC", "--title", "t", "--base", "main"}},
|
|
{"bad repo arg", []string{"pr", "create", "MOPAC", "--title", "t", "--base", "main", "--head", "x"}},
|
|
{"non-numeric index", []string{"pr", "merge", "ukrrs/MOPAC", "abc"}},
|
|
{"bad merge style", []string{"pr", "merge", "ukrrs/MOPAC", "1", "--do", "blend"}},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
code, _, errOut := run(t, srv, tt.args...)
|
|
if code != 1 {
|
|
t.Fatalf("code = %d, want usage error 1 (stderr: %s)", code, errOut)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFlagsAfterPositionals(t *testing.T) {
|
|
srv := newServer(t)
|
|
srv.AddRepo("ukrrs", "MOPAC", "main", "main", "feat/quota")
|
|
|
|
code, _, errOut := run(t, srv, "pr", "create", "ukrrs/MOPAC", "--base", "main",
|
|
"--head", "feat/quota", "--title", "flags after positional")
|
|
if code != 0 {
|
|
t.Fatalf("pr create: %s", errOut)
|
|
}
|
|
}
|
|
|
|
func TestTokenNeverInOutput(t *testing.T) {
|
|
srv := newServer(t)
|
|
srv.AddRepo("ukrrs", "MOPAC", "main", "main")
|
|
|
|
t.Setenv("GITEA_URL", srv.URL)
|
|
t.Setenv("GITEA_KEY", fakeToken)
|
|
var out, errb bytes.Buffer
|
|
srv.Token = "rotated-" + fakeToken // force a 401 body that echoes the token
|
|
code := Run([]string{"repo", "list"}, &out, &errb)
|
|
if code != 2 {
|
|
t.Fatalf("code = %d, want 2", code)
|
|
}
|
|
if strings.Contains(out.String()+errb.String(), fakeToken) {
|
|
t.Fatalf("token leaked: out=%q err=%q", out.String(), errb.String())
|
|
}
|
|
}
|
|
|
|
func TestMissingConfigIsUsageError(t *testing.T) {
|
|
t.Setenv("GITEA_URL", "")
|
|
t.Setenv("GITEA_KEY", "")
|
|
var out, errb bytes.Buffer
|
|
code := Run([]string{"repo", "list", "--config", filepath.Join(t.TempDir(), "absent")}, &out, &errb)
|
|
if code != 1 || !strings.Contains(errb.String(), "GITEA_URL") {
|
|
t.Fatalf("code=%d err=%q", code, errb.String())
|
|
}
|
|
}
|
|
|
|
func TestLooseConfigRefused(t *testing.T) {
|
|
srv := newServer(t)
|
|
path := filepath.Join(t.TempDir(), "loose.env")
|
|
os.WriteFile(path, []byte("GITEA_URL="+srv.URL+"\nGITEA_KEY="+fakeToken+"\n"), 0o644)
|
|
|
|
t.Setenv("GITEA_URL", "")
|
|
t.Setenv("GITEA_KEY", "")
|
|
var out, errb bytes.Buffer
|
|
code := Run([]string{"repo", "list", "--config", path}, &out, &errb)
|
|
if code != 1 || !strings.Contains(errb.String(), "insecure mode") {
|
|
t.Fatalf("code=%d err=%q", code, errb.String())
|
|
}
|
|
}
|
|
|
|
func TestBodyFromStdinDash(t *testing.T) {
|
|
srv := newServer(t)
|
|
srv.AddRepo("ukrrs", "MOPAC", "main", "main", "feat/quota")
|
|
|
|
t.Setenv("GITEA_URL", srv.URL)
|
|
t.Setenv("GITEA_KEY", fakeToken)
|
|
var out, errb bytes.Buffer
|
|
old := os.Stdin
|
|
r, w, _ := os.Pipe()
|
|
w.WriteString("body via stdin\n")
|
|
w.Close()
|
|
os.Stdin = r
|
|
defer func() { os.Stdin = old; time.Sleep(0) }()
|
|
code := Run([]string{"pr", "create", "ukrrs/MOPAC", "--title", "stdin body",
|
|
"--body", "-", "--base", "main", "--head", "feat/quota"}, &out, &errb)
|
|
os.Stdin = old
|
|
if code != 0 {
|
|
t.Fatalf("pr create stdin: code=%d err=%s", code, errb.String())
|
|
}
|
|
stored, ok := srv.PullRequest("ukrrs", "MOPAC", 1)
|
|
if !ok || stored.Body != "body via stdin\n" {
|
|
t.Fatalf("stored body = %q ok=%v", stored.Body, ok)
|
|
}
|
|
}
|