@synopackageland/cli 0.8.0 → 0.9.1

package/templates/native-go/backend/internal/api/registry.go

@@ -1,142 +0,0 @@
-// Package api is the package's one HTTP entry point. Every request passes the
-// same transport guards and the centralized permissions.json policy before
-// any handler runs. Unlisted methods require DSM administrators membership.
-package api
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"regexp"
-)
-
-type policy int
-
-const (
-	policyUnset policy = iota
-	policyUser
-	policyAdmin
-	policyPublic
-)
-
-// Handler runs one business operation. It receives the caller the server
-// verified and the raw `params` object; it decodes params itself.
-type Handler func(ctx context.Context, caller Caller, params json.RawMessage) (any, error)
-
-// Route binds a method name to its handler. Permissions come from JSON only.
-type Route struct {
-	method          string
-	policy          policy
-	handler         Handler
-	requestHandler  RequestHandler
-	responseHandler ResponseHandler
-	streamHandler   StreamHandler
-}
-
-// Handle registers an operation without scattering permissions among handlers.
-func Handle(method string, h Handler) Route {
-	return Route{method: method, handler: h}
-}
-
-// User is a compatibility alias. Deprecated: use Handle and permissions.json.
-// This constructor does not grant access to ordinary users.
-func User(method string, h Handler) Route {
-	return Handle(method, h)
-}
-
-// RequestHandler receives the original request after the normal transport and
-// authentication guards. Credentials must remain request-scoped.
-type RequestHandler func(context.Context, Caller, *http.Request, json.RawMessage) (any, error)
-
-// HandleRequest registers an operation needing the authenticated HTTP request.
-func HandleRequest(method string, h RequestHandler) Route {
-	return Route{method: method, requestHandler: h}
-}
-
-// UserRequest is a compatibility alias. Deprecated: use HandleRequest.
-func UserRequest(method string, h RequestHandler) Route {
-	return HandleRequest(method, h)
-}
-
-// Admin is a compatibility alias. Deprecated: use Handle and permissions.json.
-func Admin(method string, h Handler) Route {
-	return Handle(method, h)
-}
-
-// Public is a compatibility alias. Deprecated: use Handle and permissions.json.
-// This constructor cannot bypass the JSON policy or create an anonymous route.
-func Public(method string, h Handler) Route {
-	return Handle(method, h)
-}
-
-// ResponseHandler can set cookies or stream a response after central authorization.
-type ResponseHandler func(context.Context, Caller, http.ResponseWriter, *http.Request, json.RawMessage) error
-
-func HandleResponse(method string, h ResponseHandler) Route {
-	return Route{method: method, responseHandler: h}
-}
-
-// StreamHandler handles a query-selected HTTP transfer without reading JSON.
-type StreamHandler func(context.Context, Caller, http.ResponseWriter, *http.Request) error
-
-func HandleStream(method string, h StreamHandler) Route {
-	return Route{method: method, streamHandler: h}
-}
-
-// Identity is what an Authenticator established about the requester.
-type Identity struct {
-	User  string
-	Admin bool
-}
-
-// Caller is the verified requester handed to handlers. Only the server sets
-// its fields, so a handler cannot fabricate an authenticated caller; the zero
-// value carries no authority.
-type Caller struct {
-	identity      Identity
-	authenticated bool
-}
-
-func (c Caller) Authenticated() bool { return c.authenticated }
-func (c Caller) User() string        { return c.identity.User }
-func (c Caller) Admin() bool         { return c.authenticated && c.identity.Admin }
-
-var adminRequired = &Error{"admin_required", "this action needs the DSM administrators group"}
-
-// RequireAdmin reserves part of a shared route, such as global settings, for
-// DSM administrators. Whole routes are reserved in permissions.json instead.
-func RequireAdmin(c Caller) error {
-	if !c.Admin() {
-		return adminRequired
-	}
-	return nil
-}
-
-var methodName = regexp.MustCompile(`^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$`)
-
-func buildRegistry(routes []Route) (map[string]Route, error) {
-	registry := make(map[string]Route, len(routes))
-	for _, r := range routes {
-		if !methodName.MatchString(r.method) {
-			return nil, fmt.Errorf("route %q: method must look like \"area.action\" (lowercase)", r.method)
-		}
-		if r.handler == nil && r.requestHandler == nil && r.responseHandler == nil && r.streamHandler == nil {
-			return nil, fmt.Errorf("route %q has no handler", r.method)
-		}
-		if _, dup := registry[r.method]; dup {
-			return nil, fmt.Errorf("route %q is registered twice", r.method)
-		}
-		registry[r.method] = r
-	}
-	return registry, nil
-}
-
-// Method is the route's method name, e.g. "greeting.set".
-func (r Route) Method() string { return r.method }
-
-// Public reports the centralized permission, not the constructor's name.
-func (r Route) Public() bool { return r.declaredPermission() == policyPublic }
-
-// AdminOnly reports the centralized permission. Unlisted routes default here.
-func (r Route) AdminOnly() bool { return r.declaredPermission() == policyAdmin }

