cursus 0.6.2

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

use std::sync::Arc;

use crate::command::CommandRunner;
use crate::command::test_support::RecordingCommandRunner;
use crate::filesystem::LocalFilesystem;
use crate::model::config::NpmConfig;
use crate::package_manager::{
	NpmAdapter, PackageManagerAdapter, build_dependency_graph, enumerate_projects,
};
use crate::path::AbsolutePath;

#[tokio::test]
async fn build_dependency_graph_empty_for_single_package() {
	let dir = tempfile::tempdir().unwrap();
	std::fs::write(
		dir.path().join("package.json"),
		r#"{"name": "test-package", "version": "0.1.0"}"#,
	)
	.unwrap();

	let adapter: Arc<dyn PackageManagerAdapter> = Arc::new(NpmAdapter::new(
		NpmConfig::default(),
		AbsolutePath::new(dir.path()).unwrap(),
		{
			let r = Arc::new(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("/tmp").unwrap(),
				)),
			)
		},
	));
	let projects = enumerate_projects([adapter]).await.unwrap();
	let graph = build_dependency_graph(&projects).unwrap();

	// Single package with no dependencies should result in trivial sorting
	let sorted = graph.sort_leaves_first();
	assert_eq!(sorted, vec!["test-package"]);
}

#[tokio::test]
async fn build_dependency_graph_with_workspace_dependencies() {
	let dir = tempfile::tempdir().unwrap();

	// Create workspace with dependencies
	std::fs::write(
		dir.path().join("package.json"),
		r#"{"name": "root", "version": "0.1.0", "workspaces": ["packages/*"]}"#,
	)
	.unwrap();

	std::fs::create_dir_all(dir.path().join("packages/lib")).unwrap();
	std::fs::write(
		dir.path().join("packages/lib/package.json"),
		r#"{"name": "lib", "version": "0.1.0"}"#,
	)
	.unwrap();

	std::fs::create_dir_all(dir.path().join("packages/app")).unwrap();
	std::fs::write(
		dir.path().join("packages/app/package.json"),
		r#"{"name": "app", "version": "0.1.0", "dependencies": {"lib": "0.1.0"}}"#,
	)
	.unwrap();

	let adapter: Arc<dyn PackageManagerAdapter> = Arc::new(NpmAdapter::new(
		NpmConfig::default(),
		AbsolutePath::new(dir.path()).unwrap(),
		{
			let r = Arc::new(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("/tmp").unwrap(),
				)),
			)
		},
	));
	let projects = enumerate_projects([adapter]).await.unwrap();
	let graph = build_dependency_graph(&projects).unwrap();

	// app depends on lib, so lib should come before app
	let sorted = graph.sort_leaves_first();

	// lib should be published before app (lib is a dependency of app)
	let lib_index = sorted.iter().position(|n| n == "lib").unwrap();
	let app_index = sorted.iter().position(|n| n == "app").unwrap();
	assert!(lib_index < app_index, "lib should come before app");
}

#[tokio::test]
async fn build_dependency_graph_excludes_external_dependencies() {
	let dir = tempfile::tempdir().unwrap();

	// Create workspace where app depends on both workspace lib and external react
	std::fs::write(
		dir.path().join("package.json"),
		r#"{"name": "root", "version": "0.1.0", "workspaces": ["packages/*"]}"#,
	)
	.unwrap();

	std::fs::create_dir_all(dir.path().join("packages/lib")).unwrap();
	std::fs::write(
		dir.path().join("packages/lib/package.json"),
		r#"{"name": "lib", "version": "0.1.0"}"#,
	)
	.unwrap();

	std::fs::create_dir_all(dir.path().join("packages/app")).unwrap();
	std::fs::write(
		dir.path().join("packages/app/package.json"),
		r#"{"name": "app", "version": "0.1.0", "dependencies": {"lib": "0.1.0", "react": "^18.0.0"}}"#,
	)
	.unwrap();

	let adapter: Arc<dyn PackageManagerAdapter> = Arc::new(NpmAdapter::new(
		NpmConfig::default(),
		AbsolutePath::new(dir.path()).unwrap(),
		{
			let r = Arc::new(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("/tmp").unwrap(),
				)),
			)
		},
	));
	let projects = enumerate_projects([adapter]).await.unwrap();
	let graph = build_dependency_graph(&projects).unwrap();

	// Verify that app's adjacency list only includes lib, not react
	assert_eq!(
		graph.adjacency.get("app").unwrap(),
		&vec!["lib".to_string()]
	);

	// Verify react is not in the graph at all
	assert!(!graph.adjacency.contains_key("react"));

	// Verify topological sort still works correctly
	let sorted = graph.sort_leaves_first();

	// react should not appear in the sorted output
	assert!(!sorted.contains(&"react".to_string()));

	// lib should come before app
	let lib_index = sorted.iter().position(|n| n == "lib").unwrap();
	let app_index = sorted.iter().position(|n| n == "app").unwrap();
	assert!(lib_index < app_index, "lib should come before app");
}