Git/gitea-tea
1
0
Fork 0
mirror of https://gitea.com/gitea/tea.git synced 2026-02-22 06:13:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add tea actions runs and workflows commands (#880)

Browse Source 
Implements comprehensive workflow execution tracking for Gitea Actions using tea CLI

## Features

### tea actions runs list
- List workflow runs with filtering (status, branch, event, actor, time)
- Time filters: relative (24h, 7d) and absolute dates
- Status symbols: ✓ success, ✘ failure, ⭮ pending, ⊘ skipped/cancelled, ⚠ blocked
- Multiple output formats: table, json, yaml, csv, tsv

### tea actions runs view
- View run details with metadata (ID, status, workflow, branch, event, trigger info)
- Shows jobs table with status, runner, duration
- Optional --jobs flag to toggle jobs display

### tea actions runs delete
- Delete/cancel workflow runs with confirmation prompt
- Supports --confirm/-y to skip prompt

### tea actions runs logs
- View job logs for all jobs or specific job (--job <id>)
- **New: --follow/-f flag for real-time log following** (like tail -f)
- Polls API every 2 seconds, only shows new content
- Auto-detects completion and exits

### tea actions workflows list
- List workflow files (.yml and .yaml) in repository
- Searches in .gitea/workflows and .github/workflows
- Shows active (✓) or inactive (✗) status based on recent runs
- Displays workflow name, path, and file size

## Commands

`tea actions runs list --status success --since 24h`
`tea actions runs view 123`
`tea actions runs delete 123 --confirm`
`tea actions runs logs 123 --job 456 --follow`
`tea actions workflows list`

## Tests
- 19 unit tests across all commands
- Full test suite passing
- Manual testing successful

---------

Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com>
Co-authored-by: techknowlogick <techknowlogick@gitea.com>
Reviewed-on: https://gitea.com/gitea/tea/pulls/880
Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com>
Co-authored-by: yousfi saad <yousfi.saad@gmail.com>
Co-committed-by: yousfi saad <yousfi.saad@gmail.com>
This commit is contained in:
yousfi saad
2026-02-11 00:40:06 +00:00
committed by Lunny Xiao
parent ea795775af
commit 2152d99f2d
12 changed files with 1138 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

188
modules/print/actions_runs.go Normal file
View File

@@ -0,0 +1,188 @@
// Copyright 2026 The Gitea Authors. All rights reserved.
// SPDX-License-Identifier: MIT
package print
import (
"fmt"
"time"
"code.gitea.io/sdk/gitea"
)
// formatDurationMinutes formats duration in a human-readable way
func formatDurationMinutes(started, completed time.Time) string {
if started.IsZero() {
return ""
}
end := completed
if end.IsZero() {
end = time.Now()
}
duration := end.Sub(started)
if duration < time.Minute {
return fmt.Sprintf("%ds", int(duration.Seconds()))
}
if duration < time.Hour {
return fmt.Sprintf("%dm", int(duration.Minutes()))
}
hours := int(duration.Hours())
minutes := int(duration.Minutes()) % 60
return fmt.Sprintf("%dh%dm", hours, minutes)
}
// getWorkflowDisplayName returns the display title or falls back to path
func getWorkflowDisplayName(run *gitea.ActionWorkflowRun) string {
if run.DisplayTitle != "" {
return run.DisplayTitle
}
return run.Path
}
// ActionRunsList prints a list of workflow runs
func ActionRunsList(runs []*gitea.ActionWorkflowRun, output string) {
t := table{
headers: []string{
"ID",
"Status",
"Workflow",
"Branch",
"Event",
"Started",
"Duration",
},
}
machineReadable := isMachineReadable(output)
for _, run := range runs {
workflowName := getWorkflowDisplayName(run)
duration := formatDurationMinutes(run.StartedAt, run.CompletedAt)
t.addRow(
fmt.Sprintf("%d", run.ID),
run.Status,
workflowName,
run.HeadBranch,
run.Event,
FormatTime(run.StartedAt, machineReadable),
duration,
)
}
if len(runs) == 0 {
fmt.Printf("No workflow runs found\n")
return
}
t.sort(0, true)
t.print(output)
}
// ActionRunDetails prints detailed information about a workflow run
func ActionRunDetails(run *gitea.ActionWorkflowRun) {
workflowName := getWorkflowDisplayName(run)
fmt.Printf("Run ID: %d\n", run.ID)
fmt.Printf("Run Number: %d\n", run.RunNumber)
fmt.Printf("Status: %s\n", run.Status)
if run.Conclusion != "" {
fmt.Printf("Conclusion: %s\n", run.Conclusion)
}
fmt.Printf("Workflow: %s\n", workflowName)
fmt.Printf("Path: %s\n", run.Path)
fmt.Printf("Branch: %s\n", run.HeadBranch)
fmt.Printf("Event: %s\n", run.Event)
fmt.Printf("Head SHA: %s\n", run.HeadSha)
fmt.Printf("Started: %s\n", FormatTime(run.StartedAt, false))
if !run.CompletedAt.IsZero() {
fmt.Printf("Completed: %s\n", FormatTime(run.CompletedAt, false))
duration := formatDurationMinutes(run.StartedAt, run.CompletedAt)
fmt.Printf("Duration: %s\n", duration)
}
if run.RunAttempt > 1 {
fmt.Printf("Attempt: %d\n", run.RunAttempt)
}
if run.Actor != nil {
fmt.Printf("Triggered by: %s\n", run.Actor.UserName)
}
if run.HTMLURL != "" {
fmt.Printf("URL: %s\n", run.HTMLURL)
}
}
// ActionWorkflowJobsList prints a list of workflow jobs
func ActionWorkflowJobsList(jobs []*gitea.ActionWorkflowJob, output string) {
t := table{
headers: []string{
"ID",
"Name",
"Status",
"Runner",
"Started",
"Duration",
},
}
machineReadable := isMachineReadable(output)
for _, job := range jobs {
duration := formatDurationMinutes(job.StartedAt, job.CompletedAt)
runner := job.RunnerName
if runner == "" {
runner = "-"
}
t.addRow(
fmt.Sprintf("%d", job.ID),
job.Name,
job.Status,
runner,
FormatTime(job.StartedAt, machineReadable),
duration,
)
}
if len(jobs) == 0 {
fmt.Printf("No jobs found\n")
return
}
t.sort(0, true)
t.print(output)
}
// WorkflowsList prints a list of workflow files with active status
func WorkflowsList(workflows []*gitea.ContentsResponse, activeStatus map[string]bool, output string) {
t := table{
headers: []string{
"Active",
"Name",
"Path",
},
}
machineReadable := isMachineReadable(output)
for _, workflow := range workflows {
// Check if this workflow file is active (has runs)
isActive := activeStatus[workflow.Name]
activeIndicator := formatBoolean(isActive, !machineReadable)
t.addRow(
activeIndicator,
workflow.Name,
workflow.Path,
)
}
if len(workflows) == 0 {
fmt.Printf("No workflows found\n")
return
}
t.sort(1, true) // Sort by name column
t.print(output)
}

174
modules/print/actions_runs_test.go Normal file
View File

@@ -0,0 +1,174 @@
// Copyright 2026 The Gitea Authors. All rights reserved.
// SPDX-License-Identifier: MIT
package print
import (
"testing"
"time"
"code.gitea.io/sdk/gitea"
)
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)
}
}()
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)
}
}()
ActionRunsList(runs, "")
}
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 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)
}
}()
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)
}
}()
ActionWorkflowJobsList(jobs, "")
}
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",
},
}
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)
}
})
}
}