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)