From 5a32e0c6b5acf848f0ab5d32ac27fd6a298dfeb6 Mon Sep 17 00:00:00 2001 From: Dylan Anthony Date: Wed, 17 Aug 2022 11:59:26 -0600 Subject: [PATCH 1/2] feat: `prerelease_label` can be set at runtime with `--prerelease-label` or `KNOPE_PRERELEASE_LABEL`. Closes #241 --- .github/workflows/prerelease.yml | 3 +- Cargo.toml | 2 +- docs/src/config/step/PrepareRelease.md | 2 + docs/src/introduction.md | 10 + knope.toml | 31 --- src/config.rs | 7 + src/lib.rs | 9 +- src/step.rs | 7 + src/workflow.rs | 9 + tests/prepare_release.rs | 204 ++++++++++++++++++ .../enable_prerelease/CHANGELOG.md | 5 + .../enable_prerelease/Cargo.toml | 2 + .../enable_prerelease/EXPECTED_CHANGELOG.md | 11 + .../enable_prerelease/Expected_Cargo.toml | 2 + .../enable_prerelease/dry_run_output.txt | 8 + .../enable_prerelease/knope.toml | 9 + .../enable_prerelease/output.txt | 0 .../override_prerelease_label/CHANGELOG.md | 5 + .../override_prerelease_label/Cargo.toml | 2 + .../EXPECTED_CHANGELOG.md | 11 + .../Expected_Cargo.toml | 2 + .../dry_run_output.txt | 8 + .../override_prerelease_label/knope.toml | 10 + .../override_prerelease_label/output.txt | 0 24 files changed, 324 insertions(+), 35 deletions(-) create mode 100644 tests/prepare_release/enable_prerelease/CHANGELOG.md create mode 100644 tests/prepare_release/enable_prerelease/Cargo.toml create mode 100644 tests/prepare_release/enable_prerelease/EXPECTED_CHANGELOG.md create mode 100644 tests/prepare_release/enable_prerelease/Expected_Cargo.toml create mode 100644 tests/prepare_release/enable_prerelease/dry_run_output.txt create mode 100644 tests/prepare_release/enable_prerelease/knope.toml create mode 100644 tests/prepare_release/enable_prerelease/output.txt create mode 100644 tests/prepare_release/override_prerelease_label/CHANGELOG.md create mode 100644 tests/prepare_release/override_prerelease_label/Cargo.toml create mode 100644 tests/prepare_release/override_prerelease_label/EXPECTED_CHANGELOG.md create mode 100644 tests/prepare_release/override_prerelease_label/Expected_Cargo.toml create mode 100644 tests/prepare_release/override_prerelease_label/dry_run_output.txt create mode 100644 tests/prepare_release/override_prerelease_label/knope.toml create mode 100644 tests/prepare_release/override_prerelease_label/output.txt diff --git a/.github/workflows/prerelease.yml b/.github/workflows/prerelease.yml index c1a6daa9..ae419e8f 100644 --- a/.github/workflows/prerelease.yml +++ b/.github/workflows/prerelease.yml @@ -23,7 +23,6 @@ jobs: git_user_signingkey: true git_commit_gpgsign: true git_push_gpgsign: false - - run: | - cargo run -- prerelease + - run: cargo run -- release --prerelease-label=rc env: GITHUB_TOKEN: ${{ secrets.PAT }} \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index f798615b..8c722f4b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -28,7 +28,7 @@ platform-dirs = "0.3.0" git-conventional = "0.12.0" ureq = { version = "2.5.0", features = ["json"] } http = "0.2.8" -clap = { version = "3.2.17", features = ["cargo", "derive"] } +clap = { version = "3.2.17", features = ["cargo", "derive", "env"] } itertools = "0.10.3" miette = { version = "5.3.0", features = ["fancy"] } thiserror = "1.0.32" diff --git a/docs/src/config/step/PrepareRelease.md b/docs/src/config/step/PrepareRelease.md index 3c543fcc..f20103eb 100644 --- a/docs/src/config/step/PrepareRelease.md +++ b/docs/src/config/step/PrepareRelease.md @@ -31,6 +31,8 @@ type = "PrepareRelease" prerelease_label = "rc" ``` +If your prerelease workflow is exactly like your release workflow, you can instead temporarily add a prerelease label by passing the `--prerelease-label` option to `knope` or by setting the `KNOPE_PRERELEASE_LABEL` environment variable. This option overrides any set `prerelease_label` for any workflow run. + ### Going from Pre-release to Full Release Let's say that in addition to the configuration from the above example, you also have a section like this: diff --git a/docs/src/introduction.md b/docs/src/introduction.md index 67c9c6f2..dd7cc217 100644 --- a/docs/src/introduction.md +++ b/docs/src/introduction.md @@ -21,6 +21,14 @@ There are a few options you can pass to `knope` to control how it behaves. 3. `--generate` will generate a `knope.toml` file in the current directory. 4. `--validate` will check your `knope.toml` to make sure every workflow in it is valid, then exit. This could be useful to run in CI to make sure that your config is always valid. The exit code of this command will be 0 only if the config is valid. 5. `--dry-run` will pretend to run the selected workflow (either via arg or prompt), but will not actually perform any work (e.g., external commands, file I/O, API calls). Detects the same errors as `--validate` but also outputs info about what _would_ happen to stdout. +6. `--prerelease-label` will override the `prerelease_label` for any [`PrepareRelease`] step run. + +### Environment Variables + +These are all the environment variables that Knope will look for when running workflows. + +1. `KNOPE_PRERELEASE_LABEL` works just like the `--prerelease-label` option. Note that the option takes precedence over the environment variable. +2. `GITHUB_TOKEN` will be used to load credentials from GitHub for [GitHub config]. ## Features @@ -39,3 +47,5 @@ You define a [config] file named `knope.toml` which has some metadata (e.g. Jira [config]: config/config.md [workflow]: config/workflow.md [step]: config/step/step.md +[`preparerelease`]: config/step/PrepareRelease.md +[github config]: config/github.md diff --git a/knope.toml b/knope.toml index fb66ed39..d78b6b09 100644 --- a/knope.toml +++ b/knope.toml @@ -48,37 +48,6 @@ command = "git push" [[workflows.steps]] type = "Release" -[[workflows]] -name = "prerelease" - -[[workflows.steps]] -type = "PrepareRelease" -prerelease_label = "rc" - -[[workflow.steps]] -type = "Command" -command = "cargo update -w" - -[[workflows.steps]] -type = "Command" -command = "npx -y prettier **/*.md --write" - -[[workflows.steps]] -type = "Command" -command = "git add Cargo.toml Cargo.lock CHANGELOG.md" - -[[workflows.steps]] -type = "Command" -command = "git commit -m \"chore: Bump to version\"" -variables = { "version" = "Version" } - -[[workflows.steps]] -type = "Command" -command = "git push" - -[[workflows.steps]] -type = "Release" - [github] owner = "knope-dev" repo = "knope" diff --git a/src/config.rs b/src/config.rs index 290e0407..7de755f8 100644 --- a/src/config.rs +++ b/src/config.rs @@ -43,6 +43,13 @@ impl Config { .into_diagnostic() .wrap_err("Invalid TOML when parsing config") } + + /// Set the prerelease label for all `PrepareRelease` steps in all workflows in `self`. + pub(crate) fn set_prerelease_label(&mut self, label: &str) { + for workflow in &mut self.workflows { + workflow.set_prerelease_label(label); + } + } } /// Generate a brand new config file for the project in the current directory. diff --git a/src/lib.rs b/src/lib.rs index c74c0027..b23afd79 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -41,7 +41,10 @@ pub fn run(cli: Cli) -> Result<()> { let preselected_workflow = cli.workflow; - let config = Config::load()?; + let mut config = Config::load()?; + if let Some(prerelease_label) = cli.prerelease_label { + config.set_prerelease_label(&prerelease_label); + } let state = State::new(config.jira, config.github, config.packages); if cli.validate { @@ -99,6 +102,10 @@ pub struct Cli { #[clap(long)] /// Generate a new `knope.toml` file. generate: bool, + + #[clap(long, env = "KNOPE_PRERELEASE_LABEL")] + /// Set the `prerelease_label` attribute of any `PrepareRelease` steps at runtime. + prerelease_label: Option, } #[cfg(test)] diff --git a/src/step.rs b/src/step.rs index db16d696..3948feb4 100644 --- a/src/step.rs +++ b/src/step.rs @@ -96,6 +96,13 @@ impl Step { Step::Release => releases::release(run_type), } } + + /// Set `prerelease_label` if `self` is `PrepareRelease`. + pub(crate) fn set_prerelease_label(&mut self, prerelease_label: &str) { + if let Step::PrepareRelease(prepare_release) = self { + prepare_release.prerelease_label = Some(String::from(prerelease_label)); + } + } } #[derive(Debug, Error, Diagnostic)] diff --git a/src/workflow.rs b/src/workflow.rs index 1b25389e..2a6b4a15 100644 --- a/src/workflow.rs +++ b/src/workflow.rs @@ -19,6 +19,15 @@ pub(crate) struct Workflow { pub(crate) steps: Vec, } +impl Workflow { + /// Set `prerelease_label` for any steps that are `PrepareRelease` steps. + pub(crate) fn set_prerelease_label(&mut self, prerelease_label: &str) { + for step in &mut self.steps { + step.set_prerelease_label(prerelease_label); + } + } +} + /// A collection of errors from running with the `--validate` option. #[derive(Debug, Error, Diagnostic)] #[error("There are problems with the defined workflows")] diff --git a/tests/prepare_release.rs b/tests/prepare_release.rs index 1abf01b3..a5ee37bd 100644 --- a/tests/prepare_release.rs +++ b/tests/prepare_release.rs @@ -57,6 +57,210 @@ fn prerelease_after_release() { ); } +/// Run a `PrepareRelease` as a pre-release in a repo which already contains a release, but change +/// the configured `prerelease_label` at runtime using the `--prerelease-label` argument. +#[test] +fn override_prerelease_label_with_option() { + // Arrange. + let temp_dir = tempfile::tempdir().unwrap(); + let temp_path = temp_dir.path(); + let source_path = Path::new("tests/prepare_release/override_prerelease_label"); + + init(temp_path); + commit(temp_path, "Initial commit"); + tag(temp_path, "v1.0.0"); + commit(temp_path, "feat: New feature in existing release"); + tag(temp_path, "v1.1.0"); + commit(temp_path, "feat!: Breaking feature in new RC"); + + for file in ["knope.toml", "CHANGELOG.md", "Cargo.toml"] { + copy(source_path.join(file), temp_path.join(file)).unwrap(); + } + + // Act. + let assert = Command::new(cargo_bin!("knope")) + .arg("prerelease") + .arg("--prerelease-label=alpha") + .current_dir(temp_dir.path()) + .assert(); + let dry_run_assert = Command::new(cargo_bin!("knope")) + .arg("prerelease") + .arg("--prerelease-label=alpha") + .arg("--dry-run") + .current_dir(temp_dir.path()) + .assert(); + + // Assert. + assert + .success() + .stdout_eq_path(source_path.join("output.txt")); + dry_run_assert + .success() + .stdout_eq_path(source_path.join("dry_run_output.txt")); + + assert_eq_path( + source_path.join("EXPECTED_CHANGELOG.md"), + read_to_string(temp_path.join("CHANGELOG.md")).unwrap(), + ); + assert_eq_path( + source_path.join("Expected_Cargo.toml"), + read_to_string(temp_path.join("Cargo.toml")).unwrap(), + ); +} + +/// Run a `PrepareRelease` as a pre-release in a repo which already contains a release, but change +/// the configured `prerelease_label` at runtime using the `KNOPE_PRERELEASE_LABEL` environment variable. +#[test] +fn override_prerelease_label_with_env() { + // Arrange. + let temp_dir = tempfile::tempdir().unwrap(); + let temp_path = temp_dir.path(); + let source_path = Path::new("tests/prepare_release/override_prerelease_label"); + + init(temp_path); + commit(temp_path, "Initial commit"); + tag(temp_path, "v1.0.0"); + commit(temp_path, "feat: New feature in existing release"); + tag(temp_path, "v1.1.0"); + commit(temp_path, "feat!: Breaking feature in new RC"); + + for file in ["knope.toml", "CHANGELOG.md", "Cargo.toml"] { + copy(source_path.join(file), temp_path.join(file)).unwrap(); + } + + // Act. + let assert = Command::new(cargo_bin!("knope")) + .arg("prerelease") + .env("KNOPE_PRERELEASE_LABEL", "alpha") + .current_dir(temp_dir.path()) + .assert(); + let dry_run_assert = Command::new(cargo_bin!("knope")) + .arg("prerelease") + .env("KNOPE_PRERELEASE_LABEL", "alpha") + .arg("--dry-run") + .current_dir(temp_dir.path()) + .assert(); + + // Assert. + assert + .success() + .stdout_eq_path(source_path.join("output.txt")); + dry_run_assert + .success() + .stdout_eq_path(source_path.join("dry_run_output.txt")); + + assert_eq_path( + source_path.join("EXPECTED_CHANGELOG.md"), + read_to_string(temp_path.join("CHANGELOG.md")).unwrap(), + ); + assert_eq_path( + source_path.join("Expected_Cargo.toml"), + read_to_string(temp_path.join("Cargo.toml")).unwrap(), + ); +} + +/// Run a `PrepareRelease` as a pre-release in a repo which already contains a release, but set +/// the configured `prerelease_label` at runtime using the `--prerelease-label` argument. +#[test] +fn enable_prerelease_label_with_option() { + // Arrange. + let temp_dir = tempfile::tempdir().unwrap(); + let temp_path = temp_dir.path(); + let source_path = Path::new("tests/prepare_release/enable_prerelease"); + + init(temp_path); + commit(temp_path, "Initial commit"); + tag(temp_path, "v1.0.0"); + commit(temp_path, "feat: New feature in existing release"); + tag(temp_path, "v1.1.0"); + commit(temp_path, "feat!: Breaking feature in new RC"); + + for file in ["knope.toml", "CHANGELOG.md", "Cargo.toml"] { + copy(source_path.join(file), temp_path.join(file)).unwrap(); + } + + // Act. + let assert = Command::new(cargo_bin!("knope")) + .arg("prerelease") + .arg("--prerelease-label=rc") + .current_dir(temp_dir.path()) + .assert(); + let dry_run_assert = Command::new(cargo_bin!("knope")) + .arg("prerelease") + .arg("--prerelease-label=rc") + .arg("--dry-run") + .current_dir(temp_dir.path()) + .assert(); + + // Assert. + assert + .success() + .stdout_eq_path(source_path.join("output.txt")); + dry_run_assert + .success() + .stdout_eq_path(source_path.join("dry_run_output.txt")); + + assert_eq_path( + source_path.join("EXPECTED_CHANGELOG.md"), + read_to_string(temp_path.join("CHANGELOG.md")).unwrap(), + ); + assert_eq_path( + source_path.join("Expected_Cargo.toml"), + read_to_string(temp_path.join("Cargo.toml")).unwrap(), + ); +} + +/// Run a `PrepareRelease` as a pre-release in a repo which already contains a release, but set +/// the configured `prerelease_label` at runtime using the `KNOPE_PRERELEASE_LABEL` environment variable. +#[test] +fn enable_prerelease_label_with_env() { + // Arrange. + let temp_dir = tempfile::tempdir().unwrap(); + let temp_path = temp_dir.path(); + let source_path = Path::new("tests/prepare_release/enable_prerelease"); + + init(temp_path); + commit(temp_path, "Initial commit"); + tag(temp_path, "v1.0.0"); + commit(temp_path, "feat: New feature in existing release"); + tag(temp_path, "v1.1.0"); + commit(temp_path, "feat!: Breaking feature in new RC"); + + for file in ["knope.toml", "CHANGELOG.md", "Cargo.toml"] { + copy(source_path.join(file), temp_path.join(file)).unwrap(); + } + + // Act. + let assert = Command::new(cargo_bin!("knope")) + .arg("prerelease") + .env("KNOPE_PRERELEASE_LABEL", "rc") + .current_dir(temp_dir.path()) + .assert(); + let dry_run_assert = Command::new(cargo_bin!("knope")) + .arg("prerelease") + .env("KNOPE_PRERELEASE_LABEL", "rc") + .arg("--dry-run") + .current_dir(temp_dir.path()) + .assert(); + + // Assert. + assert + .success() + .stdout_eq_path(source_path.join("output.txt")); + dry_run_assert + .success() + .stdout_eq_path(source_path.join("dry_run_output.txt")); + + assert_eq_path( + source_path.join("EXPECTED_CHANGELOG.md"), + read_to_string(temp_path.join("CHANGELOG.md")).unwrap(), + ); + assert_eq_path( + source_path.join("Expected_Cargo.toml"), + read_to_string(temp_path.join("Cargo.toml")).unwrap(), + ); +} + /// Run a `PrepareRelease` as a pre-release in a repo which already contains a pre-release. #[test] fn second_prerelease() { diff --git a/tests/prepare_release/enable_prerelease/CHANGELOG.md b/tests/prepare_release/enable_prerelease/CHANGELOG.md new file mode 100644 index 00000000..38ff50c5 --- /dev/null +++ b/tests/prepare_release/enable_prerelease/CHANGELOG.md @@ -0,0 +1,5 @@ +## 1.1.0 + +### Features + +- New feature in existing release diff --git a/tests/prepare_release/enable_prerelease/Cargo.toml b/tests/prepare_release/enable_prerelease/Cargo.toml new file mode 100644 index 00000000..051d5daa --- /dev/null +++ b/tests/prepare_release/enable_prerelease/Cargo.toml @@ -0,0 +1,2 @@ +[package] +version = "1.1.0" diff --git a/tests/prepare_release/enable_prerelease/EXPECTED_CHANGELOG.md b/tests/prepare_release/enable_prerelease/EXPECTED_CHANGELOG.md new file mode 100644 index 00000000..63e04a42 --- /dev/null +++ b/tests/prepare_release/enable_prerelease/EXPECTED_CHANGELOG.md @@ -0,0 +1,11 @@ +## 2.0.0-rc.0 + +### Breaking Changes + +- Breaking feature in new RC + +## 1.1.0 + +### Features + +- New feature in existing release diff --git a/tests/prepare_release/enable_prerelease/Expected_Cargo.toml b/tests/prepare_release/enable_prerelease/Expected_Cargo.toml new file mode 100644 index 00000000..48e7c18a --- /dev/null +++ b/tests/prepare_release/enable_prerelease/Expected_Cargo.toml @@ -0,0 +1,2 @@ +[package] +version = "2.0.0-rc.0" diff --git a/tests/prepare_release/enable_prerelease/dry_run_output.txt b/tests/prepare_release/enable_prerelease/dry_run_output.txt new file mode 100644 index 00000000..2e297684 --- /dev/null +++ b/tests/prepare_release/enable_prerelease/dry_run_output.txt @@ -0,0 +1,8 @@ +Would bump version to 2.0.0-rc.1 +Would add the following to CHANGELOG.md: +## 2.0.0-rc.1 + +### Breaking Changes + +- Breaking feature in new RC + diff --git a/tests/prepare_release/enable_prerelease/knope.toml b/tests/prepare_release/enable_prerelease/knope.toml new file mode 100644 index 00000000..bb321d7b --- /dev/null +++ b/tests/prepare_release/enable_prerelease/knope.toml @@ -0,0 +1,9 @@ +[[packages]] +versioned_files = ["Cargo.toml"] +changelog = "CHANGELOG.md" + +[[workflows]] +name = "prerelease" + +[[workflows.steps]] +type = "PrepareRelease" diff --git a/tests/prepare_release/enable_prerelease/output.txt b/tests/prepare_release/enable_prerelease/output.txt new file mode 100644 index 00000000..e69de29b diff --git a/tests/prepare_release/override_prerelease_label/CHANGELOG.md b/tests/prepare_release/override_prerelease_label/CHANGELOG.md new file mode 100644 index 00000000..38ff50c5 --- /dev/null +++ b/tests/prepare_release/override_prerelease_label/CHANGELOG.md @@ -0,0 +1,5 @@ +## 1.1.0 + +### Features + +- New feature in existing release diff --git a/tests/prepare_release/override_prerelease_label/Cargo.toml b/tests/prepare_release/override_prerelease_label/Cargo.toml new file mode 100644 index 00000000..051d5daa --- /dev/null +++ b/tests/prepare_release/override_prerelease_label/Cargo.toml @@ -0,0 +1,2 @@ +[package] +version = "1.1.0" diff --git a/tests/prepare_release/override_prerelease_label/EXPECTED_CHANGELOG.md b/tests/prepare_release/override_prerelease_label/EXPECTED_CHANGELOG.md new file mode 100644 index 00000000..8496ea45 --- /dev/null +++ b/tests/prepare_release/override_prerelease_label/EXPECTED_CHANGELOG.md @@ -0,0 +1,11 @@ +## 2.0.0-alpha.0 + +### Breaking Changes + +- Breaking feature in new RC + +## 1.1.0 + +### Features + +- New feature in existing release diff --git a/tests/prepare_release/override_prerelease_label/Expected_Cargo.toml b/tests/prepare_release/override_prerelease_label/Expected_Cargo.toml new file mode 100644 index 00000000..faf071c3 --- /dev/null +++ b/tests/prepare_release/override_prerelease_label/Expected_Cargo.toml @@ -0,0 +1,2 @@ +[package] +version = "2.0.0-alpha.0" diff --git a/tests/prepare_release/override_prerelease_label/dry_run_output.txt b/tests/prepare_release/override_prerelease_label/dry_run_output.txt new file mode 100644 index 00000000..6db76c28 --- /dev/null +++ b/tests/prepare_release/override_prerelease_label/dry_run_output.txt @@ -0,0 +1,8 @@ +Would bump version to 2.0.0-alpha.1 +Would add the following to CHANGELOG.md: +## 2.0.0-alpha.1 + +### Breaking Changes + +- Breaking feature in new RC + diff --git a/tests/prepare_release/override_prerelease_label/knope.toml b/tests/prepare_release/override_prerelease_label/knope.toml new file mode 100644 index 00000000..e3416e26 --- /dev/null +++ b/tests/prepare_release/override_prerelease_label/knope.toml @@ -0,0 +1,10 @@ +[[packages]] +versioned_files = ["Cargo.toml"] +changelog = "CHANGELOG.md" + +[[workflows]] +name = "prerelease" + +[[workflows.steps]] +type = "PrepareRelease" +prerelease_label = "rc" diff --git a/tests/prepare_release/override_prerelease_label/output.txt b/tests/prepare_release/override_prerelease_label/output.txt new file mode 100644 index 00000000..e69de29b From f4a7d243b16b56c9e97632817aedd1573f3244cd Mon Sep 17 00:00:00 2001 From: Dylan Anthony Date: Wed, 17 Aug 2022 12:03:26 -0600 Subject: [PATCH 2/2] test: Test arg vs env var precedence for `prerelease_label` --- tests/prepare_release.rs | 60 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-) diff --git a/tests/prepare_release.rs b/tests/prepare_release.rs index a5ee37bd..e0b6abbf 100644 --- a/tests/prepare_release.rs +++ b/tests/prepare_release.rs @@ -160,7 +160,7 @@ fn override_prerelease_label_with_env() { } /// Run a `PrepareRelease` as a pre-release in a repo which already contains a release, but set -/// the configured `prerelease_label` at runtime using the `--prerelease-label` argument. +/// the `prerelease_label` at runtime using the `--prerelease-label` argument. #[test] fn enable_prerelease_label_with_option() { // Arrange. @@ -211,7 +211,7 @@ fn enable_prerelease_label_with_option() { } /// Run a `PrepareRelease` as a pre-release in a repo which already contains a release, but set -/// the configured `prerelease_label` at runtime using the `KNOPE_PRERELEASE_LABEL` environment variable. +/// the `prerelease_label` at runtime using the `KNOPE_PRERELEASE_LABEL` environment variable. #[test] fn enable_prerelease_label_with_env() { // Arrange. @@ -261,6 +261,62 @@ fn enable_prerelease_label_with_env() { ); } +/// Run a `PrepareRelease` as a pre-release in a repo which already contains a release, but set +/// the `prerelease_label` at runtime using both the `--prerelease-label` argument and the +/// `KNOPE_PRERELEASE_LABEL` environment variable. +/// +/// The `--prerelease-label` argument should take precedence over the environment variable. +#[test] +fn prerelease_label_option_overrides_env() { + // Arrange. + let temp_dir = tempfile::tempdir().unwrap(); + let temp_path = temp_dir.path(); + let source_path = Path::new("tests/prepare_release/enable_prerelease"); + + init(temp_path); + commit(temp_path, "Initial commit"); + tag(temp_path, "v1.0.0"); + commit(temp_path, "feat: New feature in existing release"); + tag(temp_path, "v1.1.0"); + commit(temp_path, "feat!: Breaking feature in new RC"); + + for file in ["knope.toml", "CHANGELOG.md", "Cargo.toml"] { + copy(source_path.join(file), temp_path.join(file)).unwrap(); + } + + // Act. + let assert = Command::new(cargo_bin!("knope")) + .arg("prerelease") + .env("KNOPE_PRERELEASE_LABEL", "alpha") + .arg("--prerelease-label=rc") + .current_dir(temp_dir.path()) + .assert(); + let dry_run_assert = Command::new(cargo_bin!("knope")) + .arg("prerelease") + .env("KNOPE_PRERELEASE_LABEL", "alpha") + .arg("--prerelease-label=rc") + .arg("--dry-run") + .current_dir(temp_dir.path()) + .assert(); + + // Assert. + assert + .success() + .stdout_eq_path(source_path.join("output.txt")); + dry_run_assert + .success() + .stdout_eq_path(source_path.join("dry_run_output.txt")); + + assert_eq_path( + source_path.join("EXPECTED_CHANGELOG.md"), + read_to_string(temp_path.join("CHANGELOG.md")).unwrap(), + ); + assert_eq_path( + source_path.join("Expected_Cargo.toml"), + read_to_string(temp_path.join("Cargo.toml")).unwrap(), + ); +} + /// Run a `PrepareRelease` as a pre-release in a repo which already contains a pre-release. #[test] fn second_prerelease() {