mirror of
https://gitea.com/gitea/tea.git
synced 2026-09-10 07:26:33 -04:00
423 lines
11 KiB
Go
423 lines
11 KiB
Go
// Copyright 2026 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package print
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.dev/sdk"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
func TestActionRunsListEmpty(t *testing.T) {
|
|
// Test with empty runs - should not panic
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ActionRunsList panicked with empty list: %v", r)
|
|
}
|
|
}()
|
|
|
|
require.NoError(t, ActionRunsList([]*gitea.ActionWorkflowRun{}, ""))
|
|
}
|
|
|
|
func TestActionRunsListWithData(t *testing.T) {
|
|
runs := []*gitea.ActionWorkflowRun{
|
|
{
|
|
ID: 1,
|
|
Status: "success",
|
|
DisplayTitle: "Test Workflow",
|
|
HeadBranch: "main",
|
|
Event: "push",
|
|
StartedAt: time.Now().Add(-1 * time.Hour),
|
|
CompletedAt: time.Now().Add(-30 * time.Minute),
|
|
},
|
|
{
|
|
ID: 2,
|
|
Status: "in_progress",
|
|
Path: ".gitea/workflows/test.yml",
|
|
HeadBranch: "feature",
|
|
Event: "pull_request",
|
|
StartedAt: time.Now().Add(-10 * time.Minute),
|
|
},
|
|
}
|
|
|
|
// Test that it doesn't panic with real data
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ActionRunsList panicked with data: %v", r)
|
|
}
|
|
}()
|
|
|
|
require.NoError(t, ActionRunsList(runs, ""))
|
|
}
|
|
|
|
func TestActionRunsListJSONHasStableFields(t *testing.T) {
|
|
startedAt := time.Date(2026, time.August, 2, 10, 0, 0, 0, time.UTC)
|
|
runs := []*gitea.ActionWorkflowRun{{
|
|
ID: 7,
|
|
Status: "in_progress",
|
|
DisplayTitle: "CI",
|
|
Path: ".gitea/workflows/ci.yml",
|
|
HeadBranch: "main",
|
|
HeadSha: "abc123",
|
|
Event: "push",
|
|
StartedAt: startedAt,
|
|
CompletedAt: time.Unix(0, 0).UTC(),
|
|
}}
|
|
|
|
out := captureStdout(t, func() {
|
|
require.NoError(t, ActionRunsList(runs, "json"))
|
|
})
|
|
var rows []map[string]string
|
|
require.NoError(t, json.Unmarshal([]byte(out), &rows))
|
|
require.Len(t, rows, 1)
|
|
assert.Equal(t, "abc123", rows[0]["head_sha"])
|
|
assert.Equal(t, ".gitea/workflows/ci.yml", rows[0]["path"])
|
|
assert.Equal(t, "in_progress", rows[0]["status"])
|
|
assert.Equal(t, "", rows[0]["conclusion"])
|
|
assert.Equal(t, "2026-08-02T10:00:00Z", rows[0]["started_at"])
|
|
assert.Equal(t, "", rows[0]["completed_at"])
|
|
assert.NotContains(t, rows[0]["duration"], "-")
|
|
}
|
|
|
|
func TestActionRunsListEmptyJSONIsValid(t *testing.T) {
|
|
out := captureStdout(t, func() {
|
|
require.NoError(t, ActionRunsList(nil, "json"))
|
|
})
|
|
var rows []map[string]string
|
|
require.NoError(t, json.Unmarshal([]byte(out), &rows))
|
|
assert.Empty(t, rows)
|
|
}
|
|
|
|
func TestActionRunsListHumanColumnsRemainCompatible(t *testing.T) {
|
|
out := captureStdout(t, func() {
|
|
require.NoError(t, ActionRunsList([]*gitea.ActionWorkflowRun{{
|
|
ID: 1,
|
|
Status: "completed",
|
|
Conclusion: "success",
|
|
DisplayTitle: "CI",
|
|
}}, "table"))
|
|
})
|
|
assert.Contains(t, out, "WORKFLOW")
|
|
assert.NotContains(t, out, "CONCLUSION")
|
|
assert.NotContains(t, out, "HEAD SHA")
|
|
}
|
|
|
|
func TestActionRunDetails(t *testing.T) {
|
|
run := &gitea.ActionWorkflowRun{
|
|
ID: 123,
|
|
RunNumber: 42,
|
|
Status: "success",
|
|
Conclusion: "success",
|
|
DisplayTitle: "Build and Test",
|
|
Path: ".gitea/workflows/ci.yml",
|
|
HeadBranch: "main",
|
|
Event: "push",
|
|
HeadSha: "abc123def456",
|
|
StartedAt: time.Now().Add(-2 * time.Hour),
|
|
CompletedAt: time.Now().Add(-1 * time.Hour),
|
|
RunAttempt: 1,
|
|
Actor: &gitea.User{
|
|
UserName: "testuser",
|
|
},
|
|
HTMLURL: "https://gitea.example.com/owner/repo/actions/runs/123",
|
|
}
|
|
|
|
// Test that it doesn't panic
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ActionRunDetails panicked: %v", r)
|
|
}
|
|
}()
|
|
|
|
ActionRunDetails(run)
|
|
}
|
|
|
|
func TestActionRunViewMachineOutputIsSingleDocument(t *testing.T) {
|
|
startedAt := time.Date(2026, time.August, 2, 10, 0, 0, 0, time.UTC)
|
|
completedAt := startedAt.Add(5 * time.Minute)
|
|
run := &gitea.ActionWorkflowRun{
|
|
ID: 123,
|
|
RunNumber: 42,
|
|
Status: "completed",
|
|
Conclusion: "failure",
|
|
DisplayTitle: "CI",
|
|
Path: ".gitea/workflows/ci.yml",
|
|
HeadBranch: "main",
|
|
HeadSha: "abc123",
|
|
Event: "push",
|
|
StartedAt: startedAt,
|
|
CompletedAt: completedAt,
|
|
RunAttempt: 2,
|
|
}
|
|
jobs := []*gitea.ActionWorkflowJob{{
|
|
ID: 456,
|
|
Name: "test",
|
|
Status: "completed",
|
|
Conclusion: "failure",
|
|
HeadSha: "abc123",
|
|
StartedAt: startedAt,
|
|
CompletedAt: completedAt,
|
|
RunnerName: "runner-1",
|
|
}}
|
|
|
|
for _, output := range []string{"json", "yaml"} {
|
|
t.Run(output, func(t *testing.T) {
|
|
buf := &bytes.Buffer{}
|
|
require.NoError(t, fprintActionRunView(buf, run, jobs, output))
|
|
|
|
var document struct {
|
|
Run struct {
|
|
HeadSHA string `json:"head_sha" yaml:"head_sha"`
|
|
Path string `json:"path" yaml:"path"`
|
|
Status string `json:"status" yaml:"status"`
|
|
Conclusion string `json:"conclusion" yaml:"conclusion"`
|
|
StartedAt string `json:"started_at" yaml:"started_at"`
|
|
CompletedAt string `json:"completed_at" yaml:"completed_at"`
|
|
} `json:"run" yaml:"run"`
|
|
Jobs []struct {
|
|
Conclusion string `json:"conclusion" yaml:"conclusion"`
|
|
} `json:"jobs" yaml:"jobs"`
|
|
}
|
|
if output == "json" {
|
|
require.NoError(t, json.Unmarshal(buf.Bytes(), &document))
|
|
} else {
|
|
require.NoError(t, yaml.Unmarshal(buf.Bytes(), &document))
|
|
}
|
|
assert.Equal(t, "abc123", document.Run.HeadSHA)
|
|
assert.Equal(t, ".gitea/workflows/ci.yml", document.Run.Path)
|
|
assert.Equal(t, "completed", document.Run.Status)
|
|
assert.Equal(t, "failure", document.Run.Conclusion)
|
|
assert.Equal(t, "2026-08-02T10:00:00Z", document.Run.StartedAt)
|
|
assert.Equal(t, "2026-08-02T10:05:00Z", document.Run.CompletedAt)
|
|
require.Len(t, document.Jobs, 1)
|
|
assert.Equal(t, "failure", document.Jobs[0].Conclusion)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestActionRunViewNormalizesEpochCompletion(t *testing.T) {
|
|
startedAt := time.Date(2026, time.August, 2, 10, 0, 0, 0, time.UTC)
|
|
buf := &bytes.Buffer{}
|
|
require.NoError(t, fprintActionRunView(buf, &gitea.ActionWorkflowRun{
|
|
ID: 1,
|
|
Status: "in_progress",
|
|
StartedAt: startedAt,
|
|
CompletedAt: time.Unix(0, 0).UTC(),
|
|
}, nil, "json"))
|
|
|
|
var document actionRunViewOutput
|
|
require.NoError(t, json.Unmarshal(buf.Bytes(), &document))
|
|
assert.Empty(t, document.Run.CompletedAt)
|
|
assert.NotContains(t, document.Run.Duration, "-")
|
|
assert.Empty(t, document.Jobs)
|
|
}
|
|
|
|
func TestActionRunViewRejectsFlatStructuredFormats(t *testing.T) {
|
|
run := &gitea.ActionWorkflowRun{ID: 1}
|
|
for _, output := range []string{"csv", "tsv"} {
|
|
t.Run(output, func(t *testing.T) {
|
|
err := ActionRunView(run, nil, output)
|
|
require.ErrorContains(t, err, "use json or yaml")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestActionWorkflowJobsListEmpty(t *testing.T) {
|
|
// Test with empty jobs - should not panic
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ActionWorkflowJobsList panicked with empty list: %v", r)
|
|
}
|
|
}()
|
|
|
|
require.NoError(t, ActionWorkflowJobsList([]*gitea.ActionWorkflowJob{}, ""))
|
|
}
|
|
|
|
func TestActionWorkflowJobsListWithData(t *testing.T) {
|
|
jobs := []*gitea.ActionWorkflowJob{
|
|
{
|
|
ID: 1,
|
|
Name: "build",
|
|
Status: "success",
|
|
RunnerName: "runner-1",
|
|
StartedAt: time.Now().Add(-30 * time.Minute),
|
|
CompletedAt: time.Now().Add(-20 * time.Minute),
|
|
},
|
|
{
|
|
ID: 2,
|
|
Name: "test",
|
|
Status: "in_progress",
|
|
RunnerName: "runner-2",
|
|
StartedAt: time.Now().Add(-5 * time.Minute),
|
|
},
|
|
}
|
|
|
|
// Test that it doesn't panic with real data
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ActionWorkflowJobsList panicked with data: %v", r)
|
|
}
|
|
}()
|
|
|
|
require.NoError(t, ActionWorkflowJobsList(jobs, ""))
|
|
}
|
|
|
|
func TestActionWorkflowJobsListHumanColumnsRemainCompatible(t *testing.T) {
|
|
out := captureStdout(t, func() {
|
|
require.NoError(t, ActionWorkflowJobsList([]*gitea.ActionWorkflowJob{{
|
|
ID: 1,
|
|
Name: "test",
|
|
Status: "completed",
|
|
Conclusion: "success",
|
|
}}, "table"))
|
|
})
|
|
assert.Contains(t, out, "RUNNER")
|
|
assert.NotContains(t, out, "CONCLUSION")
|
|
assert.NotContains(t, out, "HEAD SHA")
|
|
}
|
|
|
|
func TestActionWorkflowsListEmpty(t *testing.T) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ActionWorkflowsList panicked with empty list: %v", r)
|
|
}
|
|
}()
|
|
|
|
require.NoError(t, ActionWorkflowsList([]*gitea.ActionWorkflow{}, ""))
|
|
}
|
|
|
|
func TestActionWorkflowsListWithData(t *testing.T) {
|
|
workflows := []*gitea.ActionWorkflow{
|
|
{
|
|
ID: "1",
|
|
Name: "CI",
|
|
Path: ".gitea/workflows/ci.yml",
|
|
State: "active",
|
|
},
|
|
{
|
|
ID: "2",
|
|
Name: "Deploy",
|
|
Path: ".gitea/workflows/deploy.yml",
|
|
State: "disabled_manually",
|
|
},
|
|
}
|
|
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ActionWorkflowsList panicked with data: %v", r)
|
|
}
|
|
}()
|
|
|
|
require.NoError(t, ActionWorkflowsList(workflows, ""))
|
|
}
|
|
|
|
func TestActionWorkflowDetails(t *testing.T) {
|
|
wf := &gitea.ActionWorkflow{
|
|
ID: "1",
|
|
Name: "CI Pipeline",
|
|
Path: ".gitea/workflows/ci.yml",
|
|
State: "active",
|
|
HTMLURL: "https://gitea.example.com/owner/repo/actions/workflows/ci.yml",
|
|
BadgeURL: "https://gitea.example.com/owner/repo/actions/workflows/ci.yml/badge.svg",
|
|
CreatedAt: time.Now().Add(-24 * time.Hour),
|
|
UpdatedAt: time.Now().Add(-1 * time.Hour),
|
|
}
|
|
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ActionWorkflowDetails panicked: %v", r)
|
|
}
|
|
}()
|
|
|
|
ActionWorkflowDetails(wf)
|
|
}
|
|
|
|
func TestActionWorkflowDispatchResult(t *testing.T) {
|
|
details := &gitea.RunDetails{
|
|
WorkflowRunID: 42,
|
|
HTMLURL: "https://gitea.example.com/owner/repo/actions/runs/42",
|
|
}
|
|
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ActionWorkflowDispatchResult panicked: %v", r)
|
|
}
|
|
}()
|
|
|
|
ActionWorkflowDispatchResult(details)
|
|
}
|
|
|
|
func TestActionWorkflowDispatchResultNil(t *testing.T) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("ActionWorkflowDispatchResult panicked with nil: %v", r)
|
|
}
|
|
}()
|
|
|
|
ActionWorkflowDispatchResult(nil)
|
|
}
|
|
|
|
func TestFormatDurationMinutes(t *testing.T) {
|
|
now := time.Now()
|
|
|
|
tests := []struct {
|
|
name string
|
|
started time.Time
|
|
completed time.Time
|
|
expected string
|
|
}{
|
|
{
|
|
name: "zero started",
|
|
started: time.Time{},
|
|
completed: now,
|
|
expected: "",
|
|
},
|
|
{
|
|
name: "30 seconds",
|
|
started: now.Add(-30 * time.Second),
|
|
completed: now,
|
|
expected: "30s",
|
|
},
|
|
{
|
|
name: "5 minutes",
|
|
started: now.Add(-5 * time.Minute),
|
|
completed: now,
|
|
expected: "5m",
|
|
},
|
|
{
|
|
name: "in progress (no completed)",
|
|
started: now.Add(-1 * time.Hour),
|
|
completed: time.Time{},
|
|
expected: "1h0m",
|
|
},
|
|
{
|
|
name: "2 hours 30 minutes",
|
|
started: now.Add(-150 * time.Minute),
|
|
completed: now,
|
|
expected: "2h30m",
|
|
},
|
|
{
|
|
name: "completion before start",
|
|
started: now,
|
|
completed: now.Add(-time.Hour),
|
|
expected: "",
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result := formatDurationMinutes(test.started, test.completed)
|
|
if result != test.expected {
|
|
t.Errorf("formatDurationMinutes() = %q, want %q", result, test.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|