denoland-deno/cli/tests/integration/bundle_tests.rs

// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.

use test_util as util;
use test_util::assert_contains;
use test_util::assert_ends_with;
use test_util::TempDir;

#[test]
fn bundle_exports() {
  // First we have to generate a bundle of some module that has exports.
  let mod1 = util::testdata_path().join("subdir/mod1.ts");
  assert!(mod1.is_file());
  let t = TempDir::new();
  let bundle = t.path().join("mod1.bundle.js");
  let mut deno = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("bundle")
    .arg(mod1)
    .arg(&bundle)
    .spawn()
    .unwrap();
  let status = deno.wait().unwrap();
  assert!(status.success());
  assert!(bundle.is_file());

  // Now we try to use that bundle from another module.
  let test = t.path().join("test.js");
  std::fs::write(
    &test,
    "
      import { printHello3 } from \"./mod1.bundle.js\";
      printHello3(); ",
  )
  .unwrap();

  let output = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("run")
    .arg(&test)
    .output()
    .unwrap();
  // check the output of the test.ts program.
  assert_ends_with!(
    std::str::from_utf8(&output.stdout).unwrap().trim(),
    "Hello",
  );
  assert_eq!(output.stderr, b"");
}

#[test]
fn bundle_exports_no_check() {
  // First we have to generate a bundle of some module that has exports.
  let mod1 = util::testdata_path().join("subdir/mod1.ts");
  assert!(mod1.is_file());
  let t = TempDir::new();
  let bundle = t.path().join("mod1.bundle.js");
  let mut deno = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("bundle")
    .arg(mod1)
    .arg(&bundle)
    .spawn()
    .unwrap();
  let status = deno.wait().unwrap();
  assert!(status.success());
  assert!(bundle.is_file());

  // Now we try to use that bundle from another module.
  let test = t.path().join("test.js");
  std::fs::write(
    &test,
    "
      import { printHello3 } from \"./mod1.bundle.js\";
      printHello3(); ",
  )
  .unwrap();

  let output = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("run")
    .arg(&test)
    .output()
    .unwrap();
  // check the output of the test.ts program.
  assert_ends_with!(
    std::str::from_utf8(&output.stdout).unwrap().trim(),
    "Hello",
  );
  assert_eq!(output.stderr, b"");
}

#[test]
fn bundle_circular() {
  // First we have to generate a bundle of some module that has exports.
  let circular1_path = util::testdata_path().join("subdir/circular1.ts");
  assert!(circular1_path.is_file());
  let t = TempDir::new();
  let bundle_path = t.path().join("circular1.bundle.js");

  // run this twice to ensure it works even when cached
  for _ in 0..2 {
    let mut deno = util::deno_cmd_with_deno_dir(&t)
      .current_dir(util::testdata_path())
      .arg("bundle")
      .arg(&circular1_path)
      .arg(&bundle_path)
      .spawn()
      .unwrap();
    let status = deno.wait().unwrap();
    assert!(status.success());
    assert!(bundle_path.is_file());
  }

  let output = util::deno_cmd_with_deno_dir(&t)
    .current_dir(util::testdata_path())
    .arg("run")
    .arg(&bundle_path)
    .output()
    .unwrap();
  // check the output of the the bundle program.
  assert_ends_with!(
    std::str::from_utf8(&output.stdout).unwrap().trim(),
    "f2\nf1",
  );
  assert_eq!(output.stderr, b"");
}

#[test]
fn bundle_single_module() {
  // First we have to generate a bundle of some module that has exports.
  let single_module = util::testdata_path().join("subdir/single_module.ts");
  assert!(single_module.is_file());
  let t = TempDir::new();
  let bundle = t.path().join("single_module.bundle.js");
  let mut deno = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("bundle")
    .arg(single_module)
    .arg(&bundle)
    .spawn()
    .unwrap();
  let status = deno.wait().unwrap();
  assert!(status.success());
  assert!(bundle.is_file());

  let output = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("run")
    .arg(&bundle)
    .output()
    .unwrap();
  // check the output of the the bundle program.
  assert_ends_with!(
    std::str::from_utf8(&output.stdout).unwrap().trim(),
    "Hello world!",
  );
  assert_eq!(output.stderr, b"");
}

