@synopackageland/cli 0.8.0 → 0.9.0

package/dist/templates/native-go/backend/internal/filestation/download_dsm71_test.go

@@ -1,82 +0,0 @@
-package filestation
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-)
-
-// DSM 7.1.1-42962 (vt-62, t-0231) answers Download v2 mode=download with the
-// file bytes and no Content-Disposition header. Its Content-Type was not
-// recorded, so every plausible type is covered.
-func dsm71Download(contentType, body string) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if contentType != "" {
-			w.Header().Set("Content-Type", contentType)
-		}
-		fmt.Fprint(w, body)
-	}
-}
-
-func TestDSM71DownloadWithoutDispositionReturnsFileBytes(t *testing.T) {
-	for _, tt := range []struct{ contentType, body string }{
-		{"text/plain", "t0231 fixture a.txt"},
-		{"application/octet-stream", "\x00\x01binary"},
-		{"", "no type"},
-		{"application/json", `{"name":"a user file"}`},
-		{"application/json", `[{"success":false}]`},
-		{"text/plain", strings.Repeat("y", downloadPeek+7)},
-	} {
-		t.Run(tt.contentType, func(t *testing.T) {
-			c := fakeClient(t, dsm71Download(tt.contentType, tt.body))
-			b, err := c.Read(context.Background(), sessionRequest(), "/home/a")
-			if err != nil || string(b) != tt.body {
-				t.Fatalf("%v %q", err, b)
-			}
-		})
-	}
-}
-
-func TestDSM71DownloadStreamsBeyondThePeek(t *testing.T) {
-	body := strings.Repeat("z", MaxBytes*3)
-	c := fakeClient(t, dsm71Download("application/octet-stream", body))
-	d, err := c.DownloadStream(context.Background(), sessionRequest(), "/home/a")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer d.Body.Close()
-	b, err := io.ReadAll(d.Body)
-	if err != nil || string(b) != body || d.ContentType != "application/octet-stream" {
-		t.Fatal(err, len(b))
-	}
-}
-
-func TestDSM71DownloadEnvelopeWithoutDispositionIsNeverContent(t *testing.T) {
-	for _, tt := range []struct{ contentType, body, want string }{
-		{"application/json; charset=utf-8", `{"success":false,"error":{"code":408}}`, "denied"},
-		{"text/plain", `{"success":false,"error":{"code":119}}`, "session_required"},
-		{"", ` {"error":{"code":407},"success":false}` + "\n", "denied"},
-		{"application/json", `{"success":true,"data":{}}`, "unavailable"},
-	} {
-		t.Run(tt.want, func(t *testing.T) {
-			c := fakeClient(t, dsm71Download(tt.contentType, tt.body))
-			b, err := c.Read(context.Background(), sessionRequest(), "/home/a")
-			if err == nil || len(b) != 0 || !strings.Contains(err.Error(), tt.want) {
-				t.Fatalf("%v %q", err, b)
-			}
-		})
-	}
-}
-
-func TestNonAttachmentDispositionStaysRefused(t *testing.T) {
-	c := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Disposition", `inline; filename="a"`)
-		fmt.Fprint(w, "abc")
-	})
-	if b, err := c.Read(context.Background(), sessionRequest(), "/home/a"); err == nil || len(b) != 0 {
-		t.Fatal("inline disposition admitted")
-	}
-}

package/dist/templates/native-go/backend/internal/filestation/http.go

