swc/crates/swc_plugin_runner/tests/issues.rs

#![cfg_attr(not(feature = "__rkyv"), allow(warnings))]

use std::{
    env, fs,
    path::{Path, PathBuf},
    process::{Command, Stdio},
    sync::Arc,
};

use anyhow::{anyhow, Error};
use serde_json::json;
#[cfg(feature = "__rkyv")]
use swc_common::plugin::serialized::PluginSerializedBytes;
use swc_common::{collections::AHashMap, plugin::metadata::TransformPluginMetadataContext, Mark};
use swc_ecma_ast::{CallExpr, Callee, EsVersion, Expr, Lit, MemberExpr, Program, Str};
use swc_ecma_parser::{parse_file_as_program, Syntax};
use swc_ecma_visit::Visit;
use testing::CARGO_TARGET_DIR;

/// Returns the path to the built plugin
fn build_plugin(dir: &Path, crate_name: &str) -> Result<PathBuf, Error> {
    {
        let mut cmd = Command::new("cargo");
        cmd.env("CARGO_TARGET_DIR", &*CARGO_TARGET_DIR);
        cmd.current_dir(dir);
        cmd.args(["build", "--release", "--target=wasm32-wasi"])
            .stderr(Stdio::inherit());
        cmd.output()?;

        if !cmd
            .status()
            .expect("Exit code should be available")
            .success()
        {
            return Err(anyhow!("Failed to build plugin"));
        }
    }

    for entry in fs::read_dir(&CARGO_TARGET_DIR.join("wasm32-wasi").join("release"))? {
        let entry = entry?;

        let s = entry.file_name().to_string_lossy().into_owned();
        if s.eq_ignore_ascii_case(&format!("{}.wasm", crate_name)) {
            return Ok(entry.path());
        }
    }

    Err(anyhow!("Could not find built plugin"))
}

struct TestVisitor {
    pub plugin_transform_found: bool,
}

impl Visit for TestVisitor {
    fn visit_call_expr(&mut self, call: &CallExpr) {
        if let Callee::Expr(expr) = &call.callee {
            if let Expr::Member(MemberExpr { obj, .. }) = &**expr {
                if let Expr::Ident(ident) = &**obj {
                    if ident.sym == *"console" {
                        let args = &*(call.args[0].expr);
                        if let Expr::Lit(Lit::Str(Str { value, .. })) = args {
                            self.plugin_transform_found = value == "changed_via_plugin";
                        }
                    }
                }
            }
        }
    }
}

#[cfg(feature = "__rkyv")]
#[test]
fn issue_6404() -> Result<(), Error> {
    use swc_common::plugin::serialized::VersionedSerializable;

    let plugin_path = build_plugin(
        &PathBuf::from(env::var("CARGO_MANIFEST_DIR")?)
            .join("tests")
            .join("fixture")
            .join("issue_6404"),
        "swc_issue_6404",
    )?;

    dbg!("Built!");

    // run single plugin
    testing::run_test(false, |cm, _handler| {
        let fm = cm
            .load_file("../swc_ecma_minifier/benches/full/typescript.js".as_ref())
            .unwrap();

        let program = parse_file_as_program(
            &fm,
            Syntax::Es(Default::default()),
            EsVersion::latest(),
            None,
            &mut vec![],
        )
        .unwrap();

        let program = PluginSerializedBytes::try_serialize(&VersionedSerializable::new(program))
            .expect("Should serializable");
        let experimental_metadata: AHashMap<String, String> = [
            (
                "TestExperimental".to_string(),
                "ExperimentalValue".to_string(),
            ),
            ("OtherTest".to_string(), "OtherVal".to_string()),
        ]
        .into_iter()
        .collect();

        let raw_module_bytes =
            std::fs::read(&plugin_path).expect("Should able to read plugin bytes");
        let store = wasmer::Store::default();
        let module = wasmer::Module::new(&store, raw_module_bytes).unwrap();

        let plugin_module = swc_plugin_runner::plugin_module_bytes::CompiledPluginModuleBytes::new(
            plugin_path
                .as_os_str()
                .to_str()
                .expect("Should able to get path")
                .to_string(),
            module,
            store,
        );

        let mut plugin_transform_executor = swc_plugin_runner::create_plugin_transform_executor(
            &cm,
            &Mark::new(),
            &Arc::new(TransformPluginMetadataContext::new(
                None,
                "development".to_string(),
                Some(experimental_metadata),
            )),
            Box::new(plugin_module),
            Some(json!({ "pluginConfig": "testValue" })),
            None,
        );

        /* [TODO]: reenable this test
        assert!(!plugin_transform_executor
            .plugin_core_diag
            .pkg_version
            .is_empty());
         */

        let program_bytes = plugin_transform_executor
            .transform(&program, Some(false))
            .expect("Plugin should apply transform");

        let _: Program = program_bytes
            .deserialize()
            .expect("Should able to deserialize")
            .into_inner();

        Ok(())
    })
    .expect("Should able to run single plugin transform");

    Ok(())
}