Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
package app
import (
"archive/zip"
"bytes"
"context"
"errors"
"io"
"log/slog"
"os"
"path/filepath"
"strings"
"testing"
"time"
tea "charm.land/bubbletea/v2"
"charm.land/lipgloss/v2"
"github.com/TNTcraftHIM/Piik/internal/app/buildinfo"
"github.com/TNTcraftHIM/Piik/internal/app/failure"
"github.com/TNTcraftHIM/Piik/internal/diagnostics"
"github.com/charmbracelet/x/ansi"
)
func TestConsoleLocalizesFailureAtRenderWithoutLosingCause(t *testing.T) {
cause := errors.New("cloudflared exit status 7")
problem := errors.Join(failure.TunnelExited, cause)
model := consoleModel{language: "en", width: 120, view: consoleView{state: "setup", problem: problem}}
for _, language := range []string{"en", "zh", "vis"} {
updated, _ := model.Update(consoleLanguage(language))
model = updated.(consoleModel)
content := model.content(false)
if !strings.Contains(strings.Join(strings.Fields(content), ""), strings.Join(strings.Fields(model.text("failure.tunnel-exited")), "")) || !strings.Contains(content, cause.Error()) {
t.Fatalf("%s failure presentation: %s", language, content)
}
if !errors.Is(model.view.problem, cause) {
t.Fatal("console lost original cause")
}
if language == "vis" && !strings.Contains(content, "\n!\n\n!\n"+problem.Error()) {
t.Fatalf("known failure was not shown as a visual error: %s", content)
}
}
model.language = "en"
model.view.problem = errors.New("unclassified technical failure")
if content := model.content(false); !strings.Contains(content, "Could not continue") || !strings.Contains(content, "unclassified technical failure") {
t.Fatalf("unknown failure presentation: %s", content)
}
updated, _ := model.Update(consoleDiagnostic("raw diagnostic line"))
content := updated.(consoleModel).content(false)
if !strings.Contains(content, "raw diagnostic line") || strings.Contains(content, "Could not continue") {
t.Fatalf("diagnostic changed: %s", content)
}
}
func TestConsoleRetainsTheSavedDiagnosticPathAfterRestoration(t *testing.T) {
for _, scenario := range []string{"normal", "terminal-ended-before-export", "terminal-read-failed", "manual-result-after-terminal", "failed-export", "failed-export-keeps-path"} {
t.Run(scenario, func(t *testing.T) {
output, err := os.CreateTemp(t.TempDir(), "restored-terminal-")
if err != nil {
t.Fatal(err)
}
defer output.Close()
previous := os.Stderr
os.Stderr = output
defer func() { os.Stderr = previous }()
recorder, err := diagnostics.Open(t.TempDir(), "client", "test")
if err != nil {
t.Fatal(err)
}
defer recorder.Close()
previousLogger := slog.Default()
slog.SetDefault(recorder.Logger())
defer slog.SetDefault(previousLogger)
model := consoleModel{language: "en", width: 80, cancel: func() {}, view: consoleView{state: "ready"}}
exported, release, commandDone := make(chan struct{}), make(chan struct{}), make(chan struct{})
if scenario == "manual-result-after-terminal" {
model.debug = consoleDebug{export: func() (string, error) {
path, err := recorder.Export()
close(exported)
<-release
close(commandDone)
return path, err
}}
}
var input io.Reader
var failInput func()
readFailure := errors.New("fixture terminal read failed")
if scenario == "terminal-read-failed" {
reader, writer := io.Pipe()
defer reader.Close()
defer writer.Close()
input = reader
failInput = func() { _ = writer.CloseWithError(readFailure) }
}
var screen bytes.Buffer
console := &console{
program: tea.NewProgram(model, tea.WithInput(input), tea.WithOutput(&screen), tea.WithoutSignalHandler(), tea.WithoutRenderer()),
done: make(chan consoleResult, 1),
}
terminalEnded := make(chan struct{})
go func() {
model, err := console.program.Run()
console.done <- consoleResult{model: model, err: err}
close(terminalEnded)
}()
defer console.program.Kill()
if scenario == "manual-result-after-terminal" {
console.send(tea.KeyPressMsg{Code: 'd'})
select {
case <-exported:
case <-time.After(5 * time.Second):
close(release)
t.Fatal("manual export did not start")
}
}
if scenario != "normal" {
if failInput != nil {
failInput()
} else {
console.program.Quit()
}
select {
case <-terminalEnded:
case <-time.After(time.Second):
close(release)
t.Fatal("terminal did not stop")
}
}
var failure error
if scenario == "terminal-ended-before-export" || strings.HasPrefix(scenario, "failed-export") {
failure = errors.New("local service failed")
}
if scenario == "normal" || scenario == "failed-export-keeps-path" {
path, err := recorder.Export()
if err != nil {
t.Fatal(err)
}
console.send(consoleExportResult{path: path})
}
if strings.HasPrefix(scenario, "failed-export") {
if err := recorder.Close(); err != nil {
t.Fatal(err)
}
}
if scenario == "manual-result-after-terminal" {
close(release)
<-commandDone
}
failure = finishRun(console, recorder, func() { slog.SetDefault(previousLogger) }, failure)
path := recorder.LastExportPath()
if (path == "") != (scenario == "failed-export") {
t.Fatalf("saved path %q does not match export outcome", path)
}
if scenario == "terminal-read-failed" {
if !errors.Is(failure, readFailure) {
t.Fatalf("terminal read failure was not retained: %v", failure)
}
archive, err := zip.OpenReader(path)
if err != nil {
t.Fatalf("terminal failure did not produce a complete diagnostic report: %v", err)
}
_ = archive.Close()
log, err := os.ReadFile(recorder.LogPath())
if err != nil || !strings.Contains(string(log), `"event":"stopped","failed":true`) ||
!strings.Contains(string(log), readFailure.Error()) {
t.Fatalf("final diagnostics missed the terminal error: %s, %v", log, err)
}
}
content, err := os.ReadFile(output.Name())
if err != nil || path != "" && strings.Count(string(content), path) != 1 ||
path == "" && strings.Contains(string(content), "Saved") ||
failure != nil && !strings.Contains(string(content), failure.Error()) {
t.Fatalf("restored terminal lost the saved path or App error: %s, %v", content, err)
}
})
}
}
func TestConsoleStartsWithSystemLanguageAndAcceptsVisualSelection(t *testing.T) {
console := newConsole(func() {}, true)
if console.plain.language != defaultConsoleLanguage() || console.plain.language == "vis" {
t.Fatalf("initial console language = %q", console.plain.language)
}
updated, _ := console.plain.Update(consoleLanguage("vis"))
if updated.(consoleModel).language != "vis" {
t.Fatal("explicit visual selection was ignored")
}
}
func TestBrowserOpenFeedbackBelongsToTheCurrentEntry(t *testing.T) {
target := "http://127.0.0.1:8787/#client-access=private-secret"
failure := consoleOpenResult{target: target, err: errors.New("exit status 0xc0000005")}
model := consoleModel{width: 80, language: "en", view: consoleView{state: "ready", entry: target}}
updated, _ := model.Update(failure)
model = updated.(consoleModel)
if model.finished || model.view.state != "ready" || model.view.entry != target {
t.Fatal("browser failure retired a ready App")
}
for _, language := range []string{"en", "zh", "vis"} {
updated, _ = model.Update(consoleLanguage(language))
model = updated.(consoleModel)
content := model.content(false)
if !strings.Contains(content, model.text("openFailed")) || !strings.Contains(content, "0xc0000005") ||
strings.Contains(content, "private-secret") {
t.Fatalf("browser feedback lost its current language/error or exposed a credential: %s", content)
}
}
updated, _ = model.Update(consoleOpenResult{target: target})
model = updated.(consoleModel)
if model.view.browserError != nil {
t.Fatal("successful retry retained the browser failure")
}
for _, next := range []tea.Msg{
consoleView{state: "setup", entry: "http://127.0.0.1:12345/client"},
consoleView{state: "stopping"},
consoleFinished{err: errors.New("service failed")},
} {
updated, _ = model.Update(next)
updated, _ = updated.(consoleModel).Update(failure)
if current := updated.(consoleModel); current.view.browserError != nil {
t.Fatal("late browser result overwrote the current App state")
}
}
}
func TestConsoleEntryKeepsAppActivationWithoutExposingCredentials(t *testing.T) {
model := consoleModel{width: 80, language: "en", view: consoleView{
mode: "link", state: "ready",
entry: "http://user:private-secret@localhost:8787/?token=private-secret&piik-client-port=39730#client-access=private-secret&piik-client=1",
invite: "https://room.example/?token=private-secret#v=private-secret",
}}
want := []string{"http://localhost:8787/?piik-client-port=39730#piik-client=1", "https://room.example/"}
for _, styled := range []bool{false, true} {
content := model.content(styled)
var addresses []string
for _, field := range strings.Fields(ansi.Strip(content)) {
if strings.HasPrefix(field, "http") {
addresses = append(addresses, field)
}
}
if len(addresses) != len(want) {
t.Fatalf("styled=%v: copyable addresses = %q", styled, addresses)
}
for i, address := range want {
if addresses[i] != address {
t.Fatalf("styled=%v: copyable address = %q, want %q", styled, addresses[i], address)
}
if styled && !strings.Contains(content, ansi.SetHyperlink(address)) {
t.Fatalf("terminal hyperlink differs from copyable address %q", address)
}
}
if strings.Contains(content, "private-secret") || strings.Contains(content, "client-access") {
t.Fatal("console exposed an entry or invitation credential")
}
}
}
func TestLauncherEntrySurvivesRoomViewsUntilAppExit(t *testing.T) {
model := consoleModel{width: 80, language: "en"}
launcherURL := "http://127.0.0.1:12345/client"
updated, _ := model.Update(consoleLauncher(launcherURL))
model = updated.(consoleModel)
for _, mode := range []string{"site", "local", "link"} {
updated, _ = model.Update(consoleView{mode: mode, state: "ready", entry: "http://127.0.0.1:8787/"})
model = updated.(consoleModel)
if !strings.Contains(model.content(false), launcherURL) {
t.Fatalf("%s view lost the resident App launcher", mode)
}
}
updated, _ = model.Update(consoleView{state: "setup", entry: launcherURL})
if count := strings.Count(updated.(consoleModel).content(false), launcherURL); count != 1 {
t.Fatalf("setup repeats the launcher address: %d", count)
}
updated, _ = model.Update(consoleFinished{})
if strings.Contains(updated.(consoleModel).content(false), launcherURL) {
t.Fatal("exited App retained its launcher address")
}
}
func TestConsolePresentationAndShutdown(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
model := consoleModel{cancel: cancel, launcher: "http://127.0.0.1:12345/client", view: consoleView{
mode: "link", state: "ready", protected: true,
entry: "http://localhost:8787/#client-access=private-secret",
invite: "https://a-long-public-link-name.example.test/",
}}
for _, language := range []string{"zh", "en", "vis"} {
for _, width := range []int{30, 52, 90} {
model.language, model.width, model.height = language, width, 18
for _, styled := range []bool{true, false} {
content := model.content(styled)
if styled && strings.Count(content, "\n")+1 > model.height {
t.Fatalf("%s width %d height overflow: %d", language, width, strings.Count(content, "\n")+1)
}
if strings.Contains(content, "private-secret") || strings.Contains(content, "client-access") {
t.Fatal("console exposed the entry credential")
}
for _, line := range strings.Split(content, "\n") {
if ansi.StringWidth(line) > width {
t.Fatalf("%s width %d overflow: %q", language, width, line)
}
}
}
}
}
model.colors = true
for _, compact := range []bool{false, true} {
model.width, model.height = 80, 32
if compact {
model.width, model.height = 40, 18
}
for _, frame := range []int{0, 3, 5, 8} {
mascot := consoleBlockTV(frame, true)
lines := strings.Split(mascot, "\n")
if len(lines) != len(strings.Split(consoleBlockTV(0, false), "\n")) {
t.Fatal("mascot animation moved the layout")
}
for _, line := range lines {
if ansi.StringWidth(line) != ansi.StringWidth(lines[0]) {
t.Fatal("mascot frame changed width")
}
}
model.frame = frame
content := model.content(true)
if lipgloss.Width(content) > model.width || lipgloss.Height(content) > model.height {
t.Fatal("color console overflowed")
}
}
}
if !strings.Contains(consoleTV(5, true, false), "- | *") ||
!strings.Contains(consoleTV(0, false, false), "o -") ||
!strings.Contains(consoleBlockTV(0, false), "\u2584\u2584") ||
consoleTV(8, false, false) != consoleTV(0, false, false) {
t.Fatal("mascot wink or static state changed")
}
model.frame = 16
updated, cmd := model.Update(consoleIdleWink{})
waking := updated.(consoleModel)
if !waking.animating() || waking.frame != 8 || cmd == nil {
t.Fatal("idle wink did not resume without redrawing the shell")
}
for range 8 {
updated, _ = waking.Update(consoleTick{})
waking = updated.(consoleModel)
}
if waking.animating() || !waking.idlePending {
t.Fatal("idle wink did not return to rest")
}
var output bytes.Buffer
program := tea.NewProgram(model, tea.WithInput(nil), tea.WithOutput(&output), tea.WithoutSignalHandler(), tea.WithoutRenderer())
done := make(chan error, 1)
go func() { _, err := program.Run(); done <- err }()
program.Send(consoleLanguage("zh"))
program.Send(tea.KeyPressMsg{Code: 'q'})
select {
case <-ctx.Done():
case <-time.After(time.Second):
t.Fatal("quit did not request application shutdown")
}
program.Send(consoleFinished{})
select {
case err := <-done:
if err != nil {
t.Fatal(err)
}
case <-time.After(time.Second):
program.Kill()
t.Fatal("console did not finish after application cleanup")
}
updated, _ = model.Update(consoleFinished{})
if text := updated.(consoleModel).content(false); strings.Contains(text, "http") {
t.Fatal("stopped console retained a live entry")
}
}
func TestConsoleBuildVersionAndRevision(t *testing.T) {
previousVersion, previousRevision := buildinfo.Release, buildinfo.Revision
t.Cleanup(func() { buildinfo.Release, buildinfo.Revision = previousVersion, previousRevision })
buildinfo.Revision = strings.Repeat("a", 40)
for _, test := range []struct{ version, want string }{
{"v1.2.3", "v1.2.3"},
{"development", "development"},
{"", "development"},
{"v01.2.3", "development"},
{"v1.2", "development"},
{"v1.2.3-preview.1", "development"},
{"v1.2.3+build", "development"},
} {
buildinfo.Release = test.version
content := (consoleModel{width: 80, language: "en", view: consoleView{state: "ready"}}).content(false)
if !strings.Contains(content, test.want) || !strings.Contains(content, "aaaaaaa") || strings.Contains(content, buildinfo.Revision) {
t.Fatalf("console identity for %q: %s", test.version, content)
}
}
}
func TestConsoleDiagnosticExportRunsOutsideUpdate(t *testing.T) {
called := 0
path := filepath.Join(t.TempDir(), "client-report.zip")
model := consoleModel{
view: consoleView{state: "ready"}, frame: 16, idlePending: true,
debug: consoleDebug{logPath: filepath.Join(filepath.Dir(path), "client.log"), export: func() (string, error) {
called++
return path, nil
}},
}
updated, command := model.Update(tea.KeyPressMsg{Code: 'd'})
model = updated.(consoleModel)
if called != 0 || command == nil || !model.exporting {
t.Fatal("diagnostic export blocked the console update")
}
_, repeated := model.Update(tea.KeyPressMsg{Code: 'd'})
if repeated != nil {
t.Fatal("repeated key queued another diagnostic export")
}
updated, _ = model.Update(command())
model = updated.(consoleModel)
if called != 1 || model.exporting || model.exportPath != path || model.exportError {
t.Fatalf("diagnostic result = %+v", model)
}
updated, _ = model.Update(consoleExportResult{err: errors.New("disk full")})
model = updated.(consoleModel)
if !model.exportError || model.exportPath != path {
t.Fatal("failed export discarded the previously saved bundle")
}
for _, language := range []string{"en", "zh", "vis"} {
for _, width := range []int{30, 52, 90} {
model.language, model.width, model.height = language, width, 40
for _, styled := range []bool{false, true} {
content := model.content(styled)
for _, line := range strings.Split(content, "\n") {
if ansi.StringWidth(line) > width {
t.Fatalf("%s diagnostic console width %d overflowed: %q", language, width, line)
}
}
if styled && !strings.Contains(content, "[d]") || !styled && strings.Contains(content, "[d]") {
t.Fatalf("export key hint does not match terminal input: %q", content)
}
}
}
}
link := consoleFileLink(path, path, lipgloss.NewStyle(), true)
if !strings.Contains(link, "file:///") || strings.Contains(link, "file:///C:\\") {
t.Fatalf("local report hyperlink = %q", link)
}
}
func TestConsoleDiagnosticsFitCompactTerminal(t *testing.T) {
model := consoleModel{
view: consoleView{mode: "local", state: "ready", entry: "http://localhost:8787/"},
width: 30, height: 18, colors: true,
debug: consoleDebug{logPath: "C:/Piik/logs/client.log", export: func() (string, error) { return "", nil }},
}
for _, language := range []string{"en", "zh", "vis"} {
model.language = language
for _, path := range []string{"", "C:/Piik/logs/client-20260908T120000Z.zip", "C:/Users/Example/Documents/Workspaces/Piik-embedded-media/build/client-check/logs/client-diagnostics-20260908T120000Z-123456789.zip"} {
model.exportPath = path
content := model.content(true)
if lipgloss.Width(content) > model.width || lipgloss.Height(content) > model.height {
t.Fatalf("%s diagnostic console overflowed: %s", language, content)
}
if !strings.Contains(content, "[d]") || !strings.Contains(content, "[o]") || !strings.Contains(content, "[q") {
t.Fatalf("compact diagnostics hid a terminal action: %s", content)
}
}
}
}