@@ -1,70 +0,0 @@
-package filestation
-
-import (
-	"context"
-	"dsmapp/internal/api"
-	"io"
-	"log"
-	"mime"
-	"net/http"
-	"path"
-	"strconv"
-)
-
-// Raw upload bodies are passed through as readers, with no multipart buffering.
-func (s *Service) uploadHTTP(ctx context.Context, c api.Caller, w http.ResponseWriter, r *http.Request) error {
-	if r.Method != http.MethodPost {
-		return &api.Error{Code: "method_not_allowed", Message: "use POST"}
-	}
-	media, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
-	if err != nil || media != "application/octet-stream" {
-		return fail("invalid-request")
-	}
-	if r.ContentLength < 0 || r.ContentLength > MaxUploadBytes {
-		return fail("upload_size_required")
-	}
-	q := r.URL.Query()
-	if !validPath(q.Get("parent")) || !validName(q.Get("name")) {
-		return fail("invalid-request")
-	}
-	if err := s.Upload(ctx, c, r, q.Get("parent"), q.Get("name"), http.MaxBytesReader(w, r.Body, MaxUploadBytes), r.ContentLength); err != nil {
-		return err
-	}
-	w.Header().Set("Content-Type", "application/json")
-	w.Header().Set("Cache-Control", "no-store")
-	w.Header().Set("X-Content-Type-Options", "nosniff")
-	payload := `{"success":true,"data":{"uploaded":true}}`
-	w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
-	_, err = io.WriteString(w, payload)
-	return err
-}
-func (s *Service) downloadHTTP(ctx context.Context, c api.Caller, w http.ResponseWriter, r *http.Request) error {
-	if r.Method == http.MethodPost {
-		media, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
-		if err != nil || media != "application/x-www-form-urlencoded" {
-			return fail("invalid-request")
-		}
-	} else if r.Method != http.MethodGet {
-		return &api.Error{Code: "method_not_allowed", Message: "use GET or POST"}
-	}
-	target := r.URL.Query().Get("path")
-	stream, err := s.Download(ctx, c, r, target)
-	if err != nil {
-		return err
-	}
-	defer stream.Body.Close()
-	h := w.Header()
-	h.Set("Content-Type", "application/octet-stream")
-	h.Set("Content-Disposition", mime.FormatMediaType("attachment", map[string]string{"filename": path.Base(target)}))
-	h.Set("Cache-Control", "no-store")
-	h.Set("X-Content-Type-Options", "nosniff")
-	if stream.ContentLength >= 0 {
-		h.Set("Content-Length", strconv.FormatInt(stream.ContentLength, 10))
-	}
-	w.WriteHeader(http.StatusOK)
-	// Once headers are sent a failed transfer must remain truncated, never receive a JSON trailer.
-	if _, err := io.Copy(w, stream.Body); err != nil {
-		log.Print("File Station download interrupted")
-	}
-	return nil
-}

package/dist/templates/native-go/backend/internal/filestation/http_test.go