#[test]
fn bundle_tla() {
  // First we have to generate a bundle of some module that has exports.
  let tla_import = util::testdata_path().join("subdir/tla.ts");
  assert!(tla_import.is_file());
  let t = TempDir::new();
  let bundle = t.path().join("tla.bundle.js");
  let mut deno = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("bundle")
    .arg(tla_import)
    .arg(&bundle)
    .spawn()
    .unwrap();
  let status = deno.wait().unwrap();
  assert!(status.success());
  assert!(bundle.is_file());

  // Now we try to use that bundle from another module.
  let test = t.path().join("test.js");
  std::fs::write(
    &test,
    "
      import { foo } from \"./tla.bundle.js\";
      console.log(foo); ",
  )
  .unwrap();

  let output = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("run")
    .arg(&test)
    .output()
    .unwrap();
  // check the output of the test.ts program.
  assert_ends_with!(
    std::str::from_utf8(&output.stdout).unwrap().trim(),
    "Hello",
  );
  assert_eq!(output.stderr, b"");
}

#[test]
fn bundle_js() {
  // First we have to generate a bundle of some module that has exports.
  let mod6 = util::testdata_path().join("subdir/mod6.js");
  assert!(mod6.is_file());
  let t = TempDir::new();
  let bundle = t.path().join("mod6.bundle.js");
  let mut deno = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("bundle")
    .arg(mod6)
    .arg(&bundle)
    .spawn()
    .unwrap();
  let status = deno.wait().unwrap();
  assert!(status.success());
  assert!(bundle.is_file());

  let output = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("run")
    .arg(&bundle)
    .output()
    .unwrap();
  // check that nothing went to stderr
  assert_eq!(output.stderr, b"");
}

#[test]
fn bundle_dynamic_import() {
  let _g = util::http_server();
  let dynamic_import = util::testdata_path().join("bundle/dynamic_import.ts");
  assert!(dynamic_import.is_file());
  let t = TempDir::new();
  let output_path = t.path().join("bundle_dynamic_import.bundle.js");
  let mut deno = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("bundle")
    .arg(dynamic_import)
    .arg(&output_path)
    .spawn()
    .unwrap();
  let status = deno.wait().unwrap();
  assert!(status.success());
  assert!(output_path.is_file());

  let output = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("run")
    .arg("--allow-net")
    .arg("--quiet")
    .arg(&output_path)
    .output()
    .unwrap();
  // check the output of the test.ts program.
  assert_ends_with!(
    std::str::from_utf8(&output.stdout).unwrap().trim(),
    "Hello",
  );
  assert_eq!(output.stderr, b"");
}

#[test]
fn bundle_import_map() {
  let import = util::testdata_path().join("bundle/import_map/main.ts");
  let import_map_path =
    util::testdata_path().join("bundle/import_map/import_map.json");
  assert!(import.is_file());
  let t = TempDir::new();
  let output_path = t.path().join("import_map.bundle.js");
  let mut deno = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("bundle")
    .arg("--import-map")
    .arg(import_map_path)
    .arg(import)
    .arg(&output_path)
    .spawn()
    .unwrap();
  let status = deno.wait().unwrap();
  assert!(status.success());
  assert!(output_path.is_file());

  // Now we try to use that bundle from another module.
  let test = t.path().join("test.js");
  std::fs::write(
    &test,
    "
      import { printHello3 } from \"./import_map.bundle.js\";
      printHello3(); ",
  )
  .unwrap();

  let output = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("run")
    .arg("--check")
    .arg(&test)
    .output()
    .unwrap();
  // check the output of the test.ts program.
  assert_ends_with!(
    std::str::from_utf8(&output.stdout).unwrap().trim(),
    "Hello",
  );
  assert_eq!(output.stderr, b"");
}

