@synopackageland/cli 0.5.3 → 0.6.1

package/templates/native-go/backend/internal/filestation/sdk_session_test.go

@@ -1,183 +0,0 @@
-//go:build synopkgland_sdk_workers
-
-package filestation
-
-import (
-	"context"
-	"dsmapp/internal/api"
-	"dsmapp/internal/helper/jobcontract"
-	"fmt"
-	"golang.org/x/sys/unix"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-type sdkAuth struct {
-	identity api.Identity
-	err      error
-}
-
-func (a sdkAuth) Authenticate(*http.Request) (api.Identity, error) { return a.identity, a.err }
-func TestSDKSessionIdentityFreshAndMatched(t *testing.T) {
-	var calls atomic.Int32
-	c := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		calls.Add(1)
-		fmt.Fprint(w, `{"success":true,"data":{"username":"alice"}}`)
-	})
-	s := NewService(c, NewGrantRepository(t.TempDir()))
-	s.lookupUID = func(string) (string, error) { return "1000", nil }
-	a := sdkAuth{identity: api.Identity{User: "alice", Admin: true}}
-	for range 2 {
-		id, e := s.CheckSession(context.Background(), a, sessionRequest())
-		if e != nil || id.User != "alice" || id.UID != "1000" || !id.Admin {
-			t.Fatalf("missing verified identity: %v", e)
-		}
-	}
-	if calls.Load() != 2 {
-		t.Fatal("session cached")
-	}
-	a.identity.User = "bob"
-	if _, e := s.CheckSession(context.Background(), a, sessionRequest()); e == nil {
-		t.Fatal("mismatched session accepted")
-	}
-	a.identity.User = "alice"
-	s.lookupUID = func(string) (string, error) { return "0", nil }
-	if _, e := s.CheckSession(context.Background(), a, sessionRequest()); e == nil {
-		t.Fatal("root identity accepted")
-	}
-	a.err = api.ErrNoSession
-	if _, e := s.CheckSession(context.Background(), a, sessionRequest()); e == nil {
-		t.Fatal("expired session accepted")
-	}
-}
-func TestSDKJobUsesSelectionAndFileStation(t *testing.T) {
-	var calls atomic.Int32
-	c := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		calls.Add(1)
-		r.ParseForm()
-		if r.Form.Get("api") != "SYNO.FileStation.List" {
-			t.Error("unexpected API")
-		}
-		fmt.Fprint(w, `{"success":true,"data":{"files":[{"path":"/home/item","name":"item","isdir":false,"additional":{"size":7}}]}}`)
-	})
-	repo := NewGrantRepository(t.TempDir())
-	s := NewService(c, repo)
-	ctx := context.Background()
-	id := SessionIdentity{User: "alice", UID: "1000"}
-	g, e := repo.Confirm(ctx, id.User, id.UID, "/home", false)
-	if e != nil {
-		t.Fatal(e)
-	}
-	if e = s.JobSelection(ctx, id, g.ID); e != nil {
-		t.Fatal(e)
-	}
-	step := jobcontract.Step{Action: jobcontract.Stat, Segments: []string{"item"}}
-	result, e := s.JobStep(ctx, sessionRequest(), id, g.ID, step)
-	if e != nil || result.Entries != 1 || result.CompletedSteps != 1 {
-		t.Fatalf("step failed: %v", e)
-	}
-	for _, other := range []SessionIdentity{{User: "bob", UID: "1000", Admin: true}, {User: "alice", UID: "1001"}} {
-		if _, e = s.JobStep(ctx, sessionRequest(), other, g.ID, step); e == nil {
-			t.Fatal("foreign selection accepted")
-		}
-	}
-	step.Segments = []string{"..", "item"}
-	if _, e = s.JobStep(ctx, sessionRequest(), id, g.ID, step); e == nil {
-		t.Fatal("traversal accepted")
-	}
-	step.Action = jobcontract.ReadStream
-	step.Segments = []string{"item"}
-	if _, e = s.JobStep(ctx, sessionRequest(), id, g.ID, step); e == nil {
-		t.Fatal("stream accepted")
-	}
-	if calls.Load() != 1 {
-		t.Fatal("refused input reached File Station")
-	}
-	if e = repo.Revoke(ctx, id.User, id.UID, g.ID); e != nil {
-		t.Fatal(e)
-	}
-	if e = s.JobSelection(ctx, id, g.ID); e == nil {
-		t.Fatal("revoked selection accepted")
-	}
-}
-
-func TestSDKJobReadUsesBoundedDownloadAndSafeCounters(t *testing.T) {
-	c := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		r.ParseForm()
-		if r.Form.Get("method") == "getinfo" {
-			fmt.Fprint(w, `{"success":true,"data":{"files":[{"path":"/home/item","name":"item","additional":{"size":3}}]}}`)
-			return
-		}
-		if r.Method != "GET" || r.URL.Query().Has("SynoToken") {
-			t.Error("credential URL or non-GET download")
-		}
-		w.Header().Set("Content-Disposition", `attachment; filename="item"`)
-		fmt.Fprint(w, "abc")
-	})
-	repo := NewGrantRepository(t.TempDir())
-	s := NewService(c, repo)
-	id := SessionIdentity{User: "alice", UID: "1000"}
-	g, e := repo.Confirm(context.Background(), id.User, id.UID, "/home", false)
-	if e != nil {
-		t.Fatal(e)
-	}
-	n := uint64(3)
-	step := jobcontract.Step{Action: jobcontract.Read, Segments: []string{"item"}, MaxBytes: &n}
-	result, e := s.JobStep(context.Background(), sessionRequest(), id, g.ID, step)
-	if e != nil || result.BytesRead != 3 || result.CompletedSteps != 1 {
-		t.Fatal("download", e)
-	}
-	n = 2
-	if _, e = s.JobStep(context.Background(), sessionRequest(), id, g.ID, step); e == nil {
-		t.Fatal("oversized read")
-	}
-}
-
-func TestSDKJobSelectionNeverCreatesPackageFiles(t *testing.T) {
-	dir := t.TempDir()
-	s := NewService(nil, NewGrantRepository(dir))
-	_ = s.JobSelection(context.Background(), SessionIdentity{User: "alice", UID: "1000"}, strings.Repeat("a", 64))
-	files, e := os.ReadDir(dir)
-	if e != nil {
-		t.Fatal(e)
-	}
-	if len(files) != 0 {
-		t.Fatal("privileged job reader created package metadata")
-	}
-}
-func TestSDKJobSelectionRefusesSpecialMetadataFiles(t *testing.T) {
-	for _, name := range []string{"session-selections.lock", "session-selections.json"} {
-		t.Run(name, func(t *testing.T) {
-			dir := t.TempDir()
-			repo := NewGrantRepository(dir)
-			id := SessionIdentity{User: "alice", UID: "1000"}
-			g, e := repo.Confirm(context.Background(), id.User, id.UID, "/home", false)
-			if e != nil {
-				t.Fatal(e)
-			}
-			target := filepath.Join(dir, name)
-			if e = os.Remove(target); e != nil {
-				t.Fatal(e)
-			}
-			if e = unix.Mkfifo(target, 0600); e != nil {
-				t.Fatal(e)
-			}
-			s := NewService(nil, repo)
-			done := make(chan error, 1)
-			go func() { done <- s.JobSelection(context.Background(), id, g.ID) }()
-			select {
-			case e := <-done:
-				if e == nil {
-					t.Fatal("special file accepted")
-				}
-			case <-time.After(time.Second):
-				t.Fatal("special file blocked root reader")
-			}
-		})
-	}
-}

