appstruct-cli 0.2.0

Command-line compiler and development workflow for AppStruct applications
use super::{install_envelope, lifecycle, verification};
use appstruct_ir::ModuleOrigin;
use appstruct_module_sdk::{
    MODULE_API_VERSION, RegistryArtifact, RegistryEnvelope, RegistryPackage,
};
use base64::{Engine as _, engine::general_purpose::STANDARD};
use ed25519_dalek::{Signer, SigningKey};
use sha2::{Digest, Sha256};
use std::fs;

#[test]
fn installs_and_compiles_a_signed_remote_module_offline() {
    let project = tempfile::tempdir().unwrap();
    fs::write(
        project.path().join("appstruct.yaml"),
        "version: 1\napp:\n  name: registry-test\ndatabase:\n  provider: postgres\nincludes: []\n",
    )
    .unwrap();
    let signing = SigningKey::from_bytes(&[7_u8; 32]);
    let public_key = STANDARD.encode(signing.verifying_key().as_bytes());
    let artifact = b"# Signed module\n";
    let package = RegistryPackage {
        name: "vendor/analytics".to_owned(),
        version: "1.2.3".to_owned(),
        appstruct_version: env!("CARGO_PKG_VERSION").to_owned(),
        module_api_version: MODULE_API_VERSION,
        manifest: concat!(
            "api_version = 1\n",
            "name = \"vendor/analytics\"\n",
            "version = \"1.2.3\"\n",
            "provides = [\"analytics.events\"]\n\n",
            "[[artifacts]]\n",
            "path = \"docs/README.md\"\n",
            "source = \"assets/README.md\"\n",
        )
        .to_owned(),
        artifacts: vec![RegistryArtifact {
            source: "assets/README.md".to_owned(),
            content: STANDARD.encode(artifact),
            sha256: format!("sha256:{}", hex::encode(Sha256::digest(artifact))),
            byte_len: artifact.len() as u64,
        }],
    };
    let payload = serde_json::to_vec(&package).unwrap();
    let envelope = RegistryEnvelope {
        schema_version: 1,
        payload: STANDARD.encode(&payload),
        sha256: format!("sha256:{}", hex::encode(Sha256::digest(&payload))),
        signature: STANDARD.encode(signing.sign(&payload).to_bytes()),
    };
    install_envelope(
        project.path(),
        "https://registry.example.com",
        &public_key,
        "vendor/analytics",
        "1.2.3",
        &serde_json::to_vec(&envelope).unwrap(),
    )
    .unwrap();

    verification::verify(project.path(), None).unwrap();

    let ir = appstruct_compiler::compile_project(project.path()).unwrap();
    let module = ir
        .modules
        .iter()
        .find(|module| module.name == "vendor/analytics")
        .unwrap();
    assert_eq!(module.origin, ModuleOrigin::Remote);
    assert_eq!(module.artifacts[0].content, "# Signed module\n");

    let lock = super::read_lock(project.path()).unwrap();
    let manifest = project.path().join(&lock.modules[0].manifest_path);
    fs::write(
        manifest.parent().unwrap().join("assets/README.md"),
        "tampered\n",
    )
    .unwrap();
    let verification_error =
        verification::verify(project.path(), Some("vendor/analytics")).unwrap_err();
    assert!(verification_error.contains("cached artifact"));
    let diagnostics = appstruct_compiler::compile_project(project.path()).unwrap_err();
    assert!(
        diagnostics
            .iter()
            .any(|diagnostic| diagnostic.code == "AS3090")
    );

    let cache = manifest.parent().unwrap().to_owned();
    lifecycle::uninstall(project.path(), "vendor/analytics").unwrap();
    assert_eq!(super::read_lock(project.path()).unwrap().modules.len(), 0);
    assert!(!cache.exists());
}

#[test]
fn rejects_a_tampered_registry_signature() {
    let project = tempfile::tempdir().unwrap();
    let signing = SigningKey::from_bytes(&[9_u8; 32]);
    let envelope = RegistryEnvelope {
        schema_version: 1,
        payload: STANDARD.encode(b"{}"),
        sha256: format!("sha256:{}", hex::encode(Sha256::digest(b"{}"))),
        signature: STANDARD.encode([0_u8; 64]),
    };
    let error = install_envelope(
        project.path(),
        "https://registry.example.com",
        &STANDARD.encode(signing.verifying_key().as_bytes()),
        "vendor/analytics",
        "1.2.3",
        &serde_json::to_vec(&envelope).unwrap(),
    )
    .unwrap_err();
    assert!(error.contains("signature verification failed"));
}

#[test]
fn parse_reference_validates_shape() {
    assert_eq!(
        super::parse_reference("vendor/analytics@1.2.3").unwrap(),
        ("vendor/analytics", "1.2.3")
    );
    assert!(super::parse_reference("vendor/analytics").is_err());
    assert!(super::parse_reference("@1.2.3").is_err());
}

#[test]
fn list_and_run_cover_empty_locks_and_invalid_commands() {
    let project = tempfile::tempdir().unwrap();
    super::list(project.path()).unwrap();
    assert_eq!(
        super::run(project.path(), &super::ModuleCommand::List),
        std::process::ExitCode::SUCCESS
    );
    assert_ne!(
        super::run(
            project.path(),
            &super::ModuleCommand::Install {
                module: "bad".to_owned(),
                registry: "http://example.com".to_owned(),
                public_key: None,
            },
        ),
        std::process::ExitCode::SUCCESS
    );
    fs::write(
        project.path().join("appstruct.modules.lock"),
        "lock_version = 9\n",
    )
    .unwrap();
    assert!(super::list(project.path()).is_err());
}

#[test]
fn update_and_uninstall_require_an_installed_module() {
    let project = tempfile::tempdir().unwrap();
    assert!(
        lifecycle::update(project.path(), "vendor/analytics@1.0.0", None, None)
            .unwrap_err()
            .contains("not installed")
    );
    assert!(
        lifecycle::uninstall(project.path(), "vendor/analytics")
            .unwrap_err()
            .contains("not installed")
    );
    assert_ne!(
        super::run(
            project.path(),
            &super::ModuleCommand::Uninstall {
                module: "vendor/analytics".to_owned(),
            },
        ),
        std::process::ExitCode::SUCCESS
    );
    let _ = super::run(
        project.path(),
        &super::ModuleCommand::Verify { module: None },
    );
}