package/templates/native-go/backend/internal/api/registry_test.go

@@ -1,344 +0,0 @@
-package api
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-)
-
-// fakeAuth returns a fixed outcome and counts how often it was consulted, so
-// tests can prove each request authenticates at most once.
-type fakeAuth struct {
-	user  string
-	admin bool
-	err   error
-	calls int
-}
-
-func (f *fakeAuth) Authenticate(*http.Request) (Identity, error) {
-	f.calls++
-	if f.err != nil {
-		return Identity{}, f.err
-	}
-	return Identity{User: f.user, Admin: f.admin}, nil
-}
-
-func post(t *testing.T, srv http.Handler, body string, mutate ...func(*http.Request)) (*httptest.ResponseRecorder, envelope) {
-	t.Helper()
-	req := httptest.NewRequest(http.MethodPost, "http://nas.local/webman/3rdparty/App/cgi/api.cgi", strings.NewReader(body))
-	req.Header.Set("Content-Type", "application/json")
-	for _, m := range mutate {
-		m(req)
-	}
-	rec := httptest.NewRecorder()
-	srv.ServeHTTP(rec, req)
-	var env envelope
-	if err := json.Unmarshal(rec.Body.Bytes(), &env); err != nil {
-		t.Fatalf("response is not JSON: %q", rec.Body.String())
-	}
-	return rec, env
-}
-
-type envelope struct {
-	Success bool            `json:"success"`
-	Data    json.RawMessage `json:"data"`
-	Error   *struct {
-		Code string `json:"code"`
-	} `json:"error"`
-}
-
-func countingRoutes(counter *int) []Route {
-	h := func(_ context.Context, c Caller, _ json.RawMessage) (any, error) {
-		*counter++
-		return map[string]string{"user": c.User()}, nil
-	}
-	return []Route{
-		User("demo.user", h),
-		Admin("demo.admin", h),
-	}
-}
-
-func newTestServer(t *testing.T, auth Authenticator, routes ...Route) *Server {
-	t.Helper()
-	// Explicit fixture policy exercises opt-in user/public behavior. Production
-	// defaults and constructor bypasses are covered independently.
-	methods := map[string]string{}
-	for _, route := range routes {
-		switch route.Method() {
-		case "demo.user", "demo.invalid", "demo.crash", "demo.panic":
-			methods[route.Method()] = "authenticated"
-		case "demo.ping":
-			methods[route.Method()] = "public"
-		}
-	}
-	raw, err := json.Marshal(map[string]any{"schema": 1, "default": "administrators", "methods": methods})
-	if err != nil {
-		t.Fatal(err)
-	}
-	srv, err := NewServerWithPermissions(auth, raw, routes...)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return srv
-}
-
-func TestUserRouteRunsForAuthenticatedUserWithVerifiedCaller(t *testing.T) {
-	var executed int
-	auth := &fakeAuth{user: "alice"}
-	srv := newTestServer(t, auth, countingRoutes(&executed)...)
-
-	rec, env := post(t, srv, `{"method":"demo.user"}`)
-
-	if rec.Code != http.StatusOK || !env.Success {
-		t.Fatalf("got %d %s", rec.Code, rec.Body.String())
-	}
-	if string(env.Data) != `{"user":"alice"}` {
-		t.Fatalf("data = %s", env.Data)
-	}
-	if executed != 1 || auth.calls != 1 {
-		t.Fatalf("executed=%d auth=%d, want 1/1", executed, auth.calls)
-	}
-}
-
-func TestEveryProtectedRouteRefusesMissingInvalidAndUnavailableAuth(t *testing.T) {
-	cases := []struct {
-		name string
-		err  error
-		code string
-	}{
-		{"missing session", ErrNoSession, "session_required"},
-		{"invalid session", ErrNoSession, "session_required"},
-		{"auth unavailable", errors.New("authenticate.cgi crashed"), "auth_unavailable"},
-	}
-	for _, method := range []string{"demo.user", "demo.admin"} {
-		for _, tc := range cases {
-			t.Run(method+"/"+tc.name, func(t *testing.T) {
-				var executed int
-				auth := &fakeAuth{err: tc.err}
-				srv := newTestServer(t, auth, countingRoutes(&executed)...)
-
-				rec, env := post(t, srv, `{"method":"`+method+`"}`)
-
-				if rec.Code != http.StatusOK || env.Success || env.Error.Code != tc.code {
-					t.Fatalf("got %d %s", rec.Code, rec.Body.String())
-				}
-				if executed != 0 || auth.calls != 1 {
-					t.Fatalf("executed=%d auth=%d, want 0/1", executed, auth.calls)
-				}
-			})
-		}
-	}
-}
-
-func TestAdminRouteRefusesNonAdminWithoutExecuting(t *testing.T) {
-	var executed int
-	srv := newTestServer(t, &fakeAuth{user: "bob"}, countingRoutes(&executed)...)
-
-	rec, env := post(t, srv, `{"method":"demo.admin"}`)
-
-	if rec.Code != http.StatusOK || env.Error.Code != "admin_required" || executed != 0 {
-		t.Fatalf("got %d %s executed=%d", rec.Code, rec.Body.String(), executed)
-	}
-}
-
-func TestAdminRouteRunsForAdmin(t *testing.T) {
-	var executed int
-	srv := newTestServer(t, &fakeAuth{user: "root-admin", admin: true}, countingRoutes(&executed)...)
-
-	rec, _ := post(t, srv, `{"method":"demo.admin"}`)
-
-	if rec.Code != http.StatusOK || executed != 1 {
-		t.Fatalf("got %d executed=%d", rec.Code, executed)
-	}
-}
-
-func TestUnknownMethodNeedsSessionThenIsNotFound(t *testing.T) {
-	var executed int
-	srv := newTestServer(t, &fakeAuth{err: ErrNoSession}, countingRoutes(&executed)...)
-	_, env := post(t, srv, `{"method":"demo.missing"}`)
-	if env.Error == nil || env.Error.Code != "session_required" {
-		t.Fatalf("anonymous unknown method: got %+v, want session_required (no route probing)", env.Error)
-	}
-
-	srv = newTestServer(t, &fakeAuth{user: "alice", admin: true}, countingRoutes(&executed)...)
-	rec, env := post(t, srv, `{"method":"demo.missing"}`)
-	if rec.Code != http.StatusOK || env.Error.Code != "unknown_method" || executed != 0 {
-		t.Fatalf("got %d %s executed=%d", rec.Code, rec.Body.String(), executed)
-	}
-}
-
-func TestPublicRouteIsExplicitAndSkipsAuthentication(t *testing.T) {
-	var executed int
-	auth := &fakeAuth{err: ErrNoSession}
-	srv := newTestServer(t, auth, Public("demo.ping", func(_ context.Context, c Caller, _ json.RawMessage) (any, error) {
-		executed++
-		if c.Authenticated() {
-			t.Error("public handler received an authenticated caller")
-		}
-		return "pong", nil
-	}))
-
-	rec, _ := post(t, srv, `{"method":"demo.ping"}`)
-
-	if rec.Code != http.StatusOK || executed != 1 || auth.calls != 0 {
-		t.Fatalf("got %d executed=%d auth=%d", rec.Code, executed, auth.calls)
-	}
-}
-
-func TestTransportGuardsRunBeforeAuthenticationAndDispatch(t *testing.T) {
-	cases := []struct {
-		name   string
-		body   string
-		mutate func(*http.Request)
-		code   string
-	}{
-		{"GET", `{"method":"demo.user"}`, func(r *http.Request) { r.Method = http.MethodGet }, "method_not_allowed"},
-		{"form post", `{"method":"demo.user"}`, func(r *http.Request) { r.Header.Set("Content-Type", "text/plain") }, "json_required"},
-		{"cross-site fetch", `{"method":"demo.user"}`, func(r *http.Request) { r.Header.Set("Sec-Fetch-Site", "cross-site") }, "cross_origin"},
-		{"foreign origin", `{"method":"demo.user"}`, func(r *http.Request) { r.Header.Set("Origin", "https://evil.example") }, "cross_origin"},
-		{"oversized body", `{"method":"demo.user","params":"` + strings.Repeat("x", MaxRequestBytes) + `"}`, nil, "request_too_large"},
-		{"malformed JSON", `{"method":`, nil, "bad_request"},
-		{"unknown field", `{"method":"demo.user","user":"admin"}`, nil, "bad_request"},
-		{"trailing data", `{"method":"demo.user"}{}`, nil, "bad_request"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			var executed int
-			auth := &fakeAuth{user: "alice", admin: true}
-			srv := newTestServer(t, auth, countingRoutes(&executed)...)
-			mutate := []func(*http.Request){}
-			if tc.mutate != nil {
-				mutate = append(mutate, tc.mutate)
-			}
-
-			rec, env := post(t, srv, tc.body, mutate...)
-
-			if rec.Code != http.StatusOK || env.Error == nil || env.Error.Code != tc.code {
-				t.Fatalf("got %d %s", rec.Code, rec.Body.String())
-			}
-			if executed != 0 || auth.calls != 0 {
-				t.Fatalf("executed=%d auth=%d, want 0/0", executed, auth.calls)
-			}
-		})
-	}
-}
-
-// countingReader records how much of the request body the server consumed.
-type countingReader struct {
-	r    io.Reader
-	read int
-}
-
-func (c *countingReader) Read(p []byte) (int, error) {
-	n, err := c.r.Read(p)
-	c.read += n
-	return n, err
-}
-
-// DSM's CGI gateway cuts the reply short when a CGI exits without reading
-// its stdin, so every refusal still consumes the request body.
-func TestRefusalsConsumeTheWholeRequestBody(t *testing.T) {
-	cases := map[string]func(*http.Request){
-		"form post":  func(r *http.Request) { r.Header.Set("Content-Type", "text/plain") },
-		"cross-site": func(r *http.Request) { r.Header.Set("Sec-Fetch-Site", "cross-site") },
-		"GET":        func(r *http.Request) { r.Method = http.MethodGet },
-		"oversized":  func(*http.Request) {},
-	}
-	for name, mutate := range cases {
-		t.Run(name, func(t *testing.T) {
-			var executed int
-			srv := newTestServer(t, &fakeAuth{user: "alice"}, countingRoutes(&executed)...)
-			body := `{"method":"demo.user"}`
-			if name == "oversized" {
-				body = `{"method":"demo.user","params":"` + strings.Repeat("x", 2*MaxRequestBytes) + `"}`
-			}
-			reader := &countingReader{r: strings.NewReader(body)}
-			req := httptest.NewRequest(http.MethodPost, "http://nas.local/api.cgi", reader)
-			req.Header.Set("Content-Type", "application/json")
-			mutate(req)
-			srv.ServeHTTP(httptest.NewRecorder(), req)
-			if reader.read != len(body) {
-				t.Fatalf("read %d of %d body bytes", reader.read, len(body))
-			}
-		})
-	}
-}
-
-func TestSameOriginRequestIsAccepted(t *testing.T) {
-	var executed int
-	srv := newTestServer(t, &fakeAuth{user: "alice"}, countingRoutes(&executed)...)
-	rec, _ := post(t, srv, `{"method":"demo.user"}`, func(r *http.Request) {
-		r.Header.Set("Origin", "http://nas.local")
-		r.Header.Set("Sec-Fetch-Site", "same-origin")
-	})
-	if rec.Code != http.StatusOK {
-		t.Fatalf("got %d %s", rec.Code, rec.Body.String())
-	}
-}
-
-func TestResponsesAreUncachedJSON(t *testing.T) {
-	var executed int
-	srv := newTestServer(t, &fakeAuth{err: ErrNoSession}, countingRoutes(&executed)...)
-	rec, _ := post(t, srv, `{"method":"demo.user"}`)
-	if got := rec.Header().Get("Cache-Control"); got != "no-store" {
-		t.Errorf("Cache-Control = %q", got)
-	}
-	if got := rec.Header().Get("Content-Type"); got != "application/json" {
-		t.Errorf("Content-Type = %q", got)
-	}
-}
-
-func TestHandlerErrorsKeepTheirCodeButInternalErrorsAreHidden(t *testing.T) {
-	srv := newTestServer(t, &fakeAuth{user: "alice"},
-		User("demo.invalid", func(context.Context, Caller, json.RawMessage) (any, error) {
-			return nil, BadRequest("text must not be empty")
-		}),
-		User("demo.crash", func(context.Context, Caller, json.RawMessage) (any, error) {
-			return nil, errors.New("disk path /secret/xyz failed")
-		}),
-		User("demo.panic", func(context.Context, Caller, json.RawMessage) (any, error) {
-			panic("boom")
-		}),
-	)
-
-	rec, env := post(t, srv, `{"method":"demo.invalid"}`)
-	if rec.Code != http.StatusOK || env.Error.Code != "bad_request" || !strings.Contains(rec.Body.String(), "text must not be empty") {
-		t.Fatalf("got %d %s", rec.Code, rec.Body.String())
-	}
-	for _, method := range []string{"demo.crash", "demo.panic"} {
-		rec, env = post(t, srv, `{"method":"`+method+`"}`)
-		if rec.Code != http.StatusOK || env.Error.Code != "internal" || strings.Contains(rec.Body.String(), "secret") || strings.Contains(rec.Body.String(), "boom") {
-			t.Fatalf("%s: got %d %s", method, rec.Code, rec.Body.String())
-		}
-	}
-}
-
-func TestRegistryRefusesUnusableRoutes(t *testing.T) {
-	h := func(context.Context, Caller, json.RawMessage) (any, error) { return nil, nil }
-	cases := map[string][]Route{
-		"zero route (no policy)": {{}},
-		"nil handler":            {User("demo.nil", nil)},
-		"bad method name":        {User("Demo Method", h)},
-		"duplicate method":       {User("demo.x", h), Admin("demo.x", h)},
-	}
-	for name, routes := range cases {
-		if _, err := NewServer(&fakeAuth{}, routes...); err == nil {
-			t.Errorf("%s: NewServer accepted it", name)
-		}
-	}
-	if _, err := NewServer(nil, User("demo.x", h)); err == nil {
-		t.Error("NewServer accepted a nil authenticator")
-	}
-}
-
-func TestZeroCallerIsNotAuthenticated(t *testing.T) {
-	var c Caller
-	if c.Authenticated() || c.Admin() || c.User() != "" {
-		t.Fatal("a Caller built outside the server must carry no authority")
-	}
-}