package/templates/native-go/backend/internal/filestation/session_semantics_test.go

@@ -1,383 +0,0 @@
-package filestation
-
-import (
-	"bytes"
-	"dsmapp/internal/api"
-	"encoding/json"
-	"fmt"
-	"io/fs"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"testing"
-)
-
-// fakeDSM answers the loopback WebAPI for several DSM sessions. A session id
-// maps to a user; an expired id answers 119 like DSM. Calls are recorded so a
-// test can prove a refused request never reached File Station.
-type fakeDSM struct {
-	mu       sync.Mutex
-	users    map[string]string // session id -> user
-	denied   map[string]bool   // "user method path" -> DSM 407
-	uploads  map[string]string // "user path/name" -> content
-	calls    []string
-	failPush func(user string) string // non-empty raw reply for upload
-}
-
-func newFakeDSM(t *testing.T) (*fakeDSM, *Client) {
-	t.Helper()
-	d := &fakeDSM{users: map[string]string{}, denied: map[string]bool{}, uploads: map[string]string{}}
-	c := fakeClient(t, d.serve)
-	return d, c
-}
-
-func (d *fakeDSM) serve(w http.ResponseWriter, r *http.Request) {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	cookie, _ := r.Cookie("id")
-	user := ""
-	if cookie != nil {
-		user = d.users[cookie.Value]
-	}
-	if user == "" {
-		fmt.Fprint(w, `{"success":false,"error":{"code":119}}`)
-		return
-	}
-	if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/") {
-		m, e := r.MultipartReader()
-		if e != nil {
-			http.Error(w, "bad", 400)
-			return
-		}
-		fields, content := map[string]string{}, ""
-		for {
-			p, e := m.NextPart()
-			if e != nil {
-				break
-			}
-			b := new(bytes.Buffer)
-			b.ReadFrom(p)
-			if p.FormName() == "file" {
-				content = b.String()
-				fields["name"] = p.FileName()
-			} else {
-				fields[p.FormName()] = b.String()
-			}
-		}
-		d.calls = append(d.calls, user+" upload "+fields["path"]+"/"+fields["name"])
-		if d.denied[user+" upload "+fields["path"]] {
-			fmt.Fprint(w, `{"success":false,"error":{"code":407}}`)
-			return
-		}
-		if d.failPush != nil {
-			if raw := d.failPush(user); raw != "" {
-				fmt.Fprint(w, raw)
-				return
-			}
-		}
-		d.uploads[user+" "+fields["path"]+"/"+fields["name"]] = content
-		fmt.Fprint(w, `{"success":true,"data":{}}`)
-		return
-	}
-	r.ParseForm()
-	method, p := r.Form.Get("method"), r.Form.Get("folder_path")
-	if p == "" {
-		p = strings.Trim(r.Form.Get("path"), `[]"`)
-	}
-	d.calls = append(d.calls, user+" "+method+" "+p)
-	if d.denied[user+" "+method+" "+p] {
-		fmt.Fprint(w, `{"success":false,"error":{"code":407}}`)
-		return
-	}
-	switch method {
-	case "get":
-		fmt.Fprintf(w, `{"success":true,"data":{"username":%q}}`, user)
-	case "getinfo":
-		fmt.Fprintf(w, `{"success":true,"data":{"files":[{"path":%q,"name":"x","isdir":true}]}}`, p)
-	case "list":
-		fmt.Fprint(w, `{"success":true,"data":{"files":[],"total":0}}`)
-	default:
-		fmt.Fprint(w, `{"success":true,"data":{}}`)
-	}
-}
-
-func (d *fakeDSM) reached(prefix string) int {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	n := 0
-	for _, c := range d.calls {
-		if strings.Contains(c, prefix) {
-			n++
-		}
-	}
-	return n
-}
-
-type sessionHarness struct {
-	t       *testing.T
-	dsm     *fakeDSM
-	service *Service
-	dir     string
-}
-
-func newHarness(t *testing.T) *sessionHarness {
-	d, c := newFakeDSM(t)
-	dir := t.TempDir()
-	s := NewService(c, NewGrantRepository(dir))
-	uids := map[string]string{"alice": "1001", "bob": "1002"}
-	s.lookupUID = func(u string) (string, error) { return uids[u], nil }
-	return &sessionHarness{t: t, dsm: d, service: s, dir: dir}
-}
-
-// call runs one route as the DSM user behind session id sid.
-func (h *sessionHarness) call(user, sid, method, params string) map[string]any {
-	h.t.Helper()
-	server, e := api.NewServer(testAuth{user}, h.service.Routes()...)
-	if e != nil {
-		h.t.Fatal(e)
-	}
-	r := httptest.NewRequest("POST", "http://package/api", ioNop([]byte(fmt.Sprintf(`{"method":%q,"params":%s}`, method, params))))
-	r.Header.Set("Content-Type", "application/json")
-	if sid != "" {
-		r.AddCookie(&http.Cookie{Name: "id", Value: sid})
-	}
-	r.Header.Set("X-SYNO-TOKEN", "token-"+sid)
-	w := httptest.NewRecorder()
-	server.ServeHTTP(w, r)
-	var out map[string]any
-	if json.Unmarshal(w.Body.Bytes(), &out) != nil {
-		h.t.Fatal(w.Body.String())
-	}
-	return out
-}
-
-func errorCode(out map[string]any) string {
-	if out["success"] == true {
-		return ""
-	}
-	if e, ok := out["error"].(map[string]any); ok {
-		code, _ := e["code"].(string)
-		return code
-	}
-	return "malformed"
-}
-
-func (h *sessionHarness) confirm(user, sid, folder string, writable bool) string {
-	h.t.Helper()
-	out := h.call(user, sid, "nas.grants.confirm", fmt.Sprintf(`{"folder":%q,"writable":%v}`, folder, writable))
-	if out["success"] != true {
-		h.t.Fatalf("confirm refused: %v", out)
-	}
-	return out["data"].(map[string]any)["grantId"].(string)
-}
-
-func (h *sessionHarness) wantRefusal(out map[string]any, code string) {
-	h.t.Helper()
-	if got := errorCode(out); got != code {
-		h.t.Fatalf("error code %q, want %q: %v", got, code, out)
-	}
-}
-
-func TestValidSessionConfirmsListsAndWritesInsideItsScope(t *testing.T) {
-	h := newHarness(t)
-	h.dsm.users["sid-a"] = "alice"
-	id := h.confirm("alice", "sid-a", "/home/alice", true)
-	p := fmt.Sprintf(`{"grantId":%q}`, id)
-	if out := h.call("alice", "sid-a", "nas.files.list", p); out["success"] != true {
-		t.Fatal(out)
-	}
-	w := fmt.Sprintf(`{"grantId":%q,"name":"note.txt","data":"aGk="}`, id)
-	if out := h.call("alice", "sid-a", "nas.files.write", w); out["success"] != true {
-		t.Fatal(out)
-	}
-	if got := h.dsm.uploads["alice /home/alice/note.txt"]; got != "hi" {
-		t.Fatalf("upload landed as %q", got)
-	}
-}
-
-func TestExpiredOrInvalidSessionIsRefusedBeforeAnyFileOperation(t *testing.T) {
-	h := newHarness(t)
-	h.dsm.users["sid-a"] = "alice"
-	id := h.confirm("alice", "sid-a", "/home/alice", true)
-	p := fmt.Sprintf(`{"grantId":%q}`, id)
-	w := fmt.Sprintf(`{"grantId":%q,"name":"late.txt","data":"aGk="}`, id)
-	delete(h.dsm.users, "sid-a") // DSM expires the session
-	for method, params := range map[string]string{"nas.files.list": p, "nas.files.read": p, "nas.files.write": w, "nas.grants.list": `{}`, "nas.discovery": `{}`} {
-		h.wantRefusal(h.call("alice", "sid-a", method, params), "session_required")
-	}
-	h.wantRefusal(h.call("alice", "", "nas.files.list", p), "session_required") // no cookie at all
-	if len(h.dsm.uploads) != 0 || h.dsm.reached("upload") != 0 {
-		t.Fatal("an expired session reached the upload path")
-	}
-	if h.dsm.reached("list /home/alice") != 0 {
-		t.Fatal("an expired session listed a folder")
-	}
-	h.dsm.users["sid-a"] = "alice" // a fresh session works again with the stored consent
-	if out := h.call("alice", "sid-a", "nas.files.list", p); out["success"] != true {
-		t.Fatal(out)
-	}
-}
-
-func TestSessionOfAnotherUserIsRefusedEvenWithAMatchingCaller(t *testing.T) {
-	h := newHarness(t)
-	h.dsm.users["sid-b"] = "bob"
-	// The CGI authenticator says alice, but the DSM session belongs to bob.
-	h.wantRefusal(h.call("alice", "sid-b", "nas.discovery", `{}`), "session_required")
-}
-
-func TestTwoUsersCannotUseEachOthersScopes(t *testing.T) {
-	h := newHarness(t)
-	h.dsm.users["sid-a"], h.dsm.users["sid-b"] = "alice", "bob"
-	a := h.confirm("alice", "sid-a", "/home/alice", true)
-	b := h.confirm("bob", "sid-b", "/home/bob", true)
-	pa, pb := fmt.Sprintf(`{"grantId":%q}`, a), fmt.Sprintf(`{"grantId":%q}`, b)
-	wa := fmt.Sprintf(`{"grantId":%q,"name":"x.txt","data":"aGk="}`, a)
-	for _, method := range []string{"nas.files.list", "nas.files.stat", "nas.files.read"} {
-		h.wantRefusal(h.call("bob", "sid-b", method, pa), "denied")
-		h.wantRefusal(h.call("alice", "sid-a", method, pb), "denied")
-	}
-	h.wantRefusal(h.call("bob", "sid-b", "nas.files.write", wa), "denied")
-	h.wantRefusal(h.call("bob", "sid-b", "nas.grants.revoke", pa), "denied")
-	if h.dsm.reached("bob list /home/alice") != 0 || h.dsm.reached("bob upload /home/alice") != 0 {
-		t.Fatal("bob's session touched alice's scope")
-	}
-	for user, sid := range map[string]string{"alice": "sid-a", "bob": "sid-b"} {
-		listed := h.call(user, sid, "nas.grants.list", `{}`)["data"].([]any)
-		if len(listed) != 1 {
-			t.Fatalf("%s sees %d selections", user, len(listed))
-		}
-	}
-	// alice's grant still works for alice after bob's attempted revoke.
-	if out := h.call("alice", "sid-a", "nas.files.list", pa); out["success"] != true {
-		t.Fatal(out)
-	}
-}
-
-func TestScopeBoundsAndReadOnlyGrants(t *testing.T) {
-	h := newHarness(t)
-	h.dsm.users["sid-a"] = "alice"
-	ro := h.confirm("alice", "sid-a", "/home/alice", false)
-	for _, rel := range []string{"../bob", "..", "/etc", "a/../../bob", "a//b", `a\b`} {
-		h.wantRefusal(h.call("alice", "sid-a", "nas.files.list", fmt.Sprintf(`{"grantId":%q,"relative":%q}`, ro, rel)), "invalid-request")
-	}
-	if h.dsm.reached("bob") != 0 || h.dsm.reached("/home/bob") != 0 {
-		t.Fatal("a traversal reached File Station")
-	}
-	for _, method := range []string{"nas.files.create", "nas.files.write"} {
-		h.wantRefusal(h.call("alice", "sid-a", method, fmt.Sprintf(`{"grantId":%q,"name":"x","data":"aGk="}`, ro)), "denied")
-	}
-	if h.dsm.reached("upload") != 0 || h.dsm.reached("create") != 0 {
-		t.Fatal("a read-only grant mutated")
-	}
-}
-
-func TestRevokedConsentAndRevokedDSMPermissionAreRefused(t *testing.T) {
-	h := newHarness(t)
-	h.dsm.users["sid-a"] = "alice"
-	id := h.confirm("alice", "sid-a", "/home/alice", true)
-	p := fmt.Sprintf(`{"grantId":%q}`, id)
-	// DSM drops alice's permission on the folder: the next call is refused fresh.
-	h.dsm.denied["alice list /home/alice"] = true
-	h.wantRefusal(h.call("alice", "sid-a", "nas.files.list", p), "denied")
-	delete(h.dsm.denied, "alice list /home/alice")
-	h.dsm.denied["alice upload /home/alice"] = true
-	h.wantRefusal(h.call("alice", "sid-a", "nas.files.write", fmt.Sprintf(`{"grantId":%q,"name":"x.txt","data":"aGk="}`, id)), "denied")
-	if len(h.dsm.uploads) != 0 {
-		t.Fatal("a denied upload stored a file")
-	}
-	delete(h.dsm.denied, "alice upload /home/alice")
-	// Revoking the stored consent refuses every later operation, upstream untouched.
-	if out := h.call("alice", "sid-a", "nas.grants.revoke", p); out["success"] != true {
-		t.Fatal(out)
-	}
-	before := h.dsm.reached("alice list /home/alice")
-	h.wantRefusal(h.call("alice", "sid-a", "nas.files.list", p), "denied")
-	h.wantRefusal(h.call("alice", "sid-a", "nas.files.write", fmt.Sprintf(`{"grantId":%q,"name":"x.txt","data":"aGk="}`, id)), "denied")
-	if h.dsm.reached("alice list /home/alice") != before || len(h.dsm.uploads) != 0 {
-		t.Fatal("a revoked grant reached File Station")
-	}
-}
-
-func TestWriteFailuresNeverReportSuccessOrLeaveLocalFiles(t *testing.T) {
-	for name, tc := range map[string]struct{ raw, code string }{
-		"DSM conflict":        {`{"success":false,"error":{"code":1805}}`, "conflict"},
-		"DSM permission":      {`{"success":false,"error":{"code":407}}`, "denied"},
-		"unreadable reply":    {`<html>502</html>`, "commit-uncertain"},
-		"success key missing": {`{"data":{}}`, "commit-uncertain"},
-	} {
-		t.Run(name, func(t *testing.T) {
-			h := newHarness(t)
-			h.dsm.users["sid-a"] = "alice"
-			id := h.confirm("alice", "sid-a", "/home/alice", true)
-			h.dsm.failPush = func(string) string { return tc.raw }
-			out := h.call("alice", "sid-a", "nas.files.write", fmt.Sprintf(`{"grantId":%q,"name":"x.txt","data":"aGk="}`, id))
-			h.wantRefusal(out, tc.code)
-			if out["success"] == true || len(h.dsm.uploads) != 0 {
-				t.Fatal("failed write was reported or stored as success")
-			}
-			assertOnlySelectionStore(t, h.dir)
-		})
-	}
-}
-
-func TestStreamAndPublishRefuseWithoutTouchingFileStation(t *testing.T) {
-	h := newHarness(t)
-	h.dsm.users["sid-a"] = "alice"
-	id := h.confirm("alice", "sid-a", "/home/alice", true)
-	before := len(h.dsm.calls)
-	for _, method := range []string{"nas.files.stream", "nas.files.publish"} {
-		out := h.call("alice", "sid-a", method, fmt.Sprintf(`{"grantId":%q,"name":"big.bin"}`, id))
-		h.wantRefusal(out, "unsupported")
-	}
-	if len(h.dsm.calls) != before || len(h.dsm.uploads) != 0 {
-		t.Fatal("unsupported stream/publish reached File Station")
-	}
-	assertOnlySelectionStore(t, h.dir)
-}
-
-func TestNoSessionMaterialIsPersisted(t *testing.T) {
-	h := newHarness(t)
-	h.dsm.users["sid-secret-cookie"] = "alice"
-	id := h.confirm("alice", "sid-secret-cookie", "/home/alice", true)
-	p := fmt.Sprintf(`{"grantId":%q}`, id)
-	h.call("alice", "sid-secret-cookie", "nas.files.list", p)
-	h.call("alice", "sid-secret-cookie", "nas.files.write", fmt.Sprintf(`{"grantId":%q,"name":"x.txt","data":"aGk="}`, id))
-	delete(h.dsm.users, "sid-secret-cookie")
-	h.call("alice", "sid-secret-cookie", "nas.files.list", p)
-	for _, secret := range []string{"sid-secret-cookie", "token-sid-secret-cookie", "SynoToken", "X-SYNO-TOKEN"} {
-		assertNothingPersists(t, h.dir, secret)
-	}
-	assertOnlySelectionStore(t, h.dir)
-}
-
-// assertOnlySelectionStore: the only package-local state is consent metadata.
-func assertOnlySelectionStore(t *testing.T, dir string) {
-	t.Helper()
-	filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
-		if err != nil || d.IsDir() {
-			return err
-		}
-		name := d.Name()
-		if !strings.HasPrefix(name, "session-selections") {
-			t.Errorf("unexpected package-local file %s", path)
-		}
-		return nil
-	})
-}
-
-func assertNothingPersists(t *testing.T, dir, secret string) {
-	t.Helper()
-	filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
-		if err != nil || d.IsDir() {
-			return err
-		}
-		b, _ := os.ReadFile(path)
-		if bytes.Contains(b, []byte(secret)) || strings.Contains(path, secret) {
-			t.Errorf("%s persisted in %s", "session material", path)
-		}
-		return nil
-	})
-}