cursus 0.7.0

Library crate for the cursus release management CLI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311

use std::sync::Arc;

use crate::cli::prepare::release_files::*;
use crate::cli::prepare::{PrepareArgs, ReleaseInfo, cmd_prepare};
use crate::command::CommandRunner;
use crate::command::test_support::RecordingCommandRunner;
use crate::filesystem::LocalFilesystem;
use crate::model::config;

fn make_runner() -> Arc<dyn CommandRunner> {
	Arc::new(RecordingCommandRunner::new(0))
}

/// Loads all Cargo projects from a temporary workspace directory.
async fn load_projects_for_dir(dir: &tempfile::TempDir) -> Vec<crate::package_manager::Project> {
	let runner = make_runner();
	let path = crate::path::AbsolutePath::new(dir.path()).unwrap();
	let env = crate::Env::new(
		Arc::clone(&runner) as Arc<dyn CommandRunner>,
		Arc::new(LocalFilesystem),
		Arc::new(crate::git::GitWorkdir::new(runner, path)),
	);
	config::load(env.fs(), env.git().path())
		.await
		.unwrap()
		.unwrap()
		.load_projects(&env)
		.await
		.unwrap()
}

fn make_test_env(dir: &std::path::Path) -> crate::Env {
	let r = Arc::new(crate::command::test_support::RecordingCommandRunner::new(0))
		as Arc<dyn CommandRunner>;
	crate::Env::new(
		Arc::clone(&r),
		Arc::new(LocalFilesystem),
		Arc::new(crate::git::GitWorkdir::new(
			r,
			crate::path::AbsolutePath::new(dir).unwrap(),
		)),
	)
}

/// Sets up a temporary Cargo workspace with `pkg-a` (0.1.0) and `pkg-b` (0.2.0).
async fn setup_two_package_workspace() -> tempfile::TempDir {
	let dir = tempfile::tempdir().unwrap();
	std::fs::create_dir(dir.path().join(".git")).unwrap();
	let setup_env = make_test_env(dir.path());
	crate::model::config::Config::new()
		.with_cargo(crate::model::config::CargoConfig::enabled())
		.save(setup_env.fs(), setup_env.git().path())
		.await
		.unwrap();
	std::fs::write(
		dir.path().join("Cargo.toml"),
		"[workspace]\nmembers = [\"pkg-a\", \"pkg-b\"]\n",
	)
	.unwrap();
	std::fs::create_dir_all(dir.path().join("pkg-a/src")).unwrap();
	std::fs::write(
		dir.path().join("pkg-a/Cargo.toml"),
		"[package]\nname = \"pkg-a\"\nversion = \"0.1.0\"\nedition = \"2024\"\n",
	)
	.unwrap();
	std::fs::write(dir.path().join("pkg-a/src/lib.rs"), "").unwrap();
	std::fs::create_dir_all(dir.path().join("pkg-b/src")).unwrap();
	std::fs::write(
		dir.path().join("pkg-b/Cargo.toml"),
		"[package]\nname = \"pkg-b\"\nversion = \"0.2.0\"\nedition = \"2024\"\n",
	)
	.unwrap();
	std::fs::write(dir.path().join("pkg-b/src/lib.rs"), "").unwrap();
	dir
}

/// Sets up a temporary Cargo workspace where `pkg-b` (1.0.0) has an
/// intra-workspace dependency on `pkg-a` (1.0.0).
async fn setup_workspace_with_dependency() -> tempfile::TempDir {
	let dir = tempfile::tempdir().unwrap();
	std::fs::create_dir(dir.path().join(".git")).unwrap();
	let setup_env = make_test_env(dir.path());
	crate::model::config::Config::new()
		.with_cargo(crate::model::config::CargoConfig::enabled())
		.save(setup_env.fs(), setup_env.git().path())
		.await
		.unwrap();
	std::fs::write(
		dir.path().join("Cargo.toml"),
		"[workspace]\nmembers = [\"pkg-a\", \"pkg-b\"]\n",
	)
	.unwrap();
	std::fs::create_dir_all(dir.path().join("pkg-a/src")).unwrap();
	std::fs::write(
		dir.path().join("pkg-a/Cargo.toml"),
		"[package]\nname = \"pkg-a\"\nversion = \"1.0.0\"\nedition = \"2024\"\n",
	)
	.unwrap();
	std::fs::write(dir.path().join("pkg-a/src/lib.rs"), "").unwrap();
	std::fs::create_dir_all(dir.path().join("pkg-b/src")).unwrap();
	std::fs::write(
		dir.path().join("pkg-b/Cargo.toml"),
		"[package]\nname = \"pkg-b\"\nversion = \"1.0.0\"\nedition = \"2024\"\n\n[dependencies]\npkg-a = { path = \"../pkg-a\", version = \"1.0.0\" }\n",
	)
	.unwrap();
	std::fs::write(dir.path().join("pkg-b/src/lib.rs"), "").unwrap();
	dir
}