package/templates/native-go/backend/internal/api/resource_limits_test.go

@@ -1,87 +0,0 @@
-package api
-
-import (
-	"context"
-	"encoding/json"
-	"strings"
-	"testing"
-)
-
-func TestJSONResourceLimitsBeforeAuthenticationAndDispatch(t *testing.T) {
-	for name, params := range map[string]string{
-		"wide": "[" + strings.Repeat("0,", 65536) + "0]",
-		"deep": strings.Repeat("[", 33) + "0" + strings.Repeat("]", 33),
-	} {
-		for _, access := range []string{"admin", "public"} {
-			t.Run(name+"/"+access, func(t *testing.T) {
-				executed := 0
-				auth := &fakeAuth{user: "alice", admin: true}
-				h := func(context.Context, Caller, json.RawMessage) (any, error) {
-					executed++
-					return nil, nil
-				}
-				route := Admin("demo.limit", h)
-				if access == "public" {
-					route = Public("demo.limit", h)
-				}
-				srv, err := NewServer(auth, route)
-				if access == "public" {
-					srv, err = NewServerWithPermissions(auth, []byte(`{"schema":1,"default":"administrators","methods":{"demo.limit":"public"}}`), route)
-				}
-				if err != nil {
-					t.Fatal(err)
-				}
-				_, env := post(t, srv, `{"method":"demo.limit","params":`+params+`}`)
-				if env.Error == nil || env.Error.Code != "request_too_large" || executed != 0 || auth.calls != 0 {
-					t.Fatalf("error=%+v executed=%d auth=%d", env.Error, executed, auth.calls)
-				}
-			})
-		}
-	}
-}
-
-func TestJSONResourceLimitsAllowLargeStringsAndPathSelections(t *testing.T) {
-	for name, params := range map[string]any{
-		"text":  strings.Repeat(`[]{}:,\"\\`, 10000),
-		"paths": strings.Split(strings.Repeat("/volume1/share/file,", 999)+"/volume1/share/last", ","),
-	} {
-		t.Run(name, func(t *testing.T) {
-			executed := 0
-			srv := newTestServer(t, &fakeAuth{user: "alice", admin: true}, Admin("demo.limit", func(_ context.Context, c Caller, p json.RawMessage) (any, error) {
-				executed++
-				if !c.Admin() || !json.Valid(p) {
-					t.Fatal("invalid caller or params")
-				}
-				return nil, nil
-			}))
-			body, err := json.Marshal(map[string]any{"method": "demo.limit", "params": params})
-			if err != nil {
-				t.Fatal(err)
-			}
-			_, env := post(t, srv, string(body))
-			if !env.Success || executed != 1 {
-				t.Fatalf("error=%+v executed=%d", env.Error, executed)
-			}
-		})
-	}
-}
-
-func TestJSONParamsCannotOverrideAdminPolicy(t *testing.T) {
-	for name, auth := range map[string]*fakeAuth{
-		"anonymous":   {err: ErrNoSession},
-		"normal user": {user: "bob"},
-	} {
-		t.Run(name, func(t *testing.T) {
-			executed := 0
-			srv := newTestServer(t, auth, countingRoutes(&executed)...)
-			_, env := post(t, srv, `{"method":"demo.admin","params":{"admin":true,"user":"root","roles":["admin"],"scope":"admin"}}`)
-			code := "admin_required"
-			if auth.err != nil {
-				code = "session_required"
-			}
-			if env.Error == nil || env.Error.Code != code || executed != 0 || auth.calls != 1 {
-				t.Fatalf("error=%+v executed=%d auth=%d", env.Error, executed, auth.calls)
-			}
-		})
-	}
-}

