use super::{AggregateModel, GROUP, Grouped, MEASURE, Measure, Measured, Owed};
use crate::model::Projection;
fn over(groups: &[&str], measures: &[&str]) -> AggregateModel {
let ident = |name: &str| syn::Ident::new(name, proc_macro2::Span::call_site());
AggregateModel {
aggregate: ident("CodecCensus"),
vis: syn::Visibility::Inherited,
krate: syn::parse_quote!(::ingraph),
krate_spelled: None,
upstream: syn::parse_quote!(demux::Track),
groups: groups
.iter()
.map(|name| Grouped {
field: ident(name),
from: ident(name),
ty: syn::parse_quote!(u64),
projection: Projection::Borrowed,
})
.collect(),
measures: measures
.iter()
.map(|name| Measured {
field: ident(name),
by: Measure::Counting,
from: None,
ty: syn::parse_quote!(u64),
projection: Projection::Borrowed,
})
.collect(),
triggers: proc_macro2::TokenStream::new(),
stores: proc_macro2::TokenStream::new(),
graphql: None,
}
}
#[test]
fn the_columns_are_the_groups_then_the_measures() {
let model = over(&["codec", "lang"], &["count", "bytes"]);
assert_eq!(
model.columns().map(ToString::to_string).collect::<Vec<_>>(),
["codec", "lang", "count", "bytes"],
);
}
#[test]
fn every_shipped_fold_is_readable_by_the_word_that_names_it() {
for word in Measure::SHIPPED {
let shipped = Measure::shipped(word).unwrap_or_else(|| panic!("`{word}` is shipped"));
assert_eq!(shipped.as_written(), word);
}
assert!(
Measure::shipped("median").is_none(),
"the bare half is closed — every other fold arrives quoted"
);
}
#[test]
fn a_declared_fold_reads_back_as_its_path() {
let declared = Measure::Declared(syn::parse_quote!(app::Median));
assert_eq!(declared.as_written().replace(' ', ""), "app::Median");
}
#[test]
fn what_a_fold_owes_is_known_for_the_ones_this_crate_ships() {
assert_eq!(Measure::Counting.owed(), Owed::Nothing);
assert_eq!(Measure::Summing.owed(), Owed::Column);
assert_eq!(
Measure::Declared(syn::parse_quote!(app::Median)).owed(),
Owed::Theirs,
"a fold this crate did not write is one it cannot answer for"
);
}
#[test]
fn every_shipped_fold_answers_what_it_owes() {
for word in Measure::SHIPPED {
let shipped = Measure::shipped(word).unwrap_or_else(|| panic!("`{word}` is shipped"));
assert_ne!(
shipped.owed(),
Owed::Theirs,
"`{word}` is this crate's own fold, so what it reads is this crate's to know"
);
}
}
#[test]
fn a_measure_carries_the_upstream_column_its_fold_reads() {
let mut model = over(&["codec"], &["count", "bytes"]);
model.measures[1].by = Measure::Summing;
model.measures[1].from = Some(syn::Ident::new("size", proc_macro2::Span::call_site()));
assert!(
model.measures[0].from.is_none(),
"a counted column reads no column of the rows it counts"
);
assert_eq!(
model.measures[1]
.from
.as_ref()
.expect("a summed column names the column it totals"),
"size",
);
}
#[test]
fn the_role_words_are_the_words_a_declaration_writes() {
assert_eq!(GROUP, "group");
assert_eq!(MEASURE, "measure");
assert_ne!(GROUP, MEASURE);
}