clusterflux-public/crates/disasmer-sdk/tests/macros.rs

use futures_executor::block_on;

#[disasmer::main]
fn build_main() -> u32 {
    1
}

#[disasmer::main(name = "release")]
fn release_main() -> u32 {
    2
}

#[disasmer::task(name = "compile-linux")]
fn compile_linux() -> u32 {
    41
}

#[disasmer::task]
fn package_release() -> disasmer::Artifact {
    disasmer::Artifact {
        id: "artifact://package/release.tar.zst".to_owned(),
    }
}

#[test]
fn disasmer_attributes_and_spawn_api_compile_for_rust_build_workflow() {
    let program = disasmer::RegisteredProgram {
        entrypoints: &[
            __DISASMER_ENTRYPOINT_BUILD_MAIN,
            __DISASMER_ENTRYPOINT_RELEASE_MAIN,
        ],
        tasks: &[
            __DISASMER_TASK_COMPILE_LINUX,
            __DISASMER_TASK_PACKAGE_RELEASE,
        ],
    };
    assert_eq!(
        program.select_entrypoint("build").unwrap().function,
        "build_main"
    );
    assert_eq!(
        program.select_entrypoint("release").unwrap().function,
        "release_main"
    );
    assert_eq!(
        program.task("compile-linux").unwrap().function,
        "compile_linux"
    );
    assert!(program.task("compile-linux").unwrap().remotely_startable);

    let result = block_on(async {
        let handle = disasmer::spawn::task(|| compile_linux() + build_main())
            .name("compile linux")
            .env(disasmer::env!("linux"))
            .start()
            .await;

        assert!(handle.virtual_thread_id() > 0);
        handle.join().await
    });

    assert_eq!(result, 42);
    assert_eq!(release_main(), 2);
}

#[test]
fn task_boundaries_accept_small_values_and_runtime_handles() {
    let small = disasmer::validate_task_arg(&7_u32, disasmer::TaskArgBudget::default()).unwrap();
    assert_eq!(small.kind, disasmer::TaskArgKind::SmallSerialized);

    let artifact = package_release();
    let artifact = disasmer::validate_task_arg(
        &artifact,
        disasmer::TaskArgBudget {
            max_inline_bytes: 4,
        },
    )
    .unwrap();
    assert_eq!(artifact.kind, disasmer::TaskArgKind::Handle);
}