@synopackageland/templates 0.9.8 → 0.10.0

package/templates/native-rust/backend/src/app/background/schedule.rs

@@ -1,126 +0,0 @@
-//! Recurring copies of an imported job: owners manage their own, an
-//! administrator re-approves them.
-
-use serde::Deserialize;
-use serde_json::{Value, json};
-use syno_pkg_land_sdk::api::{self, Caller};
-use syno_pkg_land_sdk::background::{Access, ScheduleRequest};
-use syno_pkg_land_sdk::ctx::Context;
-use syno_pkg_land_sdk::http::Request;
-use syno_pkg_land_sdk::{BoxError, jsonx};
-
-use super::{BackgroundApi, background_error, decode_id, identity_unavailable};
-use crate::app::routes::decode_params;
-
-impl BackgroundApi {
-    pub(super) fn schedules(
-        &self,
-        ctx: &Context,
-        _: &Caller,
-        _: &Request,
-        access: &Access,
-        params: &[u8],
-    ) -> Result<Value, BoxError> {
-        decode_params::<jsonx::Empty>(params)?;
-        let list = self
-            .store
-            .schedules(ctx, access)
-            .map_err(background_error)?;
-        Ok(json!({"schedules": list}))
-    }
-
-    pub(super) fn create_schedule(
-        &self,
-        ctx: &Context,
-        _: &Caller,
-        _: &Request,
-        access: &Access,
-        params: &[u8],
-    ) -> Result<Value, BoxError> {
-        #[derive(Default, Deserialize)]
-        #[serde(deny_unknown_fields, rename_all = "camelCase")]
-        struct Params {
-            #[serde(default)]
-            key: String,
-            #[serde(default)]
-            job_id: String,
-            #[serde(default)]
-            interval_seconds: i64,
-            #[serde(default)]
-            consent: bool,
-        }
-        let params: Params = decode_params(params)?;
-        if !access.owner.valid() {
-            return Err(identity_unavailable().into());
-        }
-        let request = ScheduleRequest {
-            key: params.key,
-            job_id: params.job_id,
-            interval_seconds: params.interval_seconds,
-            consent: params.consent,
-        };
-        let (schedule, duplicate) = self
-            .store
-            .create_schedule(ctx, &request, access)
-            .map_err(background_error)?;
-        Ok(json!({"schedule": schedule, "duplicate": duplicate}))
-    }
-
-    pub(super) fn disable_schedule(
-        &self,
-        ctx: &Context,
-        _: &Caller,
-        _: &Request,
-        access: &Access,
-        params: &[u8],
-    ) -> Result<Value, BoxError> {
-        let id = decode_id(params)?;
-        let schedule = self
-            .store
-            .set_schedule(ctx, &id, false, access)
-            .map_err(background_error)?;
-        Ok(json!({"schedule": schedule}))
-    }
-
-    pub(super) fn enable_schedule(
-        &self,
-        ctx: &Context,
-        _: &Caller,
-        _: &Request,
-        access: &Access,
-        params: &[u8],
-    ) -> Result<Value, BoxError> {
-        #[derive(Default, Deserialize)]
-        #[serde(deny_unknown_fields)]
-        struct Params {
-            #[serde(default)]
-            id: String,
-            #[serde(default)]
-            consent: bool,
-        }
-        let params = match decode_params::<Params>(params) {
-            Ok(p) if p.consent => p,
-            _ => return Err(api::Error::bad_request("explicit consent is required").into()),
-        };
-        let schedule = self
-            .store
-            .set_schedule(ctx, &params.id, true, access)
-            .map_err(background_error)?;
-        Ok(json!({"schedule": schedule}))
-    }
-
-    pub(super) fn delete_schedule(
-        &self,
-        ctx: &Context,
-        _: &Caller,
-        _: &Request,
-        access: &Access,
-        params: &[u8],
-    ) -> Result<Value, BoxError> {
-        let id = decode_id(params)?;
-        self.store
-            .delete_schedule(ctx, &id, access)
-            .map_err(background_error)?;
-        Ok(json!({"deleted": true}))
-    }
-}