@@ -1,188 +0,0 @@
-package filestation
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"io"
-	"mime"
-	"net/http"
-	"net/http/httptest"
-	"runtime"
-	"strings"
-	"testing"
-
-	"dsmapp/internal/api"
-)
-
-type transferClient struct {
-	DSMClient
-	read          int64
-	maxChunk      int
-	verified      string
-	downloadToken string
-}
-
-func (c *transferClient) Verify(_ context.Context, r *http.Request, user string) error {
-	c.verified = user
-	if _, err := r.Cookie("id"); err != nil {
-		return fail("dsm_session_required")
-	}
-	return nil
-}
-func (c *transferClient) UploadStream(_ context.Context, r *http.Request, parent, name string, source io.Reader, size int64) error {
-	if parent != "/home" || name != "large.bin" {
-		return fail("invalid-request")
-	}
-	buf := make([]byte, 32<<10)
-	for {
-		n, err := source.Read(buf)
-		if n > c.maxChunk {
-			c.maxChunk = n
-		}
-		c.read += int64(n)
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return err
-		}
-	}
-	if c.read != size {
-		return fail("invalid-request")
-	}
-	return nil
-}
-func (c *transferClient) DownloadStream(_ context.Context, r *http.Request, _ string) (Download, error) {
-	c.downloadToken = r.Header.Get("X-SYNO-TOKEN")
-	return Download{Body: io.NopCloser(bytes.NewBufferString("contents")), ContentLength: 8, ContentType: "text/plain"}, nil
-}
-
-type largeReader struct{ remaining int64 }
-
-func (r *largeReader) Read(p []byte) (int, error) {
-	if r.remaining == 0 {
-		return 0, io.EOF
-	}
-	n := int64(len(p))
-	if n > r.remaining {
-		n = r.remaining
-	}
-	clear(p[:n])
-	r.remaining -= n
-	return int(n), nil
-}
-func transferRequest(method, url string, body io.Reader) *http.Request {
-	r := httptest.NewRequest(method, url, body)
-	r.AddCookie(&http.Cookie{Name: "id", Value: "user-session"})
-	r.Header.Set("X-SYNO-TOKEN", "token")
-	r.Header.Set("Origin", "http://example.com")
-	return r
-}
-func transferServer(t *testing.T, c *transferClient) *api.Server {
-	t.Helper()
-	s, err := api.NewServerWithPermissions(testAuth{"normal1"}, []byte(`{"schema":1,"default":"administrators","methods":{}}`), NewService(c).Routes()...)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return s
-}
-func TestBrowserUploadStreams64MiB(t *testing.T) {
-	c := &transferClient{}
-	s := transferServer(t, c)
-	r := transferRequest("POST", "http://example.com/api.cgi?method=nas.files.upload&parent=/home&name=large.bin", &largeReader{64 << 20})
-	r.ContentLength = 64 << 20
-	r.Header.Set("Content-Type", "application/octet-stream")
-	w := httptest.NewRecorder()
-	var before, after runtime.MemStats
-	runtime.ReadMemStats(&before)
-	s.ServeHTTP(w, r)
-	runtime.ReadMemStats(&after)
-	if allocated := after.TotalAlloc - before.TotalAlloc; allocated > 8<<20 {
-		t.Fatalf("64 MiB upload allocated %d bytes (limit 8 MiB)", allocated)
-	}
-	if c.read != 64<<20 || c.maxChunk > 32<<10 || c.verified != "normal1" {
-		t.Fatalf("not streamed: %+v %s", c, w.Body.String())
-	}
-	if !bytes.Contains(w.Body.Bytes(), []byte(`"success":true`)) {
-		t.Fatal(w.Body.String())
-	}
-}
-func TestBrowserDownloadDispositionAndCentralGuards(t *testing.T) {
-	for _, tc := range []struct{ name, origin, user, code string }{{"normal", "http://example.com", "normal1", ""}, {"anonymous", "http://example.com", "", "session_required"}, {"csrf", "http://evil", "normal1", "cross_origin"}} {
-		t.Run(tc.name, func(t *testing.T) {
-			c := &transferClient{}
-			s, err := api.NewServerWithPermissions(testAuth{tc.user}, []byte(`{"schema":1,"default":"administrators","methods":{}}`), NewService(c).Routes()...)
-			if err != nil {
-				t.Fatal(err)
-			}
-			r := transferRequest("GET", "http://example.com/api.cgi?method=nas.files.download&path=/home/%E5%A0%B1%E5%91%8A.txt", nil)
-			r.Header.Set("Origin", tc.origin)
-			w := httptest.NewRecorder()
-			s.ServeHTTP(w, r)
-			if tc.code != "" {
-				if !bytes.Contains(w.Body.Bytes(), []byte(tc.code)) {
-					t.Fatal(w.Body.String())
-				}
-				return
-			}
-			_, p, err := mime.ParseMediaType(w.Header().Get("Content-Disposition"))
-			if err != nil || p["filename"] != "\u5831\u544a.txt" || w.Body.String() != "contents" || w.Header().Get("Content-Length") != "8" {
-				t.Fatalf("bad download: %v %v %v", p, w.Header(), w.Body.String())
-			}
-		})
-	}
-}
-func TestBrowserUploadLimits(t *testing.T) {
-	for _, size := range []int64{-1, MaxUploadBytes + 1} {
-		c := &transferClient{}
-		r := transferRequest("POST", "http://example.com/api.cgi?method=nas.files.upload&parent=/home&name=large.bin", &largeReader{1})
-		r.ContentLength = size
-		r.Header.Set("Content-Type", "application/octet-stream")
-		w := httptest.NewRecorder()
-		transferServer(t, c).ServeHTTP(w, r)
-		if c.read != 0 {
-			t.Fatal("read rejected payload")
-		}
-		var out map[string]any
-		if json.Unmarshal(w.Body.Bytes(), &out) != nil || out["success"] != false {
-			t.Fatal(w.Body.String())
-		}
-	}
-}
-
-func TestBrowserDownloadForwardsTokenFromPOSTBodyNotURL(t *testing.T) {
-	c := &transferClient{}
-	r := transferRequest("POST", "http://example.com/api.cgi?method=nas.files.download&path=/home/a.txt", strings.NewReader("SynoToken=caller-token"))
-	r.Header.Del("X-SYNO-TOKEN")
-	r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	w := httptest.NewRecorder()
-	transferServer(t, c).ServeHTTP(w, r)
-	if w.Body.String() != "contents" || c.downloadToken != "caller-token" {
-		t.Fatalf("POST transfer: %s token=%s", w.Body.String(), c.downloadToken)
-	}
-}
-
-type transferTokenAuth struct{}
-
-func (transferTokenAuth) Authenticate(r *http.Request) (api.Identity, error) {
-	if r.Header.Get("X-SYNO-TOKEN") != "caller-token" {
-		return api.Identity{}, api.ErrNoSession
-	}
-	return api.Identity{User: "normal1"}, nil
-}
-func TestPOSTDownloadTokenReachesCentralAuthentication(t *testing.T) {
-	c := &transferClient{}
-	s, err := api.NewServerWithPermissions(transferTokenAuth{}, []byte(`{"schema":1,"default":"administrators","methods":{}}`), NewService(c).Routes()...)
-	if err != nil {
-		t.Fatal(err)
-	}
-	r := transferRequest("POST", "http://example.com/api.cgi?method=nas.files.download&path=/home/a.txt", strings.NewReader("SynoToken=caller-token"))
-	r.Header.Del("X-SYNO-TOKEN")
-	r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	w := httptest.NewRecorder()
-	s.ServeHTTP(w, r)
-	if w.Body.String() != "contents" {
-		t.Fatal(w.Body.String())
-	}
-}

