def test_immutable(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {"i_text_in_folder": "I(folder)"}
the_filter: Filter = HasAnySpecificValues(context, schema, criteria)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
expected: List = [composite_list[3]]
assert actual == expected
def _do_test(var_id: VariableId, expected: List[Composite]):
the_filter: Filter = DoesNotExist(context,
schema,
var_id,
narrows=False)
f_iter: Callable = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composites))
assert actual == expected
def test_one_temporal(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {"t_text_in_root": "bbbb"}
the_filter: Filter = HasAnySpecificValues(context, schema, criteria)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
expected: List[Composite] = [composite_list[2]]
del expected[0].content["period_2"]
assert actual == expected
def test_t_and_i_temporal_wrong(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"i_text_in_folder": "I(folder)",
"t_text_in_folder": "Not the real value"
}
the_filter: Filter = HasAllSpecificValues(context, schema, criteria)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
assert len(list(f_iter(composite_list))) == 0
def _do_test(var_id: VariableId, threshold, expected: List[Composite]):
the_filter: Filter = GreaterThan(None,
schema,
var_id,
threshold,
narrows=False)
f_iter: Callable = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composites))
assert actual == expected
def _do_test(values: List[str], expected: List[Composite]):
the_filter: Filter = MatchesOneOf(None,
schema,
"t_text",
values=values,
narrows=False)
f_iter: Callable = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composites))
assert actual == expected
def test_two_temporal_no_match(schema, composites, context):
composite_list = list(composites)
# Both values occur in Composite 3, but not in the same period
criteria: Dict = {"t_text_in_folder": "1111", "t_text_in_root": "bbbb"}
the_filter: Filter = HasAllSpecificValues(context,
schema,
criteria,
narrows=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
assert len(list(f_iter(composite_list))) == 0
def test_one_temporal(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {"t_text_in_root": "bbbb"}
the_filter: Filter = HasAllSpecificValues(context,
schema,
criteria,
filters=False)
expected: List[Composite] = make_c3_expected(composite_list)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
assert actual == expected
def test_two_temporal_match_same(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {"t_text_in_folder": "aaaa", "t_text_in_root": "bbbb"}
the_filter: Filter = HasAnySpecificValues(context,
schema,
criteria,
narrows=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
expected: List = [composite_list[2]]
assert actual == expected
def test_temporal_and_immutable_match(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"i_text_in_folder": "I(folder)",
"t_text_in_folder": "P1(folder)"
}
the_filter: Filter = HasAllSpecificValues(context, schema, criteria)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
expected: List[Composite] = [copy.copy(composite_list[3])]
del expected[0].content["period_2"]
assert actual == expected
def test_t_and_i_immutable_wrong(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"i_text_in_folder": "Not a real value",
"t_text_in_folder": "P1(folder)"
}
the_filter: Filter = HasAnySpecificValues(context, schema, criteria)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
expected: List = [composite_list[3]]
del expected[0].content["period_2"]
assert actual == expected
def test_no_narrow(schema, composites, context):
composite_list = list(composites)
expected: Dict = copy.deepcopy(composite_list[2].content)
criteria: Dict = {"t_text_in_root": "bbbb"}
the_filter: Filter = HasAnySpecificValues(context,
schema,
criteria,
narrows=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
outcome: List[Composite] = list(f_iter(composite_list))
actual: Dict = outcome[0].content
assert actual == expected
def test_t_text_ignores_case(schema, do_test, composites):
threshold: str = "b"
var_id: str = "t_text"
expected: List[Composite] = [composites[0]]
the_filter: Filter = EqualTo(None,
schema,
var_id,
threshold,
narrows=False)
f_iter: Callable = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composites))
assert actual == expected
def test_two_temporal_match_different(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"t_text_in_folder": "in a folder",
"t_text_in_root": "bbbb"
}
the_filter: Filter = HasAnySpecificValues(context, schema, criteria)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
expected: List = [composite_list[0], composite_list[2]]
del expected[1].content["period_2"]
actual: List[Composite] = list(f_iter(composite_list))
assert actual == expected
def test_t_and_i_temporal_wrong(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"i_text_in_folder": "I(folder)",
"t_text_in_folder": "Not a real value"
}
the_filter: Filter = HasAnySpecificValues(context,
schema,
criteria,
narrows=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
expected: List = [composite_list[3]]
assert actual == expected
def test_no_effect_on_narrowing(pass_condition: str, schema: Schema,
earliest_composite):
context: Context = MagicMock(spec=Context)
the_filter: Filter = Exists(context,
schema,
"t_text",
filters=False,
pass_condition=pass_condition)
f_iter: Callable = InMemoryFilterIterator([the_filter])
expected: List[Composite] = [copy.copy(earliest_composite)]
del expected[0].content["period_2"]
del expected[0].content["period_3"]
actual: List[Composite] = list(f_iter([earliest_composite]))
assert actual == expected
def test_temporal_and_immutable_match(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"i_text_in_folder": "lorem",
"t_text_in_folder": "P1(folder)"
}
the_filter: Filter = HasAnySpecificValues(context,
schema,
criteria,
narrows=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
expected: List = [composite_list[0], composite_list[3]]
assert actual == expected
def _do_test(var_id: str, pass_condition: str,
expected_keys: List[str]) -> None:
context: Context = MagicMock(spec=Context)
the_filter: Filter = DoesNotExist(context,
schema,
var_id,
narrows=False,
pass_condition=pass_condition)
f_iter: Callable = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composites.values()))
expected: List[Composite] = []
for key in expected_keys:
expected.append(composites[key])
assert actual == expected
def test_two_temporal_no_match(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {"t_text_in_folder": "cccc", "t_text_in_root": "bbbb"}
the_filter: Filter = HasAllSpecificValues(context,
schema,
criteria,
filters=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
# Because the criteria contain no immutable variables, only temporal periods are purged
expected: List[Composite] = purge_all_periods(composite_list)
actual: List[Composite] = list(f_iter(composite_list))
assert actual == expected
def build(cls, context: "Context", schema: "Schema",
*children: List[Dict]) -> "CompoundFilter": # type: ignore
filters: List[Filter] = []
for child_spec in children:
assert isinstance(child_spec, dict) and len(child_spec) == 1
for class_name, kwargs in child_spec.items(): # type: str, Dict
try:
the_filter: Filter = Filter.build(context=context,
schema=schema,
name=class_name,
**kwargs)
except Exception as e:
raise e
filters.append(the_filter)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator(filters)
return cls(context, schema, f_iter)
def test_immutable(schema, composites, context):
composite_list = list(composites)
expected: List[Composite] = [copy.copy(c) for c in composite_list]
# Because the criteria contain immutable variables, everything is purged
for composite in expected[:-1]:
composite.content = {}
criteria: Dict = {"i_text_in_folder": "I(folder)"}
the_filter: Filter = HasAllSpecificValues(context,
schema,
criteria,
filters=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
assert actual == expected
def test_t_and_i_temporal_wrong(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"i_text_in_folder": "I(folder)",
"t_text_in_folder": "Not a real value"
}
the_filter: Filter = HasAnySpecificValues(context,
schema,
criteria,
filters=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
expected: List[Composite] = [copy.copy(c) for c in composite_list]
for composite in expected[:-1]:
for period in composite.periods:
del composite.content[period]
actual: List[Composite] = list(f_iter(composite_list))
assert actual == expected
def test_temporal_and_immutable(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"i_text_in_folder": "lorem",
"t_text_in_folder": "P1(folder)"
}
the_filter: Filter = HasAnySpecificValues(context,
schema,
criteria,
filters=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
expected: List[Composite] = [copy.copy(c) for c in composite_list]
del expected[2].content["period_1"]
del expected[2].content["period_2"]
del expected[3].content["period_2"]
assert actual == expected
def test_immutable(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {"i_text_in_folder": "I(folder)"}
the_filter: Filter = HasAnySpecificValues(context,
schema,
criteria,
filters=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
# Because the only criterion is an immutable variable, it applies to all periods; consequently, all periods are
# retained for Composite 4.
expected: List[Composite] = [copy.copy(c) for c in composite_list]
del expected[0].content["period_1"]
del expected[2].content["period_1"]
del expected[2].content["period_2"]
actual: List[Composite] = list(f_iter(composite_list))
assert actual == expected
def _do_test(values: List[str], keys: List[Set[str]]):
expected: List[Composite] = []
for i, i_keys in enumerate(keys):
content: Dict = {}
for key in i_keys:
content[key] = composites[i].content[key]
composite: Composite = Composite(
schema, content, composite_id=composites[i].composite_id)
expected.append(composite)
the_filter: Filter = MatchesOneOf(None,
schema,
"t_text",
values,
filters=False)
f_iter: Callable = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composites))
assert actual == expected
def test_t_and_i_immutable_wrong(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"i_text_in_folder": "Not the real value",
"t_text_in_folder": "P1(folder)"
}
# Because the immutable value is wrong in Composite 4, every period is purged in every composite
expected: List[Composite] = [copy.copy(c) for c in composite_list]
for composite in expected:
composite.content = {}
the_filter: Filter = HasAllSpecificValues(context,
schema,
criteria,
filters=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
assert actual == expected
def test_values_from_file(schema, composites, get_file_name, case_name) -> None:
file_name: str = get_file_name(case_name)
keys: List[Set[str]] = [
{"period_1", "period_2", "immutable"},
{"immutable"}
]
expected: List[Composite] = []
for i, i_keys in enumerate(keys):
content: Dict = {}
for key in i_keys:
content[key] = composites[i].content[key]
composite: Composite = Composite(schema, content, composite_id=composites[i].composite_id)
expected.append(composite)
the_filter: Filter = ContainsOneOf(None, schema, "t_text", file_name=file_name, filters=False)
f_iter: Callable = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composites))
assert actual == expected
def test_temporal_and_immutable_match(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"i_text_in_folder": "I(folder)",
"t_text_in_folder": "P1(folder)"
}
# Because the criteria contain immutable variables, everything is purged for composites 1-3. For composite 4, the
# non-matching period is also purged.
expected: List[Composite] = [copy.copy(c) for c in composite_list]
for composite in expected[:-1]:
composite.content = {}
del expected[3].content["period_2"]
the_filter: Filter = HasAllSpecificValues(context,
schema,
criteria,
filters=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
assert actual == expected
def test_t_and_i_temporal_wrong(schema, composites, context):
composite_list = list(composites)
criteria: Dict = {
"i_text_in_folder": "I(folder)",
"t_text_in_folder": "Not the real value"
}
# Because the immutable value is right in Composite 4, the immutable values remain in that composite; everything
# else is purged from all of the composites
expected: List[Composite] = [copy.copy(c) for c in composite_list]
for composite in expected[:-1]:
composite.content = {}
for period in expected[-1].periods:
del expected[-1].content[period]
the_filter: Filter = HasAllSpecificValues(context,
schema,
criteria,
filters=False)
f_iter: InMemoryFilterIterator = InMemoryFilterIterator([the_filter])
actual: List[Composite] = list(f_iter(composite_list))
assert actual == expected
def subject(schema, context) -> InMemoryFilterIterator:
filters: List[Filter] = [
ImmutableValueThreshold(context, schema, cast(VariableId, "immutable_var"), 7),
EarliestFilter(context, schema)
]
return InMemoryFilterIterator(filters)