package/templates/native-go/backend/internal/api/sdk-permissions.json

@@ -1,59 +0,0 @@
-{
-  "files": {
-    "nas.session.status": "authenticated",
-    "nas.files.shares": "authenticated",
-    "nas.files.list": "authenticated",
-    "nas.files.info": "authenticated",
-    "nas.files.create_folder": "authenticated",
-    "nas.files.download": "authenticated",
-    "nas.files.upload": "authenticated"
-  },
-  "jobs": {
-    "bg.status": "authenticated",
-    "bg.browse": "authenticated",
-    "bg.jobs.submit": "authenticated",
-    "bg.jobs.list": "authenticated",
-    "bg.jobs.get": "authenticated",
-    "bg.jobs.cancel": "authenticated",
-    "bg.jobs.result": "authenticated",
-    "bg.schedules.list": "authenticated",
-    "bg.schedules.create": "authenticated",
-    "bg.schedules.disable": "authenticated",
-    "bg.schedules.delete": "authenticated",
-    "bg.jobs.purge": "administrators",
-    "bg.schedules.enable": "administrators"
-  },
-  "portal": {
-    "portal.status": "authenticated"
-  },
-  "identity": {
-    "identity.status": "public",
-    "identity.login": "public",
-    "identity.session": "public",
-    "identity.logout": "public"
-  },
-  "rootOps": {
-    "executor.status": "authenticated",
-    "executor.control": "administrators",
-    "root.run": "administrators"
-  },
-  "delegate": {
-    "delegate.destination": "authenticated",
-    "delegate.status": "authenticated",
-    "delegate.create": "authenticated",
-    "delegate.list": "authenticated",
-    "delegate.revoke": "authenticated",
-    "delegate.jobs.submit": "authenticated",
-    "delegate.jobs.list": "authenticated",
-    "delegate.jobs.cancel": "authenticated",
-    "delegate.select_destination": "authenticated",
-    "delegate.move_from_staging": "authenticated",
-    "delegate.operations.get": "authenticated",
-    "delegate.operations.list": "authenticated",
-    "delegate.operations.cancel": "authenticated",
-    "delegate.disable": "administrators",
-    "delegate.enable": "administrators",
-    "delegate.audit": "authenticated",
-    "delegate.example.export": "authenticated"
-  }
-}