#[tokio::test]
async fn cmd_prepare_package_flag_filters_packages() {
	let dir = setup_two_package_workspace().await;

	let cursus_dir = dir.path().join(".cursus");
	std::fs::create_dir_all(&cursus_dir).unwrap();
	let changeset_path = cursus_dir.join("test.md");
	std::fs::write(
		&changeset_path,
		"+++\npkg-a = \"patch\"\npkg-b = \"minor\"\n+++\n\nSome change\n",
	)
	.unwrap();

	let runner = make_runner();
	let dir_abs = crate::path::AbsolutePath::new(dir.path()).unwrap();
	let env = crate::Env::new(
		Arc::clone(&runner) as Arc<dyn CommandRunner>,
		Arc::new(LocalFilesystem),
		Arc::new(crate::git::GitWorkdir::new(
			Arc::clone(&runner) as Arc<dyn CommandRunner>,
			dir_abs.clone(),
		)),
	);
	let config = config::load(env.fs(), env.git().path())
		.await
		.unwrap()
		.unwrap();
	let args = PrepareArgs {
		packages: vec!["pkg-a".to_string()],
		no_git: true,
		..PrepareArgs::default()
	};
	let result = cmd_prepare(&args, false, &env, config).await;
	assert!(result.is_ok());

	// Changeset should be rewritten with only pkg-b remaining
	assert!(
		changeset_path.exists(),
		"Changeset should still exist (partially consumed)"
	);
	let content = std::fs::read_to_string(&changeset_path).unwrap();
	assert!(
		content.contains("pkg-b = \"minor\""),
		"pkg-b should remain in changeset, got: {content}"
	);
	assert!(
		!content.contains("pkg-a"),
		"pkg-a should be removed from changeset, got: {content}"
	);
}

#[tokio::test]
async fn propagate_dependency_updates_returns_modified_manifest_paths() {
	// Guards `additional_files.extend(paths)` mutation: verifies that when a dependency
	// version is updated, the modified manifest path is included in the returned vec.
	let dir = setup_workspace_with_dependency().await;
	let projects = load_projects_for_dir(&dir).await;
	let release_infos = vec![ReleaseInfo {
		package_name: "pkg-a".to_string(),
		new_version: "1.0.1".parse().unwrap(),
		changelog_entry: String::new(),
	}];
	let modified_paths = propagate_dependency_updates(&projects, &release_infos, false)
		.await
		.unwrap();
	assert!(
		modified_paths
			.iter()
			.any(|p| p.to_string_lossy().contains("pkg-b")),
		"Expected pkg-b manifest in modified paths, got: {modified_paths:?}"
	);
}

#[tokio::test]
async fn cmd_prepare_package_flag_with_dry_run_leaves_changeset_untouched() {
	let dir = setup_two_package_workspace().await;

	let cursus_dir = dir.path().join(".cursus");
	std::fs::create_dir_all(&cursus_dir).unwrap();
	let changeset_path = cursus_dir.join("test.md");
	let original = "+++\npkg-a = \"patch\"\npkg-b = \"minor\"\n+++\n\nSome change\n";
	std::fs::write(&changeset_path, original).unwrap();

	let runner = make_runner();
	let dir_abs = crate::path::AbsolutePath::new(dir.path()).unwrap();
	let env = crate::Env::new(
		Arc::clone(&runner) as Arc<dyn CommandRunner>,
		Arc::new(LocalFilesystem),
		Arc::new(crate::git::GitWorkdir::new(
			Arc::clone(&runner) as Arc<dyn CommandRunner>,
			dir_abs.clone(),
		)),
	);
	let config = config::load(env.fs(), env.git().path())
		.await
		.unwrap()
		.unwrap();
	let args = PrepareArgs {
		packages: vec!["pkg-a".to_string()],
		no_git: true,
		..PrepareArgs::default()
	};
	let result = cmd_prepare(&args, true, &env, config).await;
	assert!(result.is_ok());

	// Dry-run must not touch the changeset even when scoped
	let content = std::fs::read_to_string(&changeset_path).unwrap();
	assert_eq!(
		content, original,
		"Changeset should be untouched in dry-run"
	);
}

