mirror of
https://gitea.com/gitea/tea.git
synced 2026-10-26 11:01:25 +01:00
229 lines
8.8 KiB
Go
229 lines
8.8 KiB
Go
// Copyright 2026 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/base64"
|
|
"errors"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.dev/tea/internal/app"
|
|
"gitea.dev/tea/internal/auth"
|
|
"gitea.dev/tea/internal/settings"
|
|
"gitea.dev/tea/internal/terminal"
|
|
"gitea.dev/tea/internal/transport"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestSignalInterruptReturns130(t *testing.T) {
|
|
if runtime.GOOS == "windows" {
|
|
t.Skip("os.Interrupt delivery is not supported by Windows processes")
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
|
|
defer cancel()
|
|
binary := filepath.Join(t.TempDir(), "tea")
|
|
build := exec.CommandContext(ctx, "go", "build", "-o", binary, ".")
|
|
output, err := build.CombinedOutput()
|
|
require.NoError(t, err, "build: %s", output)
|
|
started := make(chan struct{})
|
|
var once sync.Once
|
|
server := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) {
|
|
// require would call FailNow off the test goroutine and leave the test waiting for its deadline.
|
|
assert.Equal(t, "/api/v1/user", r.URL.Path)
|
|
once.Do(func() { close(started) })
|
|
<-r.Context().Done()
|
|
}))
|
|
defer server.Close()
|
|
command := exec.CommandContext(ctx, binary, "api", "version", "--no-input")
|
|
environment := []string{}
|
|
for _, entry := range os.Environ() {
|
|
key, _, _ := strings.Cut(entry, "=")
|
|
if strings.HasPrefix(key, "TEA_") || strings.HasPrefix(key, "GITEA_") {
|
|
continue
|
|
}
|
|
environment = append(environment, entry)
|
|
}
|
|
command.Env = append(environment, "TEA_CONFIG_DIR="+t.TempDir(), "TEA_HOST="+server.URL, "GITEA_TOKEN=disposable-test-token")
|
|
var stdout, stderr bytes.Buffer
|
|
command.Stdout, command.Stderr = &stdout, &stderr
|
|
require.NoError(t, command.Start())
|
|
done := make(chan error, 1)
|
|
go func() { done <- command.Wait() }()
|
|
select {
|
|
case <-started:
|
|
case <-ctx.Done():
|
|
t.Fatal("CLI did not reach the cancellable HTTP request")
|
|
}
|
|
require.NoError(t, command.Process.Signal(os.Interrupt))
|
|
select {
|
|
case err := <-done:
|
|
var exit *exec.ExitError
|
|
require.True(t, errors.As(err, &exit))
|
|
require.Equal(t, 130, exit.ExitCode())
|
|
case <-ctx.Done():
|
|
t.Fatal("CLI did not exit after interrupt")
|
|
}
|
|
require.Empty(t, stdout.String())
|
|
require.Empty(t, stderr.String(), "an interrupt exits silently")
|
|
}
|
|
|
|
type decliningPrompter struct{}
|
|
|
|
func (decliningPrompter) Ask(context.Context, string, func(string) error) (string, error) {
|
|
return "", nil
|
|
}
|
|
|
|
func (decliningPrompter) AskText(context.Context, string, string) (string, error) {
|
|
return "", nil
|
|
}
|
|
|
|
func (decliningPrompter) SecretInput(context.Context, string) (string, error) {
|
|
return "", nil
|
|
}
|
|
|
|
func (decliningPrompter) ConfirmDefault(context.Context, string, bool) (bool, error) {
|
|
return false, nil
|
|
}
|
|
|
|
func TestRunReportsDeclinedConfirmationsAndExplainedFailures(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/api/v1/user":
|
|
_, _ = w.Write([]byte(`{"login":"alice"}`))
|
|
case "/api/v1/repos/alice/project":
|
|
_, _ = w.Write([]byte(`{"full_name":"alice/project","has_issues":true}`))
|
|
default:
|
|
w.WriteHeader(http.StatusNotFound)
|
|
_, _ = w.Write([]byte(`{"message":"not found"}`))
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
store := settings.New(t.TempDir())
|
|
require.NoError(t, store.Update(settings.TargetHosts, func(s *settings.Snapshot) error {
|
|
s.Hosts.Hosts[server.URL] = settings.Host{User: "alice", Users: map[string]settings.Account{"alice": {AuthMethod: settings.AuthToken, CredentialStore: settings.StoreFile}}}
|
|
return nil
|
|
}))
|
|
var stderr bytes.Buffer
|
|
deps := app.Dependencies{
|
|
Settings: store, Credentials: &auth.Store{Dir: store.Dir}, Client: transport.New, Prompter: decliningPrompter{},
|
|
Streams: terminal.Streams{In: &bytes.Buffer{}, Out: &bytes.Buffer{}, ErrOut: &stderr, InTTY: true, ErrTTY: true},
|
|
Getenv: func(string) string { return "" },
|
|
}
|
|
require.Equal(t, 3, run(context.Background(), deps, []string{"auth", "logout"}))
|
|
require.Equal(t, "Canceled.\n", stderr.String())
|
|
|
|
stderr.Reset()
|
|
deps.Getenv = func(key string) string {
|
|
return map[string]string{"GITEA_TOKEN": "token", "TEA_HOST": server.URL}[key]
|
|
}
|
|
require.Equal(t, 1, run(context.Background(), deps, []string{"issue", "view", "9", "-R", "alice/project", "--no-input"}))
|
|
require.Equal(t, "Error: issue #9 not found in alice/project\n", stderr.String())
|
|
}
|
|
|
|
type reviewFormStub struct{}
|
|
|
|
func (reviewFormStub) CreateReview(context.Context, terminal.ReviewFormChoices) (terminal.ReviewFormValues, error) {
|
|
return terminal.ReviewFormValues{Event: "COMMENT", Body: "Self note"}, nil
|
|
}
|
|
|
|
func TestRunReportsWhereADeclinedReviewWasSaved(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path == "/api/v1/user" {
|
|
_, _ = w.Write([]byte(`{"login":"alice"}`))
|
|
return
|
|
}
|
|
_, _ = w.Write([]byte(`{"number":3,"title":"Add one","user":{"login":"alice"},"head":{"ref":"feat/one"},"base":{"ref":"main"}}`))
|
|
}))
|
|
defer server.Close()
|
|
tmp := t.TempDir()
|
|
t.Setenv("TMPDIR", tmp)
|
|
var stderr bytes.Buffer
|
|
store := settings.New(t.TempDir())
|
|
deps := app.Dependencies{
|
|
Settings: store, Credentials: &auth.Store{Dir: store.Dir}, Client: transport.New, Prompter: decliningPrompter{}, ReviewForm: reviewFormStub{},
|
|
Streams: terminal.Streams{In: &bytes.Buffer{}, Out: &bytes.Buffer{}, ErrOut: &stderr, InTTY: true, ErrTTY: true},
|
|
Getenv: func(key string) string { return map[string]string{"GITEA_TOKEN": "token", "TEA_HOST": server.URL}[key] },
|
|
}
|
|
require.Equal(t, 3, run(context.Background(), deps, []string{"pr", "review", "3", "-R", "alice/project"}))
|
|
files, err := filepath.Glob(filepath.Join(tmp, "tea-draft-*.md"))
|
|
require.NoError(t, err)
|
|
require.Len(t, files, 1)
|
|
require.Equal(t, "Canceled.\nDraft saved at "+files[0]+"\n", stderr.String())
|
|
}
|
|
|
|
func TestSecondInterruptStopsACommandBlockedOnStdin(t *testing.T) {
|
|
if runtime.GOOS == "windows" {
|
|
t.Skip("os.Interrupt delivery is not supported by Windows processes")
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
|
|
defer cancel()
|
|
binary := filepath.Join(t.TempDir(), "tea")
|
|
build := exec.CommandContext(ctx, "go", "build", "-o", binary, ".")
|
|
output, err := build.CombinedOutput()
|
|
require.NoError(t, err, "build: %s", output)
|
|
command := exec.CommandContext(ctx, binary, "auth", "login", "--host", "http://127.0.0.1:1", "--with-token", "--no-input")
|
|
command.Env = append(os.Environ(), "TEA_CONFIG_DIR="+t.TempDir(), "GITEA_TOKEN=")
|
|
stdin, err := command.StdinPipe()
|
|
require.NoError(t, err)
|
|
defer stdin.Close()
|
|
require.NoError(t, command.Start())
|
|
done := make(chan error, 1)
|
|
go func() { done <- command.Wait() }()
|
|
// Reading the token from stdin ignores the canceled context, so only a second signal ends tea.
|
|
time.Sleep(time.Second)
|
|
require.NoError(t, command.Process.Signal(os.Interrupt))
|
|
time.Sleep(500 * time.Millisecond)
|
|
require.NoError(t, command.Process.Signal(os.Interrupt))
|
|
select {
|
|
case err := <-done:
|
|
require.Error(t, err)
|
|
case <-time.After(10 * time.Second):
|
|
t.Fatal("tea ignored the second interrupt while waiting on stdin")
|
|
}
|
|
}
|
|
|
|
func TestRunDropsTerminalControlsFromErrors(t *testing.T) {
|
|
definition := base64.StdEncoding.EncodeToString([]byte("on:\n workflow_dispatch:\n inputs:\n target:\n required: true\n"))
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/api/v1/user":
|
|
_, _ = w.Write([]byte(`{"login":"alice"}`))
|
|
case "/api/v1/repos/alice/project":
|
|
_, _ = w.Write([]byte(`{"full_name":"alice/project","has_issues":true}`))
|
|
case "/api/v1/repos/alice/project/actions/workflows":
|
|
_, _ = w.Write([]byte(`{"workflows":[{"id":"ci.yml","name":"CI\u001b]0;PWNED\u0007","path":".gitea/workflows/ci.yml","state":"active"}]}`))
|
|
case "/api/v1/repos/alice/project/contents/.gitea/workflows/ci.yml":
|
|
_, _ = w.Write([]byte(`{"type":"file","encoding":"base64","content":"` + definition + `"}`))
|
|
default:
|
|
t.Errorf("unexpected %s %s", r.Method, r.URL.Path)
|
|
w.WriteHeader(http.StatusNotFound)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
var stderr bytes.Buffer
|
|
deps := app.Dependencies{
|
|
Settings: settings.New(t.TempDir()), Credentials: &auth.Store{Dir: t.TempDir()}, Client: transport.New, Prompter: decliningPrompter{},
|
|
Streams: terminal.Streams{In: &bytes.Buffer{}, Out: &bytes.Buffer{}, ErrOut: &stderr},
|
|
Getenv: func(key string) string {
|
|
return map[string]string{"GITEA_TOKEN": "token", "TEA_HOST": server.URL}[key]
|
|
},
|
|
}
|
|
require.Equal(t, 2, run(context.Background(), deps, []string{"workflow", "run", "ci.yml", "--ref", "main", "-R", "alice/project", "--no-input"}))
|
|
require.Contains(t, stderr.String(), "missing required input target for CI")
|
|
require.NotContains(t, stderr.String(), "\x1b")
|
|
require.NotContains(t, stderr.String(), "\x07")
|
|
}
|