def list_of_aggregators():
def helper_default_aggregator_function(jobs):
yield tuple(jobs)
def helper_non_default_aggregator_function(jobs):
for job in jobs:
yield (job, )
# The below list contains 14 distinct aggregator objects and some duplicates.
return [
_aggregator(),
_aggregator(),
_aggregator(helper_default_aggregator_function),
_aggregator(helper_non_default_aggregator_function),
_aggregator(helper_non_default_aggregator_function),
_aggregator.groupsof(1),
_aggregator.groupsof(1),
_aggregator.groupsof(2),
_aggregator.groupsof(3),
_aggregator.groupsof(4),
_aggregator.groupby("even"),
_aggregator.groupby("even"),
_aggregator.groupby("half", -1),
_aggregator.groupby("half", -1),
_aggregator.groupby(["half", "even"], default=[-1, -1]),
]
def test_groups_of_valid_num(self, setUp, project):
valid_values = [1, 2, 3, 6, 10]
# Expected length of aggregates which are made using the above values.
expected_length_of_aggregators = [10, 5, 4, 2, 1]
# Expect length of each aggregate which are made using the above
# values. The zeroth index of the nested list denotes the length of all
# the aggregates expect the last one. The first index denotes the
# length of the last aggregate formed.
expected_length_per_aggregate = [[1, 1], [2, 2], [3, 1], [6, 4],
[10, 10]]
for i, valid_value in enumerate(valid_values):
aggregate_instance = _aggregator.groupsof(valid_value)
aggregate_store = aggregate_instance._create_AggregateStore(
project)
expected_len = expected_length_of_aggregators[i]
assert len(aggregate_store) == expected_len
# We also check the length of every aggregate in order to ensure
# proper aggregation.
for j, aggregate in enumerate(aggregate_store.values()):
if j == expected_len - 1: # Checking for the last aggregate
assert len(
aggregate) == expected_length_per_aggregate[i][1]
else:
assert len(
aggregate) == expected_length_per_aggregate[i][0]
def test_contains(self, setUp, project):
jobs = tuple(project)
aggregator_instance = _aggregator()._create_AggregateStore(project)
default_aggregator = _aggregator.groupsof(1)._create_AggregateStore(
project)
# Test for an aggregate of all jobs
assert _get_aggregate_id(jobs) in aggregator_instance
assert _get_aggregate_id(jobs) not in default_aggregator
# Test for an aggregate of single job
assert not jobs[0].get_id() in aggregator_instance
assert jobs[0].get_id() in default_aggregator
def test_get_invalid_id(self, setUp, project):
jobs = tuple(project)
aggregator_instance = _aggregator()._create_AggregateStore(project)
default_aggregator = _aggregator.groupsof(1)._create_AggregateStore(
project)
# Test for an aggregate of single job for aggregator instance
with pytest.raises(LookupError):
aggregator_instance[_get_aggregate_id((jobs[0], ))]
# Test for an aggregate of all jobs for default aggregator
with pytest.raises(LookupError):
default_aggregator[_get_aggregate_id(jobs)]
def test_valid_select(self, setUp, project):
def _select(job):
return job.sp.i > 5
aggregate_instance = _aggregator.groupsof(1, select=_select)
aggregate_store = aggregate_instance._create_AggregateStore(project)
selected_jobs = []
for job in project:
if _select(job):
selected_jobs.append((job, ))
assert list(aggregate_store.values()) == selected_jobs
def test_groups_of_invalid_num(self):
invalid_values = [{}, "str", -1, -1.5]
for invalid_value in invalid_values:
with pytest.raises((TypeError, ValueError)):
_aggregator.groupsof(invalid_value)