package/templates/native-rust/backend/src/app/background/schedule_tests.rs

@@ -1,108 +0,0 @@
-use syno_pkg_land_sdk::background::{JobResult, Outcome, State};
-use syno_pkg_land_sdk::ctx::Context;
-
-use super::tests::{Env, data, id_params};
-use crate::app::test_support::{Stub, alice, bob, carol};
-
-fn ordinary_env() -> Env {
-    let env = Env::new();
-    env.set_uid(|name| match name {
-        "alice" => "1024".into(),
-        "bob" => "1025".into(),
-        "carol" => "1026".into(),
-        _ => String::new(),
-    });
-    env
-}
-
-fn submit_and_finish(env: &Env, auth: &Stub) -> String {
-    let (code, out) = env.call(
-        auth,
-        "bg.jobs.submit",
-        r#"{"key":"copy","folder":"/share","relative":"a.txt"}"#,
-    );
-    assert_eq!(code, "", "{out}");
-    let id: String = data(&out)["job"]["id"].as_str().unwrap().into();
-    let ctx = Context::background();
-    env.store.claim(&ctx).unwrap();
-    env.store
-        .finish(
-            &ctx,
-            &id,
-            Outcome {
-                state: State::Succeeded,
-                result: Some(JobResult {
-                    bytes: 5,
-                    ..JobResult::default()
-                }),
-                ..Outcome::default()
-            },
-        )
-        .unwrap();
-    id
-}
-
-fn schedule_count(env: &Env, auth: &Stub) -> usize {
-    let (_, out) = env.call(auth, "bg.schedules.list", "{}");
-    data(&out)["schedules"].as_array().unwrap().len()
-}
-
-#[test]
-fn schedule_routes_consent_owner_and_admin() {
-    let env = ordinary_env();
-    let id = submit_and_finish(&env, &bob());
-    let params = format!(r#"{{"key":"s","jobId":"{id}","intervalSeconds":3600,"consent":true}}"#);
-    assert_eq!(
-        env.call(&carol(), "bg.schedules.create", &params).0,
-        "not_found"
-    );
-    for bad in [
-        format!(r#"{{"key":"s","jobId":"{id}","intervalSeconds":3600}}"#),
-        format!(
-            r#"{{"key":"s","jobId":"{id}","intervalSeconds":3600,"consent":true,"owner":"carol"}}"#
-        ),
-    ] {
-        assert_eq!(
-            env.call(&bob(), "bg.schedules.create", &bad).0,
-            "bad_request",
-            "{bad}"
-        );
-    }
-    let (code, out) = env.call(&bob(), "bg.schedules.create", &params);
-    assert_eq!(code, "", "create: {out}");
-    let sid = data(&out)["schedule"]["id"].as_str().unwrap().to_string();
-    assert_eq!(schedule_count(&env, &carol()), 0, "list leak");
-    assert_eq!(schedule_count(&env, &alice()), 1, "admin list");
-    for method in ["bg.schedules.disable", "bg.schedules.delete"] {
-        assert_eq!(
-            env.call(&carol(), method, &id_params(&sid)).0,
-            "not_found",
-            "{method}"
-        );
-    }
-    let enable = format!(r#"{{"id":"{sid}","consent":true}}"#);
-    assert_eq!(
-        env.call(&bob(), "bg.schedules.enable", &enable).0,
-        "admin_required"
-    );
-    assert_eq!(
-        env.call(&alice(), "bg.schedules.disable", &id_params(&sid))
-            .0,
-        ""
-    );
-    assert_eq!(
-        env.call(&alice(), "bg.schedules.enable", &id_params(&sid))
-            .0,
-        "bad_request"
-    );
-    assert_eq!(env.call(&alice(), "bg.schedules.enable", &enable).0, "");
-    assert_eq!(
-        env.call(&bob(), "bg.schedules.delete", &id_params(&sid)).0,
-        ""
-    );
-    assert_eq!(
-        env.files.calls(),
-        1,
-        "no scheduling route calls File Station, uses a root grant or stores a session"
-    );
-}