build.rs

            let res = check_wasm_opt_version_compatibility(&path);

            // then
            assert!(res.is_err());
            assert!(
                format!("{:?}", res).starts_with(
                    "Err(Your wasm-opt version is 98, but we require a version >= 99."
                ),
                "Expected a different output, found {:?}",
                res
            );

            Ok(())
        })
    }

    #[cfg(unix)]
    #[test]
    fn compatible_wasm_opt_version_must_be_detected_if_built_from_repo() {
        with_tmp_dir(|path| {
            // given
            let path = mock_wasm_opt_version(path, "99 (version_99-79-gc12cc3f50");

            // when
            let res = check_wasm_opt_version_compatibility(&path);

            // then
            assert!(res.is_ok());

            Ok(())
        })
    }

    #[cfg(unix)]
    #[test]
    fn incompatible_wasm_opt_version_must_be_detected_if_installed_as_package() {
        with_tmp_dir(|path| {
            // given
            let path = mock_wasm_opt_version(path, "98");

            // when
            let res = check_wasm_opt_version_compatibility(&path);

            // then
            assert!(res.is_err());

            // this println is here to debug a spuriously failing CI at the following assert.
            eprintln!("error: {:?}", res);
            assert!(format!("{:?}", res)
                .starts_with("Err(Your wasm-opt version is 98, but we require a version >= 99."));

            Ok(())
        })
    }

    #[cfg(unix)]
    #[test]
    fn compatible_wasm_opt_version_must_be_detected_if_installed_as_package() {
        with_tmp_dir(|path| {
            // given
            let path = mock_wasm_opt_version(path, "99");

            // when
            let res = check_wasm_opt_version_compatibility(&path);

            // then
            assert!(res.is_ok());

            Ok(())
        })
    }

    #[test]
    fn contract_lib_name_different_from_package_name_must_build() {
        with_new_contract_project(|manifest_path| {
            // given
            let mut manifest =
                Manifest::new(manifest_path.clone()).expect("manifest creation failed");
            let _ = manifest
                .set_lib_name("some_lib_name")
                .expect("setting lib name failed");
            let _ = manifest
                .set_package_name("some_package_name")
                .expect("setting pacakge name failed");
            manifest
                .write(&manifest_path)
                .expect("writing manifest failed");

            // when
            let cmd = BuildCommand {
                manifest_path: Some(manifest_path.into()),
                build_artifact: BuildArtifacts::All,
                build_release: false,
                build_offline: false,
                verbosity: VerbosityFlags::default(),
                unstable_options: UnstableOptions::default(),
                optimization_passes: None,
                keep_debug_symbols: false,
                output_json: false,
            };
            let res = cmd.exec().expect("build failed");

            // then
            assert_eq!(
                res.dest_wasm
                    .expect("`dest_wasm` does not exist")
                    .file_name(),
                Some(OsStr::new("some_lib_name.wasm"))
            );

            Ok(())
        })
    }

    #[test]
    pub fn debug_mode_must_be_compatible() {
        let _ =
            assert_debug_mode_supported(&Version::parse("3.0.0-rc4").expect("parsing must work"))
                .expect("debug mode must be compatible");
        let _ =
            assert_debug_mode_supported(&Version::parse("4.0.0-rc1").expect("parsing must work"))
                .expect("debug mode must be compatible");
        let _ = assert_debug_mode_supported(&Version::parse("5.0.0").expect("parsing must work"))
            .expect("debug mode must be compatible");
    }

    #[test]
    pub fn debug_mode_must_be_incompatible() {
        let res =
            assert_debug_mode_supported(&Version::parse("3.0.0-rc3").expect("parsing must work"))
                .expect_err("assertion must fail");
        assert_eq!(
            res.to_string(),
            "Building the contract in debug mode requires an ink! version newer than `3.0.0-rc3`!"
        );
    }

    #[test]
    fn building_template_in_debug_mode_must_work() {
        with_new_contract_project(|manifest_path| {
            // given
            let args = crate::cmd::build::ExecuteArgs {
                manifest_path,
                build_mode: BuildMode::Debug,
                ..Default::default()
            };

            // when
            let res = super::execute(args);

            // then
            assert!(res.is_ok(), "building template in debug mode failed!");
            Ok(())
        })
    }

    #[test]
    fn building_template_in_release_mode_must_work() {
        with_new_contract_project(|manifest_path| {
            // given
            let args = crate::cmd::build::ExecuteArgs {
                manifest_path,
                build_mode: BuildMode::Release,
                ..Default::default()
            };

            // when
            let res = super::execute(args);

            // then
            assert!(res.is_ok(), "building template in release mode failed!");
            Ok(())
        })
    }

    #[test]
    fn building_contract_with_source_file_in_subfolder_must_work() {
        with_new_contract_project(|manifest_path| {
            // given
            let path = manifest_path.directory().expect("dir must exist");
            let old_lib_path = path.join(Path::new("lib.rs"));
            let new_lib_path = path.join(Path::new("srcfoo")).join(Path::new("lib.rs"));
            let new_dir_path = path.join(Path::new("srcfoo"));
            std::fs::create_dir_all(new_dir_path).expect("creating dir must work");
            std::fs::rename(old_lib_path, new_lib_path).expect("moving file must work");

            let mut manifest =
                Manifest::new(manifest_path.clone()).expect("creating manifest must work");
            manifest
                .set_lib_path("srcfoo/lib.rs")
                .expect("setting lib path must work");
            manifest.write(&manifest_path).expect("writing must work");

            let args = crate::cmd::build::ExecuteArgs {
                manifest_path,
                build_artifact: BuildArtifacts::CheckOnly,
                ..Default::default()
            };

            // when
            let res = super::execute(args);

            // then
            assert!(res.is_ok(), "building contract failed!");
            Ok(())
        })
    }

    #[test]
    fn keep_debug_symbols_in_debug_mode() {
        with_new_contract_project(|manifest_path| {
            let args = crate::cmd::build::ExecuteArgs {
                manifest_path,
                build_mode: BuildMode::Debug,
                build_artifact: BuildArtifacts::CodeOnly,
                keep_debug_symbols: true,
                ..Default::default()
            };

            let res = super::execute(args).expect("build failed");

            // we specified that debug symbols should be kept
            assert!(has_debug_symbols(&res.dest_wasm.unwrap()));

            Ok(())
        })
    }

    #[test]
    fn keep_debug_symbols_in_release_mode() {
        with_new_contract_project(|manifest_path| {
            let args = crate::cmd::build::ExecuteArgs {
                manifest_path,
                build_mode: BuildMode::Release,
                build_artifact: BuildArtifacts::CodeOnly,
                keep_debug_symbols: true,
                ..Default::default()
            };

            let res = super::execute(args).expect("build failed");

            // we specified that debug symbols should be kept
            assert!(has_debug_symbols(&res.dest_wasm.unwrap()));

            Ok(())
        })
    }

    #[test]
    fn build_with_json_output_works() {
        with_new_contract_project(|manifest_path| {
            // given
            let args = crate::cmd::build::ExecuteArgs {
                manifest_path,
                output_type: OutputType::Json,
                ..Default::default()
            };

            // when
            let res = super::execute(args).expect("build failed");

            // then
            assert!(res.serialize_json().is_ok());
            Ok(())
        })
    }
}