use std::collections::BTreeMap;
use serde_json::json;
use super::{
EffectiveConfigCollector, discover_internal,
layers::{MemberConfigLayers, member_effective_config, without_project_or_workspace},
};
use crate::{
DiscoveryPurpose, DiscoveryRequest, FileEntry, FileTree, ProjectOrigin, ProjectSource,
RelativePath, SourceSelection, WORKSPACE_CONFIG_INVALID, WORKSPACE_LANGUAGE_ID_EMPTY,
WORKSPACE_PROJECT_NAME_EMPTY, WORKSPACE_SELECTION_DUPLICATE, WORKSPACE_SELECTION_EMPTY,
WORKSPACE_SELECTION_INVALID, WORKSPACE_SELECTION_NAME_REQUIRED,
WORKSPACE_SELECTION_OUTSIDE_ROOT, WORKSPACE_SYMLINK_UNSUPPORTED, discover,
discover_with_details,
};
#[derive(Default)]
struct CountingCollector {
roots: usize,
projects: Vec<RelativePath>,
}
impl EffectiveConfigCollector for CountingCollector {
fn root(&mut self, _effective: &serde_json::Value) {
self.roots += 1;
}
fn project(&mut self, path: &RelativePath, _effective: &serde_json::Value) {
self.projects.push(path.clone());
}
}
fn collection_request() -> DiscoveryRequest {
DiscoveryRequest {
protocol_version: crate::workspace_discovery_protocol(),
development_root: FileTree {
entries: BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(
RelativePath::parse("morphir.toml").unwrap(),
FileEntry::File {
text:
"[workspace]\nmembers = ['packages/*']\n[project]\nname = 'acme/root'\n"
.to_owned(),
},
),
(
RelativePath::parse("packages/orders").unwrap(),
FileEntry::Directory,
),
(
RelativePath::parse("packages/orders/morphir.toml").unwrap(),
FileEntry::File {
text: "[project]\nname = 'acme/orders'\n".to_owned(),
},
),
]),
},
morphir_home: None,
system_config: None,
environment: BTreeMap::new(),
cli_overlay: json!({}),
purpose: Default::default(),
}
}
#[test]
fn effective_configs_are_collected_only_when_a_sink_is_supplied() {
let request = collection_request();
let ordinary = discover_internal(request.clone(), None).unwrap();
let mut collector = CountingCollector::default();
let detailed = discover_internal(request, Some(&mut collector)).unwrap();
assert_eq!(ordinary, detailed);
assert_eq!(collector.roots, 1);
assert_eq!(
collector.projects,
[
RelativePath::root(),
RelativePath::parse("packages/orders").unwrap(),
]
);
}
#[test]
fn portable_discovery_rejects_unmaterialized_symlinks_in_every_mount() {
enum Mount {
DevelopmentRoot,
MorphirHome,
SystemConfig,
}
for (mount, context) in [
(Mount::DevelopmentRoot, "development root"),
(Mount::MorphirHome, "Morphir Home"),
(Mount::SystemConfig, "system configuration"),
] {
let first = RelativePath::parse("a-link").unwrap();
let first_target = RelativePath::parse("targets/first").unwrap();
let links = FileTree {
entries: BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(
RelativePath::parse("z-link").unwrap(),
FileEntry::Symlink {
target: RelativePath::parse("targets/last").unwrap(),
},
),
(
first.clone(),
FileEntry::Symlink {
target: first_target.clone(),
},
),
]),
};
let mut request = collection_request();
match mount {
Mount::DevelopmentRoot => request.development_root = links,
Mount::MorphirHome => request.morphir_home = Some(links),
Mount::SystemConfig => request.system_config = Some(links),
}
let failure = discover_internal(request, None).unwrap_err();
assert_eq!(failure.code, WORKSPACE_SYMLINK_UNSUPPORTED);
assert_eq!(failure.path, Some(first.clone()));
assert!(failure.message.contains(context));
assert!(failure.message.contains(first.as_str()));
assert!(failure.message.contains(first_target.as_str()));
assert!(!failure.message.contains("z-link"));
}
}
#[test]
fn member_merge_inherits_only_shared_root_user_sections() {
let empty = json!({});
let root_user = json!({
"workspace": { "name": "root-user-workspace" },
"project": {
"name": "root/user",
"version": "2.0.0",
"source_directory": "root-user-src"
},
"ir": { "strict_mode": true, "mode": "root-user" }
});
let shared_root_user = without_project_or_workspace(&root_user);
let member_primary = json!({
"project": {
"name": "member/primary",
"version": "1.0.0",
"source_directory": "member-src"
},
"ir": { "format_version": 3, "mode": "member-primary" }
});
let member_user = json!({
"project": { "version": "3.0.0" },
"ir": { "mode": "member-user" }
});
let effective = member_effective_config(MemberConfigLayers {
system: &empty,
global: &empty,
shared_workspace: &empty,
member_primary: &member_primary,
shared_workspace_user: &shared_root_user,
member_user: Some(&member_user),
environment: &empty,
cli_overlay: &empty,
});
assert_eq!(effective["project"]["name"], "member/primary");
assert_eq!(effective["project"]["version"], "3.0.0");
assert_eq!(effective["project"]["source_directory"], "member-src");
assert!(effective.get("workspace").is_none());
assert_eq!(effective["ir"]["strict_mode"], true);
assert_eq!(effective["ir"]["format_version"], 3);
assert_eq!(effective["ir"]["mode"], "member-user");
}
fn gleam_source(path: &str) -> (RelativePath, FileEntry) {
(
RelativePath::parse(path).unwrap(),
FileEntry::File {
text: "pub type Customer {\n Customer(id: String)\n}\n".to_owned(),
},
)
}
fn ad_hoc_request_with_entries(
entries: BTreeMap<RelativePath, FileEntry>,
project: ProjectSource,
sources: SourceSelection,
) -> DiscoveryRequest {
DiscoveryRequest {
protocol_version: crate::workspace_discovery_protocol(),
development_root: FileTree { entries },
morphir_home: None,
system_config: None,
environment: BTreeMap::new(),
cli_overlay: json!({}),
purpose: DiscoveryPurpose::AdHocSources {
project,
sources,
language_id: "gleam".to_owned(),
},
}
}
fn ad_hoc_request(paths: Vec<RelativePath>, root: RelativePath) -> DiscoveryRequest {
let (source, entry) = gleam_source("models/domain/customer.gleam");
ad_hoc_request_with_entries(
BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(source, entry),
]),
ProjectSource::Synthesized,
SourceSelection { root, paths },
)
}
#[test]
fn ad_hoc_sources_without_a_manifest_yield_a_synthesized_project() {
let domain = gleam_source("models/domain/customer.gleam");
let party = gleam_source("models/party/customer.gleam");
let paths = vec![domain.0.clone(), party.0.clone()];
let root = RelativePath::parse("models").unwrap();
let entries = BTreeMap::from([(RelativePath::root(), FileEntry::Directory), domain, party]);
let mut request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: root.clone(),
paths: paths.clone(),
},
);
request.cli_overlay = json!({ "project": { "name": "acme/models" } });
let snapshot = discover(request)
.into_result()
.expect("an ad-hoc selection with no manifest should synthesize a project");
assert_eq!(snapshot.projects.len(), 1);
let project = &snapshot.projects[0];
assert_eq!(project.origin, ProjectOrigin::Synthesized { inputs: paths });
assert_eq!(project.relative_path, root);
assert_eq!(project.source_directory, RelativePath::root());
assert_eq!(project.name, "acme/models");
assert_eq!(project.exposed_modules, None);
assert_eq!(project.config_anchor, None);
assert_eq!(project.version, None);
assert_eq!(project.state, crate::ProjectState::Unloaded);
assert_eq!(snapshot.config_anchor, None);
}
#[test]
fn an_explicit_package_name_reaches_the_synthesized_snapshot() {
let (path, entry) = gleam_source("models/domain/customer.gleam");
let root = RelativePath::parse("models").unwrap();
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(path.clone(), entry),
]);
let mut request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: root.clone(),
paths: vec![path],
},
);
request.cli_overlay = json!({ "project": { "name": "acme/orders" } });
let snapshot = discover(request)
.into_result()
.expect("an explicit overlay name should synthesize successfully");
assert_eq!(snapshot.projects.len(), 1);
assert_eq!(snapshot.projects[0].name, "acme/orders");
}
#[test]
fn an_explicit_package_name_is_stored_trimmed() {
let (path, entry) = gleam_source("models/domain/customer.gleam");
let root = RelativePath::parse("models").unwrap();
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(path.clone(), entry),
]);
let mut request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: root.clone(),
paths: vec![path],
},
);
request.cli_overlay = json!({ "project": { "name": " acme/widgets " } });
let snapshot = discover(request)
.into_result()
.expect("an explicit overlay name should synthesize successfully");
assert_eq!(snapshot.projects.len(), 1);
assert_eq!(snapshot.projects[0].name, "acme/widgets");
}
#[test]
fn an_unnamed_multi_source_selection_is_left_for_the_provider_to_judge() {
let domain = gleam_source("models/domain/customer.gleam");
let party = gleam_source("models/party/customer.gleam");
let paths = vec![domain.0.clone(), party.0.clone()];
let root = RelativePath::parse("models").unwrap();
let entries = BTreeMap::from([(RelativePath::root(), FileEntry::Directory), domain, party]);
let request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection { root, paths },
);
let snapshot = discover(request)
.into_result()
.expect("portable discovery leaves cardinality to the provider");
assert_eq!(snapshot.projects[0].name, "");
}
#[test]
fn ad_hoc_overlay_project_name_must_be_a_string() {
let (path, entry) = gleam_source("models/domain/customer.gleam");
let root = RelativePath::parse("models").unwrap();
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(path.clone(), entry),
]);
let mut request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: root.clone(),
paths: vec![path],
},
);
request.cli_overlay = json!({ "project": { "name": 42 } });
let error = discover(request).into_result().unwrap_err();
assert_eq!(error.code, WORKSPACE_CONFIG_INVALID);
assert!(error.message.contains("project.name"));
}
#[test]
fn ad_hoc_overlay_project_name_whitespace_only_is_rejected() {
let (path, entry) = gleam_source("models/domain/customer.gleam");
let root = RelativePath::parse("models").unwrap();
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(path.clone(), entry),
]);
let mut request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: root.clone(),
paths: vec![path],
},
);
request.cli_overlay = json!({ "project": { "name": " " } });
let error = discover(request).into_result().unwrap_err();
assert_eq!(error.code, WORKSPACE_PROJECT_NAME_EMPTY);
}
#[test]
fn ad_hoc_empty_selection_is_rejected() {
let root = RelativePath::parse("models").unwrap();
let request = ad_hoc_request(Vec::new(), root);
let error = discover(request).into_result().unwrap_err();
assert_eq!(error.code, WORKSPACE_SELECTION_EMPTY);
assert!(error.message.contains("models"));
}
#[test]
fn ad_hoc_selected_path_naming_a_directory_is_rejected() {
let directory = RelativePath::parse("models/domain").unwrap();
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(directory.clone(), FileEntry::Directory),
]);
let request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: RelativePath::parse("models").unwrap(),
paths: vec![directory.clone()],
},
);
let error = discover(request).into_result().unwrap_err();
assert_eq!(error.code, WORKSPACE_SELECTION_INVALID);
assert!(error.message.contains(directory.as_str()));
}
#[test]
fn ad_hoc_selected_path_naming_nothing_is_rejected() {
let missing = RelativePath::parse("models/domain/missing.gleam").unwrap();
let entries = BTreeMap::from([(RelativePath::root(), FileEntry::Directory)]);
let request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: RelativePath::parse("models").unwrap(),
paths: vec![missing.clone()],
},
);
let error = discover(request).into_result().unwrap_err();
assert_eq!(error.code, WORKSPACE_SELECTION_INVALID);
assert!(error.message.contains(missing.as_str()));
}
#[test]
fn ad_hoc_duplicate_selected_path_is_rejected() {
let (path, entry) = gleam_source("models/domain/customer.gleam");
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(path.clone(), entry),
]);
let request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: RelativePath::parse("models").unwrap(),
paths: vec![path.clone(), path.clone()],
},
);
let error = discover(request).into_result().unwrap_err();
assert_eq!(error.code, WORKSPACE_SELECTION_DUPLICATE);
assert!(error.message.contains(path.as_str()));
}
#[test]
fn ad_hoc_selected_path_sharing_a_string_prefix_with_root_is_rejected() {
let (path, entry) = gleam_source("models-other/file.gleam");
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(path.clone(), entry),
]);
let request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: RelativePath::parse("models").unwrap(),
paths: vec![path.clone()],
},
);
let error = discover(request).into_result().unwrap_err();
assert_eq!(error.code, WORKSPACE_SELECTION_OUTSIDE_ROOT);
assert!(error.message.contains(path.as_str()));
}
#[test]
fn ad_hoc_selection_root_of_dot_contains_every_path() {
let (path, entry) = gleam_source("models/domain/customer.gleam");
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(path.clone(), entry),
]);
let request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: RelativePath::root(),
paths: vec![path.clone()],
},
);
let snapshot = discover(request)
.into_result()
.expect("a `.` selection root should confine, not reject, every selected path");
assert_eq!(snapshot.projects.len(), 1);
assert_eq!(snapshot.projects[0].relative_path, RelativePath::root());
}
fn manifest_request(with_manifest: bool, name: Option<&str>) -> DiscoveryRequest {
let manifest_path = RelativePath::parse("morphir.toml").unwrap();
let (path, entry) = gleam_source("models/domain/customer.gleam");
let mut entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(path.clone(), entry),
]);
if with_manifest {
entries.insert(
manifest_path.clone(),
FileEntry::File {
text: "[project]\nname = 'acme/declared'\n".to_owned(),
},
);
}
let mut request = ad_hoc_request_with_entries(
entries,
ProjectSource::Manifest {
path: manifest_path,
},
SourceSelection {
root: RelativePath::parse("models").unwrap(),
paths: vec![path],
},
);
if let Some(name) = name {
request.cli_overlay = json!({ "project": { "name": name } });
}
request
}
#[test]
fn a_manifest_origin_selection_borrows_the_host_resolved_identity() {
let snapshot = discover(manifest_request(true, Some("acme/widgets")))
.into_result()
.expect("a manifest-origin selection should discover");
let project = &snapshot.projects[0];
let manifest = RelativePath::parse("morphir.toml").unwrap();
assert_eq!(project.name, "acme/widgets");
assert_eq!(
project.origin,
ProjectOrigin::Manifest {
path: manifest.clone()
}
);
assert_eq!(project.config_anchor, Some(manifest));
assert_eq!(
project.relative_path,
RelativePath::parse("models").unwrap()
);
assert_eq!(project.exposed_modules, None);
}
#[test]
fn a_manifest_origin_selection_requires_a_host_stated_name() {
let error = discover(manifest_request(true, None))
.into_result()
.unwrap_err();
assert_eq!(error.code, WORKSPACE_SELECTION_NAME_REQUIRED);
assert!(error.message.contains("morphir.toml"));
}
#[test]
fn a_manifest_origin_selection_requires_the_manifest_to_exist() {
let error = discover(manifest_request(false, Some("acme/widgets")))
.into_result()
.unwrap_err();
assert_eq!(error.code, WORKSPACE_SELECTION_INVALID);
assert!(error.message.contains("morphir.toml"));
}
#[test]
fn ad_hoc_discover_with_details_collects_defaults_and_overlay_without_panicking() {
let path = RelativePath::parse("models/domain/customer.gleam").unwrap();
let root = RelativePath::parse("models").unwrap();
let mut request = ad_hoc_request(vec![path.clone()], root.clone());
request.cli_overlay = json!({ "ir": { "mode": "cli-overlay" } });
let details = discover_with_details(request)
.expect("the ad-hoc path must collect a root config, not panic in `finish`");
assert_eq!(details.root_effective["ir"]["mode"], "cli-overlay");
assert_eq!(
details.project_effective[&root]["ir"]["mode"],
"cli-overlay"
);
assert_eq!(details.snapshot.projects.len(), 1);
}
#[test]
fn ad_hoc_ignores_a_manifest_present_in_the_tree() {
let (path, entry) = gleam_source("models/domain/customer.gleam");
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(path.clone(), entry),
(
RelativePath::parse("morphir.toml").unwrap(),
FileEntry::File {
text: "[workspace]\nmembers = [\"packages/*\"]\n[project]\nname = \"acme/root\"\nsource_directory = \"src\"\n"
.to_owned(),
},
),
]);
let root = RelativePath::parse("models").unwrap();
let request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: root.clone(),
paths: vec![path.clone()],
},
);
let snapshot = discover(request)
.into_result()
.expect("an ad-hoc request should succeed even with a manifest present in the tree");
assert_eq!(snapshot.projects.len(), 1);
let project = &snapshot.projects[0];
assert_eq!(
project.origin,
ProjectOrigin::Synthesized { inputs: vec![path] }
);
assert_eq!(project.relative_path, root);
assert_eq!(project.name, "");
assert_eq!(snapshot.config_anchor, None);
}
#[test]
fn ad_hoc_discover_with_details_at_root_reinserts_root_into_project_effective() {
let path = RelativePath::parse("models/domain/customer.gleam").unwrap();
let root = RelativePath::root();
let request = ad_hoc_request(vec![path], root.clone());
let details = discover_with_details(request)
.expect("the ad-hoc path at `.` must collect a root config, not panic in `finish`");
assert_eq!(details.snapshot.projects.len(), 1);
assert_eq!(details.snapshot.projects[0].relative_path, root);
assert_eq!(
details.project_effective.get(&root),
Some(&details.root_effective)
);
}
#[test]
fn ad_hoc_selected_path_equal_to_root_is_rejected_by_confinement_not_file_existence() {
let root = RelativePath::parse("models").unwrap();
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(root.clone(), FileEntry::Directory),
]);
let request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: root.clone(),
paths: vec![root.clone()],
},
);
let error = discover(request).into_result().unwrap_err();
assert_eq!(error.code, WORKSPACE_SELECTION_OUTSIDE_ROOT);
assert!(error.message.contains(root.as_str()));
}
#[test]
fn ad_hoc_empty_language_id_is_rejected() {
let (path, entry) = gleam_source("models/domain/customer.gleam");
let entries = BTreeMap::from([
(RelativePath::root(), FileEntry::Directory),
(path.clone(), entry),
]);
let mut request = ad_hoc_request_with_entries(
entries,
ProjectSource::Synthesized,
SourceSelection {
root: RelativePath::parse("models").unwrap(),
paths: vec![path],
},
);
let DiscoveryPurpose::AdHocSources {
language_id: purpose_language_id,
..
} = &mut request.purpose
else {
unreachable!("ad_hoc_request_with_entries always builds an AdHocSources purpose")
};
purpose_language_id.clear();
let error = discover(request).into_result().unwrap_err();
assert_eq!(error.code, WORKSPACE_LANGUAGE_ID_EMPTY);
assert!(error.message.contains("models"));
}