bastion 0.55.3

client-go/harness_treecap_unix_test.go

@@ -0,0 +1,71 @@
+//go:build !windows
+
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// A file far larger than the tree a run may return (sparse, so it costs
+// nothing to make) is refused from its size: packing returns at once, with
+// an error and no tar, having read none of it.
+func TestPackingRefusesAFileLargerThanTheLaneCarriesWithoutReadingIt(t *testing.T) {
+	tree := t.TempDir()
+	if err := os.WriteFile(filepath.Join(tree, "a.txt"), []byte("a\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	f, err := os.Create(filepath.Join(tree, "huge.bin"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := f.Truncate(64 << 30); err != nil {
+		t.Skipf("no sparse file here: %v", err)
+	}
+	f.Close()
+	type res struct {
+		b   []byte
+		err error
+	}
+	var before, after runtime.MemStats
+	runtime.ReadMemStats(&before)
+	ch := make(chan res, 1)
+	start := time.Now()
+	go func() { b, _, err := packWorktree(tree); ch <- res{b, err} }()
+	var r res
+	select {
+	case r = <-ch:
+	case <-time.After(20 * time.Second):
+		t.Fatal("packing a tree with a 64 GiB file was still going after 20 s")
+	}
+	runtime.ReadMemStats(&after)
+	t.Logf("returned in %v, %d MiB allocated", time.Since(start), (after.TotalAlloc-before.TotalAlloc)>>20)
+	if r.err == nil || !strings.Contains(r.err.Error(), "huge.bin") || !strings.Contains(r.err.Error(), "too large") {
+		t.Fatalf("want the tree refused for huge.bin, got %v", r.err)
+	}
+	if r.b != nil {
+		t.Fatal("a tar came back with the refusal")
+	}
+	if got := after.TotalAlloc - before.TotalAlloc; got > 64<<20 {
+		t.Fatalf("packing allocated %d MiB", got>>20)
+	}
+}
+
+// A result larger than one message on the lane is replaced by a refusal that
+// says so, never sent to be dropped by the host; one that fits goes as it is.
+func TestAResultTheLaneCannotCarryIsRefusedNotSent(t *testing.T) {
+	small := []byte(`{"ok":true,"mode":"worktree"}`)
+	if b, code := fitLane(small, 0); string(b) != string(small) || code != 0 {
+		t.Fatalf("a result that fits was changed: %s %d", b, code)
+	}
+	big := append([]byte(`{"ok":true,"mode":"worktree","worktree_b64":"`), make([]byte, uvicornWSMaxSize)...)
+	b, code := fitLane(big, 0)
+	if code == 0 || len(b) > 1024 || !strings.Contains(string(b), `"result_too_large":true`) ||
+		!strings.Contains(string(b), `"ok":false`) {
+		t.Fatalf("an oversized result was not refused: %d bytes, code %d: %.200s", len(b), code, b)
+	}
+}