#[test]
fn bundle_import_map_no_check() {
  let import = util::testdata_path().join("bundle/import_map/main.ts");
  let import_map_path =
    util::testdata_path().join("bundle/import_map/import_map.json");
  assert!(import.is_file());
  let t = TempDir::new();
  let output_path = t.path().join("import_map.bundle.js");
  let mut deno = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("bundle")
    .arg("--import-map")
    .arg(import_map_path)
    .arg(import)
    .arg(&output_path)
    .spawn()
    .unwrap();
  let status = deno.wait().unwrap();
  assert!(status.success());
  assert!(output_path.is_file());

  // Now we try to use that bundle from another module.
  let test = t.path().join("test.js");
  std::fs::write(
    &test,
    "
      import { printHello3 } from \"./import_map.bundle.js\";
      printHello3(); ",
  )
  .unwrap();

  let output = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("run")
    .arg(&test)
    .output()
    .unwrap();
  // check the output of the test.ts program.
  assert_ends_with!(
    std::str::from_utf8(&output.stdout).unwrap().trim(),
    "Hello",
  );
  assert_eq!(output.stderr, b"");
}

#[test]
fn bundle_json_module() {
  // First we have to generate a bundle of some module that has exports.
  let mod7 = util::testdata_path().join("subdir/mod7.js");
  assert!(mod7.is_file());
  let t = TempDir::new();
  let bundle = t.path().join("mod7.bundle.js");
  let mut deno = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("bundle")
    .arg(mod7)
    .arg(&bundle)
    .spawn()
    .unwrap();
  let status = deno.wait().unwrap();
  assert!(status.success());
  assert!(bundle.is_file());

  let output = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("run")
    .arg(&bundle)
    .output()
    .unwrap();
  // check that nothing went to stderr
  assert_eq!(output.stderr, b"");
  // ensure the output looks right
  assert_contains!(String::from_utf8(output.stdout).unwrap(), "with space",);
}

#[test]
fn bundle_json_module_escape_sub() {
  // First we have to generate a bundle of some module that has exports.
  let mod8 = util::testdata_path().join("subdir/mod8.js");
  assert!(mod8.is_file());
  let t = TempDir::new();
  let bundle = t.path().join("mod8.bundle.js");
  let mut deno = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("bundle")
    .arg(mod8)
    .arg(&bundle)
    .spawn()
    .unwrap();
  let status = deno.wait().unwrap();
  assert!(status.success());
  assert!(bundle.is_file());

  let output = util::deno_cmd()
    .current_dir(util::testdata_path())
    .arg("run")
    .arg(&bundle)
    .output()
    .unwrap();
  // check that nothing went to stderr
  assert_eq!(output.stderr, b"");
  // make sure the output looks right and the escapes were effective
  assert_contains!(
    String::from_utf8(output.stdout).unwrap(),
    "${globalThis}`and string literal`",
  );
}

itest!(lockfile_check_error {
  args: "bundle --lock=bundle/lockfile/check_error.json http://127.0.0.1:4545/subdir/mod1.ts",
  output: "bundle/lockfile/check_error.out",
  exit_code: 10,
  http_server: true,
});

itest!(bundle {
  args: "bundle subdir/mod1.ts",
  output: "bundle/bundle.test.out",
});

itest!(bundle_jsx {
  args: "bundle run/jsx_import_from_ts.ts",
  output: "bundle/jsx.out",
});

itest!(error_bundle_with_bare_import {
  args: "bundle bundle/bare_imports/error_with_bare_import.ts",
  output: "bundle/bare_imports/error_with_bare_import.ts.out",
  exit_code: 1,
});

itest!(ts_decorators_bundle {
  args: "bundle bundle/decorators/ts_decorators.ts",
  output: "bundle/decorators/ts_decorators.out",
});

itest!(bundle_export_specifier_with_alias {
  args: "bundle bundle/file_tests-fixture16.ts",
  output: "bundle/fixture16.out",
});

itest!(bundle_ignore_directives {
  args: "bundle subdir/mod1.ts",
  output: "bundle/ignore_directives.test.out",
});

itest!(check_local_by_default_no_errors {
  args: "bundle --quiet bundle/check_local_by_default/no_errors.ts",
  output: "bundle/check_local_by_default/no_errors.out",
  http_server: true,
});

itest!(check_local_by_default_type_error {
  args: "bundle --quiet bundle/check_local_by_default/type_error.ts",
  output: "bundle/check_local_by_default/type_error.out",
  http_server: true,
  exit_code: 1,
});

itest!(bundle_shebang_file {
  args: "bundle subdir/shebang_file.js",
  output: "bundle/shebang_file.bundle.out",
});