cursus 0.3.1

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

use super::*;

fn project_info(dir: &std::path::Path, name: &str, path: &str) -> ProjectInfo {
	ProjectInfo::for_test(name, AbsolutePath::new(dir.join(path)).unwrap())
}

#[tokio::test]
async fn write_version_file_not_found() {
	let dir = temp_dir();
	let adapter = recording_adapter_default(NpmConfig::default(), dir.path(), 0);
	let info = project_info(dir.path(), "my-app", "");
	let version: semver::Version = "1.0.0".parse().unwrap();
	let result = adapter.write_version(&info, &version, false).await;
	assert!(result.is_err());
}

#[tokio::test]
async fn write_version_invalid_json() {
	let dir = temp_dir();
	write_package_json(dir.path(), "not valid json");
	let adapter = recording_adapter_default(NpmConfig::default(), dir.path(), 0);
	let info = project_info(dir.path(), "my-app", "");
	let version: semver::Version = "1.0.0".parse().unwrap();
	let result = adapter.write_version(&info, &version, false).await;
	assert!(result.is_err());
}

#[tokio::test]
async fn write_version_updates_package_json() {
	let dir = temp_dir();
	write_package_json(dir.path(), r#"{"name": "my-app", "version": "1.0.0"}"#);
	let adapter = recording_adapter_default(NpmConfig::default(), dir.path(), 0);
	let info = project_info(dir.path(), "my-app", "");
	let new_version: semver::Version = "2.0.0".parse().unwrap();
	let paths = adapter
		.write_version(&info, &new_version, false)
		.await
		.unwrap();

	let contents = std::fs::read_to_string(dir.path().join("package.json")).unwrap();
	assert!(
		contents.contains("\"2.0.0\""),
		"Should contain new version, got: {contents}"
	);
	assert!(contents.ends_with('\n'), "Should end with newline");
	assert_eq!(paths.len(), 1);
	assert_eq!(paths[0], dir.path().join("package.json"));
}

#[tokio::test]
async fn write_version_dry_run_does_not_write_file() {
	let dir = temp_dir();
	write_package_json(dir.path(), r#"{"name": "my-app", "version": "1.0.0"}"#);
	let adapter = recording_adapter_default(NpmConfig::default(), dir.path(), 0);
	let info = project_info(dir.path(), "my-app", "");
	let new_version: semver::Version = "2.0.0".parse().unwrap();
	let paths = adapter
		.write_version(&info, &new_version, true)
		.await
		.unwrap();

	let contents = std::fs::read_to_string(dir.path().join("package.json")).unwrap();
	assert!(
		contents.contains("\"1.0.0\""),
		"dry-run should not modify the file, got: {contents}"
	);
	assert!(
		!contents.contains("\"2.0.0\""),
		"dry-run should not write new version, got: {contents}"
	);
	// Path is still reported even in dry-run mode
	assert_eq!(paths.len(), 1);
	assert_eq!(paths[0], dir.path().join("package.json"));
}

#[tokio::test]
async fn write_version_roundtrip() {
	let dir = temp_dir();
	write_package_json(dir.path(), r#"{"name": "my-app", "version": "0.1.0"}"#);
	let adapter = recording_adapter_default(NpmConfig::default(), dir.path(), 0);
	let info = project_info(dir.path(), "my-app", "");

	let new_v: semver::Version = "0.2.0".parse().unwrap();
	adapter.write_version(&info, &new_v, false).await.unwrap();

	// Re-enumerate to verify the write
	let projects = enumerate(dir.path()).await.unwrap();
	assert_eq!(projects.len(), 1);
	assert_eq!(projects[0].version.to_string(), "0.2.0");
}

#[tokio::test]
async fn write_version_only_updates_package_version_not_dependencies() {
	let dir = temp_dir();
	// "1.0.0" appears as both the package version and as a dependency version.
	let json = "{\n  \"name\": \"my-app\",\n  \"version\": \"1.0.0\",\n  \"dependencies\": {\n    \"some-lib\": \"1.0.0\"\n  }\n}\n";
	write_package_json(dir.path(), json);
	let adapter = recording_adapter_default(NpmConfig::default(), dir.path(), 0);
	let info = project_info(dir.path(), "my-app", "");
	let new_version: semver::Version = "2.0.0".parse().unwrap();
	adapter
		.write_version(&info, &new_version, false)
		.await
		.unwrap();

	let contents = std::fs::read_to_string(dir.path().join("package.json")).unwrap();
	assert!(
		contents.contains("\"version\": \"2.0.0\""),
		"Package version should be updated, got: {contents}"
	);
	assert!(
		contents.contains("\"some-lib\": \"1.0.0\""),
		"Dependency version should be unchanged, got: {contents}"
	);
}

#[tokio::test]
async fn write_version_preserves_tab_indent() {
	let dir = temp_dir();
	let tab_json = "{\n\t\"name\": \"my-app\",\n\t\"version\": \"1.0.0\"\n}\n";
	write_package_json(dir.path(), tab_json);
	let adapter = recording_adapter_default(NpmConfig::default(), dir.path(), 0);
	let info = project_info(dir.path(), "my-app", "");
	let new_version: semver::Version = "2.0.0".parse().unwrap();
	adapter
		.write_version(&info, &new_version, false)
		.await
		.unwrap();

	let contents = std::fs::read_to_string(dir.path().join("package.json")).unwrap();
	assert!(
		contents.contains("\"2.0.0\""),
		"Should contain new version, got: {contents}"
	);
	assert!(
		contents.contains("\t\"version\""),
		"Should preserve tab indentation, got: {contents}"
	);
	assert!(
		!contents.contains("  \"version\""),
		"Should not have space indentation, got: {contents}"
	);
}

#[tokio::test]
async fn write_version_preserves_four_space_indent() {
	let dir = temp_dir();
	let four_space_json = "{\n    \"name\": \"my-app\",\n    \"version\": \"1.0.0\"\n}\n";
	write_package_json(dir.path(), four_space_json);
	let adapter = recording_adapter_default(NpmConfig::default(), dir.path(), 0);
	let info = project_info(dir.path(), "my-app", "");
	let new_version: semver::Version = "2.0.0".parse().unwrap();
	adapter
		.write_version(&info, &new_version, false)
		.await
		.unwrap();

	let contents = std::fs::read_to_string(dir.path().join("package.json")).unwrap();
	assert!(
		contents.contains("\"2.0.0\""),
		"Should contain new version, got: {contents}"
	);
	assert!(
		contents.contains("    \"version\""),
		"Should preserve 4-space indentation, got: {contents}"
	);
}

#[tokio::test]
async fn write_version_preserves_key_order() {
	let dir = temp_dir();
	// Keys are in non-alphabetical order: name, version, description.
	// Alphabetical order would be: description, name, version.
	let json =
		"{\n  \"name\": \"my-app\",\n  \"version\": \"1.0.0\",\n  \"description\": \"A test\"\n}\n";
	write_package_json(dir.path(), json);
	let adapter = recording_adapter_default(NpmConfig::default(), dir.path(), 0);
	let info = project_info(dir.path(), "my-app", "");
	let new_version: semver::Version = "2.0.0".parse().unwrap();
	adapter
		.write_version(&info, &new_version, false)
		.await
		.unwrap();

	let contents = std::fs::read_to_string(dir.path().join("package.json")).unwrap();
	let name_pos = contents.find("\"name\"").unwrap();
	let version_pos = contents.find("\"version\"").unwrap();
	let desc_pos = contents.find("\"description\"").unwrap();
	assert!(
		name_pos < version_pos && version_pos < desc_pos,
		"Key order not preserved: {contents}"
	);
	assert!(contents.contains("\"2.0.0\""));
}