284 lines
7.3 KiB
Go
284 lines
7.3 KiB
Go
package recording
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestRecorderWriteAndClose(t *testing.T) {
|
|
dir := t.TempDir()
|
|
id := "test-session-001"
|
|
|
|
rec, err := NewRecorder(dir, id, "Test Recording", 80, 24)
|
|
if err != nil {
|
|
t.Fatalf("NewRecorder failed: %v", err)
|
|
}
|
|
|
|
// Write some output events.
|
|
rec.WriteOutput([]byte("Welcome to the server\r\n"))
|
|
rec.WriteOutput([]byte("$ "))
|
|
|
|
// Write some input events.
|
|
rec.WriteInput([]byte("ls -la\r\n"))
|
|
|
|
// Write more output.
|
|
rec.WriteOutput([]byte("total 42\r\n"))
|
|
|
|
if rec.EventCount() != 4 {
|
|
t.Errorf("expected 4 events, got %d", rec.EventCount())
|
|
}
|
|
|
|
if err := rec.Close(); err != nil {
|
|
t.Fatalf("Close failed: %v", err)
|
|
}
|
|
|
|
// Verify the file exists and has correct format.
|
|
path := filepath.Join(dir, id+".cast")
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatalf("failed to read recording: %v", err)
|
|
}
|
|
|
|
lines := strings.Split(strings.TrimSpace(string(data)), "\n")
|
|
if len(lines) < 5 { // 1 header + 4 events
|
|
t.Fatalf("expected at least 5 lines, got %d", len(lines))
|
|
}
|
|
|
|
// Verify header.
|
|
var hdr Header
|
|
if err := json.Unmarshal([]byte(lines[0]), &hdr); err != nil {
|
|
t.Fatalf("failed to parse header: %v", err)
|
|
}
|
|
if hdr.Version != 2 {
|
|
t.Errorf("expected version 2, got %d", hdr.Version)
|
|
}
|
|
if hdr.Width != 80 || hdr.Height != 24 {
|
|
t.Errorf("expected 80x24, got %dx%d", hdr.Width, hdr.Height)
|
|
}
|
|
|
|
// Verify first event is output.
|
|
var evt []json.RawMessage
|
|
if err := json.Unmarshal([]byte(lines[1]), &evt); err != nil {
|
|
t.Fatalf("failed to parse first event: %v", err)
|
|
}
|
|
if len(evt) != 3 {
|
|
t.Fatalf("expected 3-element array, got %d", len(evt))
|
|
}
|
|
var evtType string
|
|
json.Unmarshal(evt[1], &evtType)
|
|
if evtType != "o" {
|
|
t.Errorf("expected event type 'o', got %q", evtType)
|
|
}
|
|
}
|
|
|
|
func TestStoreListAndGet(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
// Create a recording.
|
|
rec, err := NewRecorder(dir, "session-abc", "My Session", 120, 40)
|
|
if err != nil {
|
|
t.Fatalf("NewRecorder failed: %v", err)
|
|
}
|
|
rec.WriteOutput([]byte("hello world\r\n"))
|
|
time.Sleep(10 * time.Millisecond)
|
|
rec.WriteOutput([]byte("done\r\n"))
|
|
rec.Close()
|
|
|
|
// Use the store to list.
|
|
store := NewStore(dir)
|
|
metas, err := store.List()
|
|
if err != nil {
|
|
t.Fatalf("List failed: %v", err)
|
|
}
|
|
if len(metas) != 1 {
|
|
t.Fatalf("expected 1 recording, got %d", len(metas))
|
|
}
|
|
if metas[0].ID != "session-abc" {
|
|
t.Errorf("expected ID 'session-abc', got %q", metas[0].ID)
|
|
}
|
|
if metas[0].Width != 120 || metas[0].Height != 40 {
|
|
t.Errorf("unexpected dimensions: %dx%d", metas[0].Width, metas[0].Height)
|
|
}
|
|
|
|
// Read full recording.
|
|
hdr, events, err := store.Get("session-abc")
|
|
if err != nil {
|
|
t.Fatalf("Get failed: %v", err)
|
|
}
|
|
if hdr.Title != "My Session" {
|
|
t.Errorf("expected title 'My Session', got %q", hdr.Title)
|
|
}
|
|
if len(events) != 2 {
|
|
t.Errorf("expected 2 events, got %d", len(events))
|
|
}
|
|
}
|
|
|
|
func TestStoreDelete(t *testing.T) {
|
|
dir := t.TempDir()
|
|
|
|
rec, err := NewRecorder(dir, "to-delete", "Delete Me", 80, 24)
|
|
if err != nil {
|
|
t.Fatalf("NewRecorder failed: %v", err)
|
|
}
|
|
rec.WriteOutput([]byte("test\n"))
|
|
rec.Close()
|
|
|
|
store := NewStore(dir)
|
|
|
|
// Verify it exists.
|
|
metas, _ := store.List()
|
|
if len(metas) != 1 {
|
|
t.Fatalf("expected 1 recording, got %d", len(metas))
|
|
}
|
|
|
|
// Delete.
|
|
if err := store.Delete("to-delete"); err != nil {
|
|
t.Fatalf("Delete failed: %v", err)
|
|
}
|
|
|
|
// Verify it's gone.
|
|
metas, _ = store.List()
|
|
if len(metas) != 0 {
|
|
t.Errorf("expected 0 recordings, got %d", len(metas))
|
|
}
|
|
}
|
|
|
|
func TestDoubleClose(t *testing.T) {
|
|
dir := t.TempDir()
|
|
rec, err := NewRecorder(dir, "double-close", "Test", 80, 24)
|
|
if err != nil {
|
|
t.Fatalf("NewRecorder failed: %v", err)
|
|
}
|
|
rec.WriteOutput([]byte("test"))
|
|
|
|
if err := rec.Close(); err != nil {
|
|
t.Fatalf("first Close failed: %v", err)
|
|
}
|
|
// Second close should be a no-op.
|
|
if err := rec.Close(); err != nil {
|
|
t.Fatalf("second Close failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRecorderStopsAtSizeLimit(t *testing.T) {
|
|
dir := t.TempDir()
|
|
rec, err := newRecorderWithLimit(dir, "limited", "Limited", 80, 24, 512)
|
|
if err != nil {
|
|
t.Fatalf("newRecorderWithLimit failed: %v", err)
|
|
}
|
|
|
|
for i := 0; i < 50; i++ {
|
|
rec.WriteOutput([]byte(strings.Repeat("x", 80)))
|
|
}
|
|
if rec.EventCount() >= 50 {
|
|
t.Fatalf("expected recording to stop before all events were written")
|
|
}
|
|
if err := rec.Close(); err != nil {
|
|
t.Fatalf("Close failed: %v", err)
|
|
}
|
|
info, err := os.Stat(filepath.Join(dir, "limited.cast"))
|
|
if err != nil {
|
|
t.Fatalf("stat failed: %v", err)
|
|
}
|
|
if info.Size() > 512 {
|
|
t.Fatalf("recording size = %d, want <= 512", info.Size())
|
|
}
|
|
}
|
|
|
|
func TestStoreGetRejectsOversizedPlayback(t *testing.T) {
|
|
dir := t.TempDir()
|
|
path := filepath.Join(dir, "huge.cast")
|
|
header := `{"version":2,"width":80,"height":24,"timestamp":1}` + "\n"
|
|
if err := os.WriteFile(path, []byte(header+strings.Repeat("x", 256)), 0600); err != nil {
|
|
t.Fatalf("write failed: %v", err)
|
|
}
|
|
|
|
store := NewStore(dir)
|
|
_, _, err := store.getWithLimit("huge", 128)
|
|
if err == nil {
|
|
t.Fatal("expected oversized playback to be rejected")
|
|
}
|
|
if !strings.Contains(err.Error(), "too large") {
|
|
t.Fatalf("error = %q, want too large", err.Error())
|
|
}
|
|
}
|
|
|
|
func TestStoreCleanupByAgeAndSize(t *testing.T) {
|
|
dir := t.TempDir()
|
|
makeRecording := func(id string, created time.Time, payload string) {
|
|
rec, err := NewRecorder(dir, id, id, 80, 24)
|
|
if err != nil {
|
|
t.Fatalf("NewRecorder(%s) failed: %v", id, err)
|
|
}
|
|
rec.WriteOutput([]byte(payload))
|
|
if err := rec.Close(); err != nil {
|
|
t.Fatalf("Close(%s) failed: %v", id, err)
|
|
}
|
|
path := filepath.Join(dir, id+".cast")
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatalf("ReadFile(%s) failed: %v", id, err)
|
|
}
|
|
parts := strings.SplitN(string(data), "\n", 2)
|
|
var hdr Header
|
|
if err := json.Unmarshal([]byte(parts[0]), &hdr); err != nil {
|
|
t.Fatalf("header parse(%s) failed: %v", id, err)
|
|
}
|
|
hdr.Timestamp = created.Unix()
|
|
line, err := marshalJSONLine(hdr)
|
|
if err != nil {
|
|
t.Fatalf("header encode(%s) failed: %v", id, err)
|
|
}
|
|
rest := ""
|
|
if len(parts) == 2 {
|
|
rest = parts[1]
|
|
}
|
|
if err := os.WriteFile(path, append(line, []byte(rest)...), 0600); err != nil {
|
|
t.Fatalf("WriteFile(%s) failed: %v", id, err)
|
|
}
|
|
if err := os.Chtimes(path, created, created); err != nil {
|
|
t.Fatalf("Chtimes(%s) failed: %v", id, err)
|
|
}
|
|
}
|
|
|
|
old := time.Now().Add(-45 * 24 * time.Hour)
|
|
recent := time.Now().Add(-2 * time.Hour)
|
|
makeRecording("old", old, "old")
|
|
makeRecording("recent", recent, strings.Repeat("recent", 50))
|
|
|
|
store := NewStore(dir)
|
|
result, err := store.Cleanup(30, 0)
|
|
if err != nil {
|
|
t.Fatalf("Cleanup by age failed: %v", err)
|
|
}
|
|
if result.Deleted != 1 {
|
|
t.Fatalf("deleted = %d, want 1", result.Deleted)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "old.cast")); !os.IsNotExist(err) {
|
|
t.Fatalf("old recording still exists, stat err=%v", err)
|
|
}
|
|
|
|
info, err := store.StorageInfo()
|
|
if err != nil {
|
|
t.Fatalf("StorageInfo failed: %v", err)
|
|
}
|
|
result, err = store.Cleanup(0, info.TotalBytes-1)
|
|
if err != nil {
|
|
t.Fatalf("Cleanup by size failed: %v", err)
|
|
}
|
|
if result.Deleted != 1 {
|
|
t.Fatalf("deleted = %d, want 1", result.Deleted)
|
|
}
|
|
}
|
|
|
|
func TestStoreRejectsTraversalRecordingID(t *testing.T) {
|
|
store := NewStore(t.TempDir())
|
|
if err := store.Delete("../outside"); err == nil {
|
|
t.Fatal("expected traversal recording ID to be rejected")
|
|
}
|
|
}
|