|
2 | 2 |
|
3 | 3 | use crate::assembly::project::types::ObjectKey; |
4 | 4 | use crate::planner_scope::main::expand_loaders::expand_loaders; |
| 5 | +use crate::planner_scope::main::node_loads::node_loads; |
5 | 6 | use crate::planner_scope::models::LoaderGraph; |
6 | | -use crate::planner_scope::tests::test_types::{DeepLoaderTestCase, LoaderTestCase}; |
7 | | -use std::collections::HashSet; |
| 7 | +use crate::planner_scope::tests::test_types::{ |
| 8 | + DeepLoaderTestCase, LoaderTestCase, NodeLoadsTestCase, |
| 9 | +}; |
| 10 | +use std::collections::{BTreeMap, BTreeSet, HashSet}; |
8 | 11 |
|
9 | 12 | #[test] |
10 | 13 | fn given_shared_loader_dependencies_when_expanding_then_preserves_depth_first_edges_and_breadth_first_names() |
@@ -120,3 +123,87 @@ fn given_deep_loader_chain_when_expanding_then_uses_iterative_traversal() { |
120 | 123 | ); |
121 | 124 | } |
122 | 125 | } |
| 126 | + |
| 127 | +#[test] |
| 128 | +fn given_loader_chains_and_unmanaged_reads_when_listing_node_loads_then_only_declared_source_writers_appear() |
| 129 | + { |
| 130 | + let test_cases = [ |
| 131 | + NodeLoadsTestCase { |
| 132 | + description: "a hook-read managed source is listed and an unmanaged read is not", |
| 133 | + loaders: vec![("raw_returns", vec![])], |
| 134 | + sources: vec![("raw_returns", Some("raw_returns")), ("raw_products", None)], |
| 135 | + upstream: vec![ |
| 136 | + ( |
| 137 | + "model:orders", |
| 138 | + vec![ |
| 139 | + "source:raw_returns", |
| 140 | + "source:raw_products", |
| 141 | + "model:stg_orders", |
| 142 | + ], |
| 143 | + ), |
| 144 | + ("model:stg_orders", vec!["source:raw_products"]), |
| 145 | + ("source:raw_products", vec![]), |
| 146 | + ], |
| 147 | + expected_loads: vec![("model:orders", vec!["source:raw_returns"])], |
| 148 | + }, |
| 149 | + NodeLoadsTestCase { |
| 150 | + // stage_orders has no declaring source, so a run that loads it still fails in the worker. |
| 151 | + description: "a chain keeps declared loaders behind an intermediate one and drops the intermediate", |
| 152 | + loaders: vec![ |
| 153 | + ("raw_orders", vec!["stage_orders"]), |
| 154 | + ("stage_orders", vec!["raw_customers"]), |
| 155 | + ("raw_customers", vec![]), |
| 156 | + ], |
| 157 | + sources: vec![ |
| 158 | + ("raw_orders", Some("raw_orders")), |
| 159 | + ("raw_customers", Some("raw_customers")), |
| 160 | + ], |
| 161 | + upstream: vec![ |
| 162 | + ("source:raw_orders", vec![]), |
| 163 | + ("source:raw_customers", vec![]), |
| 164 | + ], |
| 165 | + expected_loads: vec![("source:raw_orders", vec!["source:raw_customers"])], |
| 166 | + }, |
| 167 | + ]; |
| 168 | + let key = |text: &str| { |
| 169 | + let (kind, name) = text.split_once(':').expect("kind:name"); |
| 170 | + (kind.to_owned(), name.to_owned()) |
| 171 | + }; |
| 172 | + for test_case in test_cases { |
| 173 | + let graph = LoaderGraph { |
| 174 | + loaders: test_case |
| 175 | + .loaders |
| 176 | + .iter() |
| 177 | + .map(|(name, deps)| { |
| 178 | + ( |
| 179 | + (*name).to_owned(), |
| 180 | + deps.iter().map(|dep| (*dep).to_owned()).collect(), |
| 181 | + ) |
| 182 | + }) |
| 183 | + .collect(), |
| 184 | + sources: test_case |
| 185 | + .sources |
| 186 | + .iter() |
| 187 | + .map(|(name, loader)| ((*name).to_owned(), loader.map(str::to_owned))) |
| 188 | + .collect(), |
| 189 | + }; |
| 190 | + let upstream: Vec<(ObjectKey, Vec<ObjectKey>)> = test_case |
| 191 | + .upstream |
| 192 | + .iter() |
| 193 | + .map(|(node, deps)| (key(node), deps.iter().map(|dep| key(dep)).collect())) |
| 194 | + .collect(); |
| 195 | + assert_eq!( |
| 196 | + node_loads(&graph, &upstream), |
| 197 | + test_case |
| 198 | + .expected_loads |
| 199 | + .iter() |
| 200 | + .map(|(node, writers)| ( |
| 201 | + key(node), |
| 202 | + writers.iter().map(|writer| key(writer)).collect() |
| 203 | + )) |
| 204 | + .collect::<BTreeMap<ObjectKey, BTreeSet<ObjectKey>>>(), |
| 205 | + "{}", |
| 206 | + test_case.description |
| 207 | + ); |
| 208 | + } |
| 209 | +} |
0 commit comments