/// Sets up a Cargo workspace where both members inherit `version.workspace = true`
/// with global linked-versions enabled (required by `validate_workspace_version_linking`).
async fn setup_workspace_version_workspace_true() -> tempfile::TempDir {
	let dir = tempfile::tempdir().unwrap();
	std::fs::create_dir(dir.path().join(".git")).unwrap();
	let setup_env = make_test_env(dir.path());
	crate::model::config::Config::new()
		.with_cargo(crate::model::config::CargoConfig::enabled())
		.with_linked_versions(crate::model::config::LinkedVersionsConfig {
			enabled: Some(true),
			groups: Vec::new(),
		})
		.save(setup_env.fs(), setup_env.git().path())
		.await
		.unwrap();
	// Workspace root Cargo.toml — defines [workspace.package].version
	std::fs::write(
		dir.path().join("Cargo.toml"),
		"[workspace]\nmembers = [\"pkg-a\", \"pkg-b\"]\n\n[workspace.package]\nversion = \"0.1.0\"\n",
	)
	.unwrap();
	for pkg in ["pkg-a", "pkg-b"] {
		std::fs::create_dir_all(dir.path().join(pkg).join("src")).unwrap();
		std::fs::write(
			dir.path().join(pkg).join("Cargo.toml"),
			format!("[package]\nname = \"{pkg}\"\nversion.workspace = true\nedition = \"2024\"\n"),
		)
		.unwrap();
		std::fs::write(dir.path().join(pkg).join("src").join("lib.rs"), "").unwrap();
	}
	dir
}

/// Regression test: when Cargo workspace members use `version.workspace = true`,
/// `bump_versions_and_generate_changelogs` must include the workspace root
/// `Cargo.toml` (not the member manifests) in its returned modified-files list.
///
/// Before the fix, the member path was pushed unconditionally and `write_version`
/// wrote silently to the workspace root without reporting it — causing the root
/// `Cargo.toml` to be omitted from the release commit.
#[tokio::test]
async fn bump_versions_includes_workspace_root_when_version_workspace_true() {
	let dir = setup_workspace_version_workspace_true().await;
	let projects = load_projects_for_dir(&dir).await;

	// Both packages bump by patch
	let aggregated: std::collections::BTreeMap<String, crate::model::changeset::ChangeType> = [
		(
			"pkg-a".to_string(),
			crate::model::changeset::ChangeType::Patch,
		),
		(
			"pkg-b".to_string(),
			crate::model::changeset::ChangeType::Patch,
		),
	]
	.into_iter()
	.collect();

	let (_, modified_files) = bump_versions_and_generate_changelogs(
		&aggregated,
		&std::collections::BTreeMap::new(),
		&projects,
		&std::collections::BTreeMap::new(),
		&std::collections::BTreeMap::new(),
		false,
		&crate::filesystem::LocalFilesystem,
	)
	.await
	.unwrap();

	let root_cargo = dir.path().join("Cargo.toml");
	assert!(
		modified_files.contains(&root_cargo),
		"Workspace root Cargo.toml must be in modified_files so it is staged for git.\n\
		 Got: {modified_files:?}"
	);

	// Member manifests must NOT appear — they only declare `version.workspace = true`
	// and were not written to.
	for pkg in ["pkg-a", "pkg-b"] {
		let member_cargo = dir.path().join(pkg).join("Cargo.toml");
		assert!(
			!modified_files.contains(&member_cargo),
			"Member Cargo.toml ({pkg}) must not be in modified_files — it was not modified.\n\
			 Got: {modified_files:?}"
		);
	}
}