package/dist/templates/native-go/backend/internal/filestation/operations_test.go

@@ -1,206 +0,0 @@
-package filestation
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-)
-
-func TestTypedOperationsAlwaysUseEachCallersSession(t *testing.T) {
-	calls := 0
-	client := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		calls++
-		cookie, err := r.Cookie("id")
-		if err != nil || (cookie.Value != "alice-session" && cookie.Value != "bob-session") || r.Header.Get("Cookie") != "id="+cookie.Value || r.Header.Get("Authorization") != "" {
-			t.Error("caller session was replaced or extra credentials forwarded")
-			return
-		}
-		if r.Header.Get("X-SYNO-TOKEN") != "test-token" {
-			t.Error("missing caller token")
-		}
-		if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/") {
-			if err := r.ParseMultipartForm(1024); err != nil {
-				t.Error(err)
-				return
-			}
-			defer r.MultipartForm.RemoveAll()
-		} else {
-			r.ParseForm()
-		}
-		if r.Form.Get("_sid") != "" {
-			t.Error("unexpected SID")
-		}
-		method := r.Form.Get("method")
-		switch method {
-		case "get":
-			fmt.Fprintf(w, `{"success":true,"data":{"username":%q}}`, strings.TrimSuffix(cookie.Value, "-session"))
-		case "list_share":
-			fmt.Fprint(w, `{"success":true,"data":{"shares":[{"path":"/anything","name":"anything","isdir":true}],"total":1}}`)
-		case "list":
-			if r.Form.Get("offset") != "100" || r.Form.Get("limit") != "25" || r.Form.Get("sort_by") != "size" || r.Form.Get("sort_direction") != "DESC" {
-				t.Error("pagination/sort not forwarded")
-			}
-			fmt.Fprint(w, `{"success":true,"data":{"files":[],"total":100,"offset":100}}`)
-		case "getinfo":
-			fmt.Fprint(w, `{"success":true,"data":{"files":[{"path":"/anything/a","name":"a","isdir":false}]}}`)
-		case "create", "upload":
-			fmt.Fprint(w, `{"success":true}`)
-		case "download":
-			w.Header().Set("Content-Disposition", `attachment; filename="a"`)
-			fmt.Fprint(w, strings.Repeat("x", MaxBytes+1))
-		default:
-			t.Errorf("unexpected DSM operation %q", method)
-		}
-	})
-	s := NewService(client)
-	for _, user := range []string{"alice", "bob"} {
-		r := sessionRequest()
-		r.Header.Set("Cookie", "id="+user+"-session")
-		r.Header.Set("Authorization", "package-account-credentials-must-not-travel")
-		caller := callerFor(t, user)
-		ctx := context.Background()
-		roots, err := s.ListShares(ctx, caller, r, 0)
-		if err != nil || roots.Shares[0].Path != "/anything" {
-			t.Fatalf("%+v %v", roots, err)
-		}
-		if _, err := s.List(ctx, caller, r, "/anything", ListOptions{Offset: 100, Limit: 25, SortBy: "size", SortDirection: "DESC"}); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := s.Info(ctx, caller, r, "/anything/a"); err != nil {
-			t.Fatal(err)
-		}
-		if err := s.CreateFolder(ctx, caller, r, "/anything", "new"); err != nil {
-			t.Fatal(err)
-		}
-		if err := s.Upload(ctx, caller, r, "/anything", "a", strings.NewReader("abc"), 3); err != nil {
-			t.Fatal(err)
-		}
-		stream, err := s.Download(ctx, caller, r, "/anything/a")
-		if err != nil {
-			t.Fatal(err)
-		}
-		n, err := io.Copy(io.Discard, stream.Body)
-		stream.Body.Close()
-		if err != nil || n != MaxBytes+1 {
-			t.Fatalf("stream was buffered/bounded: %d %v", n, err)
-		}
-	}
-	if calls != 24 {
-		t.Fatalf("wanted verification plus operation for every request, got %d", calls)
-	}
-}
-
-func TestTypedOperationsRejectMissingOrMismatchedSession(t *testing.T) {
-	calls := 0
-	client := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		calls++
-		fmt.Fprint(w, `{"success":true,"data":{"username":"mallory"}}`)
-	})
-	s := NewService(client)
-	for _, r := range []*http.Request{sessionRequest(), {Header: make(http.Header)}} {
-		if _, err := s.ListShares(context.Background(), alice(t), r, 0); err == nil {
-			t.Fatal("unverified caller accepted")
-		}
-	}
-	if calls != 1 {
-		t.Fatal("missing session reached DSM")
-	}
-}
-
-func TestDownloadReturnsBeforeDSMFinishesSendingBytes(t *testing.T) {
-	release := make(chan struct{})
-	client := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Disposition", `attachment; filename="a"`)
-		fmt.Fprint(w, "first")
-		w.(http.Flusher).Flush()
-		<-release
-		fmt.Fprint(w, "last")
-	})
-	stream, err := client.DownloadStream(context.Background(), sessionRequest(), "/share/a")
-	close(release)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer stream.Body.Close()
-	b, err := io.ReadAll(stream.Body)
-	if err != nil || string(b) != "firstlast" {
-		t.Fatalf("%q %v", b, err)
-	}
-}
-
-func TestListValidatesOptionsAndDownloadPropagatesPermissionRefusal(t *testing.T) {
-	calls := 0
-	client := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		calls++
-		fmt.Fprint(w, `{"success":false,"error":{"code":408,"secret":"test-token"}}`)
-	})
-	for _, opts := range []ListOptions{{Offset: -1}, {Limit: 101}, {SortBy: "arbitrary"}, {SortDirection: "bad"}} {
-		if _, err := client.List(context.Background(), sessionRequest(), "/share", opts); err == nil {
-			t.Fatal("invalid listing option accepted")
-		}
-	}
-	if calls != 0 {
-		t.Fatal("invalid options sent to DSM")
-	}
-	if _, err := client.DownloadStream(context.Background(), sessionRequest(), "/share/a"); err == nil || strings.Contains(err.Error(), "test-token") || !strings.Contains(err.Error(), "denied") {
-		t.Fatal(err)
-	}
-}
-
-func TestMetadataRoutesUsePathsWithoutPersistedGrants(t *testing.T) {
-	client := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		r.ParseForm()
-		if r.Form.Get("method") == "get" {
-			fmt.Fprint(w, `{"success":true,"data":{"username":"alice"}}`)
-			return
-		}
-		if r.Form.Get("method") == "list_share" {
-			fmt.Fprint(w, `{"success":true,"data":{"shares":[],"total":0,"offset":0}}`)
-			return
-		}
-		if r.Form.Get("method") == "list" {
-			fmt.Fprint(w, `{"success":false,"error":{"code":407}}`)
-			return
-		}
-		fmt.Fprint(w, `{"success":true}`)
-	})
-	s := NewService(client)
-	if out := invoke(t, s, "alice", "nas.files.shares", `{"offset":0}`); out["success"] != true {
-		t.Fatal(out)
-	}
-	if out := invoke(t, s, "alice", "nas.files.list", `{"path":"/team","sortBy":"name"}`); out["error"].(map[string]any)["code"] != "denied" {
-		t.Fatal(out)
-	}
-	if out := invoke(t, s, "alice", "nas.files.create_folder", `{"parent":"/team","name":"new"}`); out["success"] != true {
-		t.Fatal(out)
-	}
-	if out := invoke(t, s, "alice", "nas.files.list", `{"grantId":"legacy","relative":""}`); out["success"] != false {
-		t.Fatal("legacy request accepted")
-	}
-	for _, route := range s.Routes() {
-		if strings.Contains(route.Method(), "grants") || route.Method() == "nas.discovery" {
-			t.Fatal("retired grant route retained")
-		}
-	}
-}
-
-func TestEmptySharePageSerializesAsAnEmptyListing(t *testing.T) {
-	client := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprint(w, `{"success":true,"data":{"shares":[],"total":0,"offset":0}}`)
-	})
-	page, err := client.Discover(context.Background(), sessionRequest(), 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-	encoded, err := json.Marshal(page)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(encoded), `"files":[]`) && !strings.Contains(string(encoded), `"shares":[]`) {
-		t.Fatalf("empty share page is indistinguishable from a malformed response: %s", encoded)
-	}
-}

