TUI Testing Strategy for k13d¶

type TUITester struct {
    App       *tview.Application    // tview 앱 인스턴스
    Screen    tcell.SimulationScreen // 헤드리스 시뮬레이션 스크린
    Assistant *Assistant            // AI 어시스턴트 컴포넌트
}

// 주요 메서드
func NewTUITester() (*TUITester, error)                                    // 테스터 생성
func (t *TUITester) InjectKey(key tcell.Key, r rune, mod tcell.ModMask)   // 키 입력 시뮬레이션
func (t *TUITester) GetContent() string                                    // 화면 내용 추출
func (t *TUITester) Run() func()                                          // 앱 실행 (stop 함수 반환)
func (t *TUITester) AssertPage(tb, pages, expected)                       // 페이지 검증

func TestDashboardShowsResources(t *testing.T) {
    tester, _ := NewTUITester()
    // ... setup with fake data ...

    stop := tester.Run()
    defer stop()

    content := tester.GetContent()

    // 텍스트 기반 검증 - AI가 결과를 해석하기 쉬움
    if !strings.Contains(content, "nginx-deployment") {
        t.Errorf("Expected 'nginx-deployment' in screen, got:\n%s", content)
    }
    if !strings.Contains(content, "Running") {
        t.Errorf("Expected 'Running' status in screen")
    }
}

func TestNavigationFlow(t *testing.T) {
    tester, _ := NewTUITester()
    app := InitApp(tester.App, cfg, aiClient, k8sClient)

    stop := tester.Run()
    defer stop()

    // 초기 상태
    tester.AssertPage(t, app.Pages, "main")

    // 's' 키로 설정 페이지 이동
    tester.InjectKey(tcell.KeyRune, 's', tcell.ModNone)
    tester.AssertPage(t, app.Pages, "settings")

    // ESC로 메인 복귀
    tester.InjectKey(tcell.KeyEscape, 0, tcell.ModNone)
    tester.AssertPage(t, app.Pages, "main")
}

func TestYAMLViewCallback(t *testing.T) {
    tester, _ := NewTUITester()
    app := InitApp(tester.App, cfg, aiClient, k8sClient)

    // 콜백 호출 추적
    var callbackCalled bool
    originalOnYaml := app.Dashboard.OnYaml
    app.Dashboard.OnYaml = func(ns, name string) {
        callbackCalled = true
        if ns != "default" || name != "nginx" {
            t.Errorf("unexpected callback args: %s/%s", ns, name)
        }
        originalOnYaml(ns, name)
    }

    stop := tester.Run()
    defer stop()

    // 'y' 키로 YAML 뷰 트리거
    tester.InjectKey(tcell.KeyRune, 'y', tcell.ModNone)

    if !callbackCalled {
        t.Error("OnYaml callback was not triggered")
    }
}

// 추가할 헬퍼 메서드
func (t *TUITester) GetFocusedPrimitive() tview.Primitive {
    return t.App.GetFocus()
}

func (t *TUITester) AssertFocus(tb testing.TB, expected tview.Primitive) {
    tb.Helper()
    if t.App.GetFocus() != expected {
        tb.Errorf("focus mismatch: expected %T, got %T", expected, t.App.GetFocus())
    }
}

// tui_test_fixtures.go
func NewFakeK8sClient() *k8s.Client {
    fakeClient := fake.NewSimpleClientset(
        // Pods
        &corev1.Pod{
            ObjectMeta: metav1.ObjectMeta{
                Name:      "nginx-pod",
                Namespace: "default",
            },
            Status: corev1.PodStatus{
                Phase: corev1.PodRunning,
            },
        },
        // Deployments
        &appsv1.Deployment{
            ObjectMeta: metav1.ObjectMeta{
                Name:      "nginx-deployment",
                Namespace: "default",
            },
            Spec: appsv1.DeploymentSpec{
                Replicas: ptr.To(int32(3)),
            },
        },
        // ... more resources
    )
    return &k8s.Client{Clientset: fakeClient}
}

// 명확한 에러 메시지
t.Errorf("Page navigation failed:\n  Expected: %s\n  Got: %s\n  After key: %c",
    expected, actual, keyPressed)

// 화면 상태 덤프
t.Errorf("Content assertion failed:\nScreen content:\n---\n%s\n---\nMissing: %s",
    tester.GetContent(), missingText)

// pkg/ui/tui_test_utils.go에 추가 권장

// WaitForCondition waits for a condition to be true with timeout
func (t *TUITester) WaitForCondition(timeout time.Duration, condition func() bool) bool {
    deadline := time.Now().Add(timeout)
    for time.Now().Before(deadline) {
        if condition() {
            return true
        }
        time.Sleep(10 * time.Millisecond)
    }
    return false
}

// AssertContentContains checks if screen contains text
func (t *TUITester) AssertContentContains(tb testing.TB, expected string) {
    tb.Helper()
    content := t.GetContent()
    if !strings.Contains(content, expected) {
        tb.Errorf("Screen does not contain '%s'.\nActual content:\n%s", expected, content)
    }
}

// AssertContentNotContains checks if screen doesn't contain text
func (t *TUITester) AssertContentNotContains(tb testing.TB, unexpected string) {
    tb.Helper()
    content := t.GetContent()
    if strings.Contains(content, unexpected) {
        tb.Errorf("Screen unexpectedly contains '%s'.\nActual content:\n%s", unexpected, content)
    }
}

// TypeString simulates typing a string
func (t *TUITester) TypeString(s string) {
    for _, r := range s {
        t.InjectKey(tcell.KeyRune, r, tcell.ModNone)
    }
}

// PressEnter simulates Enter key
func (t *TUITester) PressEnter() {
    t.InjectKey(tcell.KeyEnter, 0, tcell.ModNone)
}

// PressEscape simulates Escape key
func (t *TUITester) PressEscape() {
    t.InjectKey(tcell.KeyEscape, 0, tcell.ModNone)
}