package/templates/native-go/backend/internal/api/sdk_policy_test.go

@@ -1,31 +0,0 @@
-package api
-
-import (
-	"context"
-	"encoding/json"
-	"testing"
-)
-
-func TestSDKPolicyCannotBeOverridden(t *testing.T) {
-	h := func(context.Context, Caller, json.RawMessage) (any, error) { return nil, nil }
-	for _, method := range []string{"nas.files.list", "bg.jobs.purge", "identity.login"} {
-		for _, permission := range []string{"public", "authenticated", "administrators"} {
-			raw := []byte(`{"schema":1,"default":"administrators","methods":{"` + method + `":"` + permission + `"}}`)
-			if _, err := NewServerWithPermissions(&fakeAuth{}, raw, Handle(method, h)); err == nil {
-				t.Fatalf("accepted override %s %s", method, permission)
-			}
-		}
-	}
-}
-func TestSDKPolicyKeepsBothUserAndAdminBoundaries(t *testing.T) {
-	h := func(context.Context, Caller, json.RawMessage) (any, error) { return nil, nil }
-	s, err := NewServer(&fakeAuth{}, Handle("nas.files.list", h), Handle("bg.jobs.purge", h), Handle("identity.login", h), Handle("app.private", h))
-	if err != nil {
-		t.Fatal(err)
-	}
-	for name, want := range map[string]policy{"nas.files.list": policyUser, "bg.jobs.purge": policyAdmin, "identity.login": policyPublic, "app.private": policyAdmin} {
-		if s.routes[name].policy != want {
-			t.Fatal(name)
-		}
-	}
-}