package/dist/templates/native-go/backend/internal/filestation/read_file_test.go

@@ -1,89 +0,0 @@
-package filestation
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"dsmapp/internal/api"
-)
-
-// identityServer answers like DSM for user "alice" with one 5-byte file.
-func identityServer(t *testing.T, size int, user string) *Client {
-	return fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		r.ParseForm()
-		switch r.Form.Get("method") {
-		case "get":
-			fmt.Fprintf(w, `{"success":true,"data":{"username":%q}}`, user)
-		case "getinfo":
-			isdir := "false"
-			if r.Form.Get("path") == `["/home"]` {
-				isdir = "true"
-			}
-			fmt.Fprintf(w, `{"success":true,"data":{"files":[{"path":%s,"name":"x","isdir":%s,"additional":{"size":%d}}]}}`, r.Form.Get("path")[1:len(r.Form.Get("path"))-1], isdir, size)
-		case "download":
-			w.Header().Set("Content-Disposition", `attachment; filename="x"`)
-			fmt.Fprint(w, "hello")
-		}
-	})
-}
-
-func fileService(t *testing.T, c *Client) (*Service, string) {
-	s := NewService(c)
-	return s, "/home"
-}
-
-func alice(t *testing.T) api.Caller {
-	var got api.Caller
-	srv, _ := sessionTestServer(testAuth{"alice"}, api.HandleRequest("a.b", func(_ context.Context, c api.Caller, _ *http.Request, _ json.RawMessage) (any, error) {
-		got = c
-		return nil, nil
-	}))
-	r := sessionRequest()
-	r.Body = ioNop([]byte(`{"method":"a.b","params":{}}`))
-	r.Header.Set("Content-Type", "application/json")
-	srv.ServeHTTP(httptest.NewRecorder(), r)
-	return got
-}
-
-func TestReadFileReturnsSelectedFileThroughCurrentSession(t *testing.T) {
-	s, folder := fileService(t, identityServer(t, 5, "alice"))
-	data, err := s.ReadFile(context.Background(), alice(t), sessionRequest(), folder, "docs/x.txt")
-	if err != nil || string(data) != "hello" {
-		t.Fatalf("%q %v", data, err)
-	}
-}
-
-func TestReadFileRefusesWhenSessionBelongsToAnotherUser(t *testing.T) {
-	s, folder := fileService(t, identityServer(t, 5, "mallory"))
-	if _, err := s.ReadFile(context.Background(), alice(t), sessionRequest(), folder, "x.txt"); err == nil {
-		t.Fatal("a session that resolves to another user must be refused")
-	}
-}
-
-func TestReadFileRefusesNonFoldersTraversalAndOversize(t *testing.T) {
-	s, folder := fileService(t, identityServer(t, MaxBytes+1, "alice"))
-	ctx, c := context.Background(), alice(t)
-	if _, err := s.ReadFile(ctx, c, sessionRequest(), folder, "x.txt"); err == nil {
-		t.Fatal("oversize file must be refused before download")
-	}
-	if _, err := s.ReadFile(ctx, c, sessionRequest(), "/home/x.txt", "x.txt"); err == nil {
-		t.Fatal("a folder that is not a directory must be refused")
-	}
-	if _, err := s.ReadFile(ctx, c, sessionRequest(), folder, "../etc/passwd"); err == nil {
-		t.Fatal("traversal must be refused")
-	}
-	if _, err := s.ReadFile(ctx, c, sessionRequest(), folder, ""); err == nil {
-		t.Fatal("the selected folder itself is not a file")
-	}
-}
-
-func TestReadFileOnNilServiceIsUnavailable(t *testing.T) {
-	var s *Service
-	if _, err := s.ReadFile(context.Background(), api.Caller{}, sessionRequest(), "x", "y"); err == nil {
-		t.Fatal("nil service must refuse")
-	}
-}

package/dist/templates/native-go/backend/internal/filestation/sdk_policy_test.go

@@ -1,39 +0,0 @@
-package filestation
-
-import (
-	"encoding/json"
-	"os"
-	"sort"
-	"testing"
-)
-
-// Every files entry in the SDK policy must name a route this package serves.
-func TestSDKPolicyListsExactlyTheFileRoutes(t *testing.T) {
-	raw, err := os.ReadFile("../api/sdk-permissions.json")
-	if err != nil {
-		t.Fatal(err)
-	}
-	var policy struct {
-		Files map[string]string `json:"files"`
-	}
-	if err := json.Unmarshal(raw, &policy); err != nil {
-		t.Fatal(err)
-	}
-	var declared, routed []string
-	for method := range policy.Files {
-		declared = append(declared, method)
-	}
-	for _, route := range (&Service{}).Routes() {
-		routed = append(routed, route.Method())
-	}
-	sort.Strings(declared)
-	sort.Strings(routed)
-	if len(declared) != len(routed) {
-		t.Fatalf("policy %v, routes %v", declared, routed)
-	}
-	for i := range declared {
-		if declared[i] != routed[i] {
-			t.Fatalf("policy %v, routes %v", declared, routed)
-		}
-	}
-}