@synopackageland/templates 0.9.8 → 0.10.0

package/templates/native-rust/backend/src/app/portal.rs

@@ -1,317 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-
-use syno_pkg_land_sdk::api::{self, Caller, Route};
-use syno_pkg_land_sdk::ctx::Context;
-use syno_pkg_land_sdk::delegate::{Client, ExecutorClient};
-use syno_pkg_land_sdk::http::Request;
-use syno_pkg_land_sdk::jsonx::Empty;
-use syno_pkg_land_sdk::{BoxError, portal};
-
-use super::Config;
-use super::routes::decode_params;
-
-/// What changes the executor's entry: `portal::register` or `portal::unregister`.
-type Change =
-    fn(&Context, &dyn ExecutorClient, &BTreeMap<String, String>) -> Result<String, BoxError>;
-
-impl Config {
-    /// portal.status when dsm-package.yaml declares `portal`. An administrator
-    /// sets the alias with DSM's own AppPortal API from the UI; the package
-    /// only reads DSM's saved setting. Below DSM 7.2 the executor registers
-    /// the App's entry (`portal_executor`): portal.status then reports it, and
-    /// portal.register and portal.unregister change it.
-    pub(super) fn portal_routes(self: &Arc<Self>) -> Vec<Route> {
-        if !self.portal {
-            return Vec::new();
-        }
-        let mut routes = vec![self.handle("portal.status", Config::portal_status)];
-        if self.portal_executor {
-            routes.push(self.handle_request("portal.register", Config::portal_register));
-            routes.push(self.handle_request("portal.unregister", Config::portal_unregister));
-        }
-        routes
-    }
-
-    /// The executor at its fixed socket, unless a test supplies one.
-    fn portal_client(&self) -> Arc<dyn ExecutorClient> {
-        self.executor
-            .clone()
-            .unwrap_or_else(|| Arc::new(Client::local(&self.package_id)))
-    }
-
-    fn portal_status(
-        &self,
-        ctx: &Context,
-        _: &Caller,
-        params: &[u8],
-    ) -> Result<portal::Status, BoxError> {
-        decode_params::<Empty>(params)?;
-        Ok(self.read_portal(ctx))
-    }
-
-    fn read_portal(&self, ctx: &Context) -> portal::Status {
-        let path = match &self.portal_config {
-            Some(path) => path.to_string_lossy().into_owned(),
-            None => portal::config_path(&self.package_id),
-        };
-        let status = portal::read(path, &format!("SYNO.SDS.{}.Instance", self.package_id));
-        if !self.portal_executor {
-            return status;
-        }
-        // An unreadable entry is not a known one: with_entry reports unavailable.
-        let entry = portal::executor_entry(ctx, &*self.portal_client()).unwrap_or_default();
-        portal::with_entry(status, &entry)
-    }
-
-    fn portal_register(
-        &self,
-        ctx: &Context,
-        caller: &Caller,
-        req: &Request,
-        params: &[u8],
-    ) -> Result<portal::Status, BoxError> {
-        self.portal_change(ctx, caller, req, params, portal::register)
-    }
-
-    fn portal_unregister(
-        &self,
-        ctx: &Context,
-        caller: &Caller,
-        req: &Request,
-        params: &[u8],
-    ) -> Result<portal::Status, BoxError> {
-        self.portal_change(ctx, caller, req, params, portal::unregister)
-    }
-
-    /// Forwards the administrator's DSM session; the executor checks it again
-    /// and keeps its refusal codes, such as PORTAL_FAILED.
-    fn portal_change(
-        &self,
-        ctx: &Context,
-        caller: &Caller,
-        req: &Request,
-        params: &[u8],
-        change: Change,
-    ) -> Result<portal::Status, BoxError> {
-        api::require_admin(caller)?;
-        decode_params::<Empty>(params)?;
-        let auth = api::dsm_session(req)?;
-        change(ctx, &*self.portal_client(), &auth)?;
-        Ok(self.read_portal(ctx))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::path::PathBuf;
-    use std::sync::Mutex;
-
-    use serde_json::Value;
-    use serde_json::value::RawValue;
-    use syno_pkg_land_sdk::delegate::Auth;
-
-    use super::super::test_support::*;
-    use super::*;
-
-    const SAVED: &str = r#"{"alias":"hello-rust","id":"SYNO.SDS.HelloRust.Instance","version":3}"#;
-
-    fn portal_fixture(saved: &str) -> Fixture {
-        let mut fixture = Fixture::new();
-        let config: PathBuf = fixture.scratch().join("AppPortal.json");
-        if !saved.is_empty() {
-            std::fs::write(&config, saved).unwrap();
-        }
-        fixture.cfg.portal = true;
-        fixture.cfg.portal_config = Some(config);
-        fixture
-    }
-
-    #[test]
-    fn portal_status_tells_every_signed_in_user_the_alias() {
-        let fixture = portal_fixture(SAVED);
-        let (code, out) = call(&fixture.cfg, &bob(), "portal.status", "{}");
-        assert_eq!(code, "", "{out}");
-        assert_eq!(out["data"]["state"], "active");
-        assert_eq!(out["data"]["alias"], "hello-rust");
-        let (code, _) = call(&fixture.cfg, &nobody(), "portal.status", "{}");
-        assert_eq!(code, "session_required");
-        let (code, _) = call(&fixture.cfg, &bob(), "portal.status", r#"{"alias":"x"}"#);
-        assert_eq!(code, "bad_request");
-    }
-
-    #[test]
-    fn portal_status_fails_closed_on_another_apps_setting() {
-        let fixture = portal_fixture(r#"{"alias":"hello-rust","id":"SYNO.SDS.Other.Instance"}"#);
-        let (_, out) = call(&fixture.cfg, &bob(), "portal.status", "{}");
-        assert_eq!(out["data"]["state"], "unavailable");
-        assert!(out["data"].get("alias").is_none());
-        let (_, out) = call(&portal_fixture("").cfg, &bob(), "portal.status", "{}");
-        assert_eq!(out["data"]["state"], "inactive");
-    }
-
-    #[test]
-    fn portal_status_exists_only_for_a_portal_build() {
-        let (code, _) = call(&Fixture::new().cfg, &alice(), "portal.status", "{}");
-        assert_eq!(code, "unknown_method");
-    }
-
-    enum Failure {
-        Down,
-        Refused(&'static str),
-    }
-
-    /// The executor as the portal routes see it.
-    #[derive(Default)]
-    struct FakeEntry {
-        state: Mutex<FakeState>,
-    }
-
-    #[derive(Default)]
-    struct FakeState {
-        entry: String,
-        failure: Option<Failure>,
-        calls: Vec<String>,
-        auth: Auth,
-    }
-
-    impl ExecutorClient for FakeEntry {
-        fn call(
-            &self,
-            _: &Context,
-            op: &str,
-            auth: &Auth,
-            _: &RawValue,
-        ) -> Result<Box<RawValue>, BoxError> {
-            let mut state = self.state.lock().unwrap();
-            state.calls.push(op.to_string());
-            match &state.failure {
-                Some(Failure::Down) => return Err("executor down".into()),
-                Some(Failure::Refused(code)) => return Err(api::Error::new(code, "x").into()),
-                None => {}
-            }
-            match op {
-                "portal.register" => {
-                    (state.entry, state.auth) = (portal::ENTRY_REGISTERED.into(), auth.clone())
-                }
-                "portal.unregister" => {
-                    (state.entry, state.auth) = (portal::ENTRY_UNREGISTERED.into(), auth.clone())
-                }
-                _ => {}
-            }
-            let key = if op == "status" { "portal" } else { "entry" };
-            let reply = serde_json::json!({ key: state.entry }).to_string();
-            Ok(RawValue::from_string(reply)?)
-        }
-    }
-
-    fn executor_fixture(saved: &str, executor: &Arc<FakeEntry>) -> Fixture {
-        let mut fixture = portal_fixture(saved);
-        fixture.cfg.portal_executor = true;
-        fixture.cfg.executor = Some(executor.clone());
-        fixture
-    }
-
-    fn fake(entry: &str, failure: Option<Failure>) -> Arc<FakeEntry> {
-        Arc::new(FakeEntry {
-            state: Mutex::new(FakeState {
-                entry: entry.into(),
-                failure,
-                ..FakeState::default()
-            }),
-        })
-    }
-
-    /// An administrator's call with a DSM session.
-    fn session_call(cfg: &Config, method: &str) -> (String, Value) {
-        let mut req = api_request(method, "{}");
-        req.header.set("Cookie", "id=session");
-        req.header.set("X-SYNO-TOKEN", "token");
-        serve(
-            cfg,
-            &alice(),
-            req,
-            crate::permissions::permissions().unwrap(),
-        )
-    }
-
-    #[test]
-    fn executor_portal_status_reports_the_entry() {
-        for (entry, failure, state, alias) in [
-            (
-                portal::ENTRY_REGISTERED,
-                false,
-                "active",
-                Some("hello-rust"),
-            ),
-            (
-                portal::ENTRY_CLEANUP_REQUIRED,
-                false,
-                "active",
-                Some("hello-rust"),
-            ),
-            (portal::ENTRY_UNREGISTERED, false, "inactive", None),
-            ("", true, "unavailable", None),
-        ] {
-            let executor = fake(entry, failure.then_some(Failure::Down));
-            let fixture = executor_fixture(SAVED, &executor);
-            let (code, out) = call(&fixture.cfg, &bob(), "portal.status", "{}");
-            let data = &out["data"];
-            assert_eq!(code, "", "{entry}: {out}");
-            assert_eq!(data["state"], state, "{entry}");
-            assert_eq!(data["alias"].as_str(), alias, "{entry}");
-            if !failure {
-                assert_eq!(data["entry"], entry);
-            }
-        }
-    }
-
-    #[test]
-    fn executor_portal_register_and_unregister_return_the_fresh_status() {
-        let executor = fake(portal::ENTRY_UNREGISTERED, None);
-        let fixture = executor_fixture(SAVED, &executor);
-        let (code, out) = session_call(&fixture.cfg, "portal.register");
-        assert_eq!(code, "", "register: {out}");
-        assert_eq!(out["data"]["entry"], portal::ENTRY_REGISTERED);
-        assert_eq!(out["data"]["state"], "active");
-        assert_eq!(
-            executor.state.lock().unwrap().auth["dsm_cookie"],
-            "session",
-            "register did not forward the DSM session"
-        );
-        let (code, out) = session_call(&fixture.cfg, "portal.unregister");
-        assert_eq!(code, "", "unregister: {out}");
-        assert_eq!(out["data"]["entry"], portal::ENTRY_UNREGISTERED);
-        assert_eq!(out["data"]["state"], "inactive");
-    }
-
-    #[test]
-    fn executor_portal_changes_need_an_administrators_dsm_session() {
-        let executor = fake(portal::ENTRY_UNREGISTERED, None);
-        let fixture = executor_fixture("", &executor);
-        for method in ["portal.register", "portal.unregister"] {
-            let (code, _) = call(&fixture.cfg, &bob(), method, "{}");
-            assert_ne!(code, "", "{method}: an ordinary user changed the entry");
-            let (code, _) = call(&fixture.cfg, &alice(), method, "{}");
-            assert_eq!(code, "session_required", "{method} without a DSM session");
-        }
-        let calls = executor.state.lock().unwrap().calls.clone();
-        assert!(calls.is_empty(), "the executor was asked: {calls:?}");
-    }
-
-    #[test]
-    fn executor_portal_refusal_keeps_the_executors_code() {
-        let executor = fake("", Some(Failure::Refused("PORTAL_FAILED")));
-        let fixture = executor_fixture("", &executor);
-        let (code, _) = session_call(&fixture.cfg, "portal.register");
-        assert_eq!(code, "PORTAL_FAILED");
-    }
-
-    #[test]
-    fn portal_changes_exist_only_in_an_executor_portal_build() {
-        for method in ["portal.register", "portal.unregister"] {
-            let (code, _) = call(&portal_fixture("").cfg, &alice(), method, "{}");
-            assert_eq!(code, "unknown_method", "{method}");
-        }
-    }
-}

package/templates/native-rust/backend/src/app/root_routes.rs

@@ -1,23 +0,0 @@
-use std::sync::Arc;
-
-use syno_pkg_land_sdk::api::Route;
-
-use super::Config;
-#[cfg(test)]
-use super::test_support::Sample;
-
-impl Config {
-    /// Empty: this package declares privilege: none and never runs anything
-    /// as root. `synopkgland init -t native-rust --privilege root` overlays
-    /// this file with one that reads the results of administrator-approved
-    /// root operations.
-    pub(super) fn root_routes(self: &Arc<Self>) -> Vec<Route> {
-        Vec::new()
-    }
-}
-
-/// The root routes' samples: none.
-#[cfg(test)]
-pub(super) fn samples() -> Vec<Sample> {
-    Vec::new()
-}

package/templates/native-rust/backend/src/app/routes.rs

@@ -1,315 +0,0 @@
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-
-use serde::{Deserialize, Serialize, de::DeserializeOwned};
-use serde_json::{Value, json};
-use syno_pkg_land_sdk::api::{self, Caller, Route};
-use syno_pkg_land_sdk::ctx::Context;
-use syno_pkg_land_sdk::delegate::ExecutorClient;
-use syno_pkg_land_sdk::filestation;
-use syno_pkg_land_sdk::http::Request;
-use syno_pkg_land_sdk::time::Timestamp;
-use syno_pkg_land_sdk::{BoxError, jsonx};
-
-/// Resolves a DSM user name to its UID; empty when the account is unknown.
-pub type UidLookup = Arc<dyn Fn(&str) -> String + Send + Sync>;
-
-/// Config is fixed at build time and startup, never taken from a request.
-#[derive(Clone, Default)]
-pub struct Config {
-    pub delegate_scope: String,
-    pub delegate_operations_json: String,
-    pub delegate_destinations_json: String,
-    pub delegate_lifetime: String,
-    pub executor_digest: String,
-    pub policy_digest: String,
-
-    /// The interactive File Station adapter; None keeps the legacy refusal.
-    pub session_files: Option<Arc<filestation::Service>>,
-    pub package_id: String,
-    pub version: String,
-    /// The package's persistent, package-owned directory
-    /// (/var/packages/<package>/var). It survives upgrades.
-    pub data_dir: PathBuf,
-    /// Where /volumeN lives; None means "/". Tests set it.
-    pub volume_root: Option<PathBuf>,
-    /// Serves portal.status; `portal_executor` adds the executor's entry
-    /// below DSM 7.2. `portal_config` overrides DSM's saved AppPortal.json
-    /// path in tests.
-    pub portal: bool,
-    pub portal_executor: bool,
-    pub portal_config: Option<PathBuf>,
-
-    /// Test seams: the production values are the system's user database and
-    /// the executor's socket under /run/synopkgland.
-    pub uid_lookup: Option<UidLookup>,
-    pub executor: Option<Arc<dyn ExecutorClient>>,
-}
-
-pub fn routes(cfg: Config) -> Vec<Route> {
-    let cfg = Arc::new(cfg);
-    let mut routes = vec![
-        cfg.handle("app.status", Config::status),
-        cfg.handle("greeting.get", Config::get_greeting),
-        cfg.handle("greeting.set", Config::set_greeting),
-    ];
-    if let Some(files) = &cfg.session_files {
-        routes.extend(files.routes());
-    }
-    routes.extend(cfg.portal_routes());
-    routes.extend(cfg.background_routes());
-    routes.extend(cfg.root_routes());
-    routes.extend(cfg.delegate_routes());
-    routes
-}
-
-type PlainFn<T> = fn(&Config, &Context, &Caller, &[u8]) -> Result<T, BoxError>;
-type RequestFn<T> = fn(&Config, &Context, &Caller, &Request, &[u8]) -> Result<T, BoxError>;
-
-impl Config {
-    /// A route whose handler needs only the caller and its params.
-    pub(super) fn handle<T: Serialize + 'static>(
-        self: &Arc<Self>,
-        method: &str,
-        handler: PlainFn<T>,
-    ) -> Route {
-        let cfg = self.clone();
-        Route::handle(method, move |ctx, caller, params| {
-            handler(&cfg, ctx, caller, params)
-        })
-    }
-
-    /// A route whose handler also needs the authenticated HTTP request.
-    pub(super) fn handle_request<T: Serialize + 'static>(
-        self: &Arc<Self>,
-        method: &str,
-        handler: RequestFn<T>,
-    ) -> Route {
-        let cfg = self.clone();
-        Route::handle_request(method, move |ctx, caller, req, params| {
-            handler(&cfg, ctx, caller, req, params)
-        })
-    }
-
-    fn status(&self, _: &Context, caller: &Caller, _: &[u8]) -> Result<Value, BoxError> {
-        // SAFETY: getuid and getgid take no arguments and cannot fail.
-        let (uid, gid) = unsafe { (libc::getuid(), libc::getgid()) };
-        Ok(self.with_shared_folders(json!({
-            "package": self.package_id,
-            "version": self.version,
-            "user": caller.user(),
-            "admin": caller.admin(),
-            "process": {"uid": uid, "gid": gid},
-            "language": "rust",
-            "platform": format!("{}/{}", std::env::consts::OS, std::env::consts::ARCH),
-            "time": Timestamp::from_unix_nanos(i128::from(Timestamp::now().unix()) * 1_000_000_000).to_string(),
-        })))
-    }
-
-    fn greeting_path(&self) -> PathBuf {
-        self.data_dir.join("greeting.json")
-    }
-
-    fn get_greeting(&self, _: &Context, _: &Caller, _: &[u8]) -> Result<Greeting, BoxError> {
-        match std::fs::read(self.greeting_path()) {
-            Ok(data) => Ok(serde_json::from_slice(&data)?),
-            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Greeting {
-                text: "Hello".into(),
-                updated_by: String::new(),
-            }),
-            Err(e) => Err(e.into()),
-        }
-    }
-
-    fn set_greeting(
-        &self,
-        _: &Context,
-        caller: &Caller,
-        params: &[u8],
-    ) -> Result<Greeting, BoxError> {
-        #[derive(Default, Deserialize)]
-        #[serde(deny_unknown_fields)]
-        struct Params {
-            #[serde(default)]
-            text: String,
-        }
-        let params: Params = decode_params(params)?;
-        let length = params.text.chars().count();
-        if !(1..=200).contains(&length) {
-            return Err(api::Error::bad_request("text must be 1 to 200 characters").into());
-        }
-        let greeting = Greeting {
-            text: params.text,
-            updated_by: caller.user().to_string(),
-        };
-        write_file_atomic(&self.greeting_path(), &jsonx::to_vec(&greeting)?)?;
-        Ok(greeting)
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-struct Greeting {
-    text: String,
-    #[serde(default, skip_serializing_if = "String::is_empty")]
-    updated_by: String,
-}
-
-/// Decodes params strictly: unknown fields are an error.
-pub(super) fn decode_params<T: DeserializeOwned + Default>(params: &[u8]) -> Result<T, api::Error> {
-    let params = if params.is_empty() { b"{}" } else { params };
-    jsonx::strict(params).map_err(|e| api::Error::bad_request(&format!("invalid params: {e}")))
-}
-
-/// Replaces path in one rename, so readers never see half a file.
-pub(super) fn write_file_atomic(path: &Path, data: &[u8]) -> std::io::Result<()> {
-    use std::io::Write;
-    use std::os::unix::fs::OpenOptionsExt;
-    use std::sync::atomic::{AtomicU64, Ordering};
-
-    static NEXT: AtomicU64 = AtomicU64::new(0);
-    let tmp = path.with_file_name(format!(
-        ".tmp-{}-{}",
-        std::process::id(),
-        NEXT.fetch_add(1, Ordering::Relaxed)
-    ));
-    let written = std::fs::OpenOptions::new()
-        .write(true)
-        .create_new(true)
-        .mode(0o600)
-        .open(&tmp)
-        .and_then(|mut f| f.write_all(data).and_then(|()| f.flush()))
-        .and_then(|()| std::fs::rename(&tmp, path));
-    if written.is_err() {
-        let _ = std::fs::remove_file(&tmp);
-    }
-    written
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::test_support::*;
-    use super::*;
-    use syno_pkg_land_sdk::api::ADMINISTRATOR_PERMISSION;
-
-    #[test]
-    fn every_route_has_sample_params_and_none_is_public() {
-        let fixture = Fixture::new();
-        let routes = routes(fixture.cfg.clone());
-        assert_eq!(
-            routes.len(),
-            samples().len(),
-            "add the new route to test_support::samples"
-        );
-        for r in &routes {
-            params_of(r.method());
-            assert_ne!(
-                rule(r),
-                "public",
-                "route {} is public; this template ships none",
-                r.method()
-            );
-        }
-    }
-
-    #[test]
-    fn every_route_refuses_callers_without_a_session_and_changes_nothing() {
-        for r in routes(Fixture::new().cfg) {
-            let fixture = Fixture::new();
-            let (code, _) = call(&fixture.cfg, &nobody(), r.method(), &params_of(r.method()));
-            assert_eq!(code, "session_required", "{}", r.method());
-            fixture.assert_data_dir_empty();
-        }
-    }
-
-    #[test]
-    fn administrator_routes_refuse_ordinary_users_and_change_nothing() {
-        for r in routes(Fixture::new().cfg) {
-            if rule(&r) != ADMINISTRATOR_PERMISSION {
-                continue;
-            }
-            let fixture = Fixture::new();
-            let (code, _) = call(&fixture.cfg, &bob(), r.method(), &params_of(r.method()));
-            assert_eq!(code, "admin_required", "{}", r.method());
-            fixture.assert_data_dir_empty();
-        }
-    }
-
-    #[test]
-    fn every_route_succeeds_for_an_admin() {
-        for sample in samples() {
-            let (code, out) = call(&Fixture::new().cfg, &alice(), sample.method, &sample.params);
-            assert_eq!(code, sample.outcome, "{}: {out}", sample.method);
-        }
-    }
-
-    #[test]
-    fn file_station_routes_exist_only_with_the_session_adapter() {
-        let mut fixture = Fixture::new();
-        let (code, _) = call(&fixture.cfg, &alice(), "nas.session.status", "{}");
-        assert_eq!(code, "unknown_method");
-        fixture.cfg.session_files = Some(Arc::new(filestation::Service::default()));
-        let (code, _) = call(&fixture.cfg, &nobody(), "nas.session.status", "{}");
-        assert_eq!(code, "session_required");
-        let (code, _) = call(&fixture.cfg, &alice(), "nas.session.status", "{}");
-        assert_eq!(
-            code, "unavailable",
-            "an adapter without a DSM client refuses"
-        );
-    }
-
-    #[test]
-    fn status_reports_package_and_caller() {
-        let (code, out) = call(&Fixture::new().cfg, &alice(), "app.status", "{}");
-        let data = &out["data"];
-        assert_eq!(code, "");
-        assert_eq!(data["package"], "HelloRust");
-        assert_eq!(data["version"], "0.1.0-0001");
-        assert_eq!(data["user"], "alice");
-        assert_eq!(data["admin"], true);
-        assert!(data["process"]["uid"].is_u64() && data["process"]["gid"].is_u64());
-        assert_eq!(data["language"], "rust");
-        assert!(data["time"].as_str().unwrap().ends_with('Z'));
-    }
-
-    #[test]
-    fn greeting_defaults_and_admin_can_change_it() {
-        let fixture = Fixture::new();
-        let (_, out) = call(&fixture.cfg, &alice(), "greeting.get", "{}");
-        assert_eq!(out["data"]["text"], "Hello");
-        let (code, out) = call(
-            &fixture.cfg,
-            &alice(),
-            "greeting.set",
-            r#"{"text":"Hi from DSM"}"#,
-        );
-        assert_eq!(code, "", "{out}");
-        let (_, out) = call(&fixture.cfg, &alice(), "greeting.get", "{}");
-        assert_eq!(out["data"]["text"], "Hi from DSM");
-        assert_eq!(out["data"]["updated_by"], "alice");
-    }
-
-    #[test]
-    fn greeting_set_validates_text() {
-        let too_long = format!(r#"{{"text":"{}"}}"#, "x".repeat(201));
-        for params in [
-            "{}",
-            r#"{"text":""}"#,
-            too_long.as_str(),
-            r#"{"text":7}"#,
-            r#"{"text":"ok","extra":1}"#,
-        ] {
-            let fixture = Fixture::new();
-            let (code, _) = call(&fixture.cfg, &alice(), "greeting.set", params);
-            assert_eq!(code, "bad_request", "{params}");
-            fixture.assert_data_dir_empty();
-        }
-    }
-
-    #[test]
-    fn greeting_text_counts_characters_not_bytes() {
-        let fixture = Fixture::new();
-        let params = format!(r#"{{"text":"{}"}}"#, "\u{5b57}".repeat(200));
-        let (code, out) = call(&fixture.cfg, &alice(), "greeting.set", &params);
-        assert_eq!(code, "", "{out}");
-    }
-}

package/templates/native-rust/backend/src/app/session_files.rs

@@ -1,19 +0,0 @@
-/// Selects the interactive File Station adapter using the caller's DSM session.
-pub const FILE_STATION_SESSION: &str = "session";
-
-/// Accepts only the fixed build-time session setting.
-pub fn session_files_enabled(file_station: &str) -> bool {
-    file_station == FILE_STATION_SESSION
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn session_files_are_enabled_by_the_trusted_build_setting() {
-        for (value, want) in [("", false), ("session", true), ("yes", false)] {
-            assert_eq!(session_files_enabled(value), want, "{value:?}");
-        }
-    }
-}