def test_overlapping_registries(ctx_part_env, simple_fixture, param_fixture): '''Test instantiate_all(), update() and difference() registry methods.''' # Get one valid part+env combination part, env = ctx_part_env() # Build base registry with some fixtures reg = fixtures.FixtureRegistry() reg.add(simple_fixture(), 0, 'b', [part], [env]) for i in param_fixture().variants: reg.add(param_fixture(), i, 'b', [part], [env]) # Build overlapping registry other = fixtures.FixtureRegistry() other.add(simple_fixture(variables={'v': 2}), 0, 'b', [part], [env]) for i in param_fixture().variants: other.add(param_fixture(), i, 'b', [part], [env]) assert len(reg.instantiate_all()) == len(param_fixture().variants) + 1 assert len(other.instantiate_all()) == len(param_fixture().variants) + 1 # Test difference method diff_reg = other.difference(reg) inst = diff_reg.instantiate_all() # Assert the difference is only the simple fixture with custom variable v. # This also tests that the instantiate_all() method sets the test variables # correctly. assert len(inst) == 1 assert inst[0].v == 2 assert inst[0].name == list(diff_reg[simple_fixture().cls].keys())[0] assert inst[0].valid_systems == [part] assert inst[0].valid_prog_environs == [env] # Test the difference method in the opposite direction diff_reg = reg.difference(other) inst = diff_reg.instantiate_all() assert len(inst) == 1 assert inst[0].v == 1 # Test the update method reg.update(other) assert len(reg.instantiate_all()) == len(param_fixture().variants) + 2 # Test ops with not a registry class Foo: pass with pytest.raises(TypeError): reg.update(Foo()) with pytest.raises(TypeError): reg.difference(Foo())
def test_fixture_registry_variants(ctx_part_env, param_fixture): '''Test different fixture variants are registered separately.''' reg = fixtures.FixtureRegistry() # Get one valid part+env combination part, env = ctx_part_env() registered_fixt = set() def register(scope='test', variant=0): registered_fixt.update( reg.add(param_fixture(scope=scope), variant, 'b', [part], [env])) register(scope='test', variant=0) assert len(registered_fixt) == 1 register(scope='test', variant=1) assert len(registered_fixt) == 2 register(scope='environment', variant=0) assert len(registered_fixt) == 3 register(scope='environment', variant=1) assert len(registered_fixt) == 4 register(scope='partition', variant=0) assert len(registered_fixt) == 5 register(scope='partition', variant=1) assert len(registered_fixt) == 6 register(scope='session', variant=0) assert len(registered_fixt) == 7 register(scope='session', variant=1) assert len(registered_fixt) == 8
def test_fixture_registry_base_arg(ctx_part_env, simple_fixture): '''The base argument argument only has an effect with test scope.''' reg = fixtures.FixtureRegistry() # Get one valid part+env combination part, env = ctx_part_env() registered_fixt = set() def register(scope, base): registered_fixt.update( reg.add(simple_fixture(scope=scope), 0, base, [part], [env])) # For a test scope, the base name is used for the fixture name mangling. # So changing this base arg, leads to a new fixture being registered. register(scope='test', base='b1') assert len(registered_fixt) == 1 register(scope='test', base='b2') assert len(registered_fixt) == 2 # The base argument is not used with any of the other scopes. register(scope='environment', base='b1') assert len(registered_fixt) == 3 register(scope='environment', base='b2') assert len(registered_fixt) == 3 register(scope='partition', base='b1') assert len(registered_fixt) == 4 register(scope='partition', base='b2') assert len(registered_fixt) == 4 register(scope='session', base='b3') assert len(registered_fixt) == 5 register(scope='session', base='b3') assert len(registered_fixt) == 5
def test_fixture_registry_variables(ctx_part_env, simple_fixture): '''Test that the order of the variables does not matter.''' reg = fixtures.FixtureRegistry() # Get one valid part+env combination part, env = ctx_part_env() registered_fixt = set() def register(**kwargs): registered_fixt.update( reg.add(simple_fixture(**kwargs), 0, 'b', [part], [env])) register(variables={'a': 1, 'b': 2}) assert len(registered_fixt) == 1 register(variables={'b': 2, 'a': 1}) assert len(registered_fixt) == 1 # Fixture with different variables is treated as a new fixture. register(variables={'a': 2, 'b': 2}) assert len(registered_fixt) == 2 register() assert len(registered_fixt) == 3 # Test also the format of the internal fixture tuple fixt_data = list(reg[simple_fixture().cls].values())[0] assert fixt_data.variant_num == 0 assert fixt_data.environments == [env] assert fixt_data.partitions == [part] assert all(v in fixt_data.variables for v in ('b', 'a'))
def test_fixture_registry_variants(ctx_sys, param_fixture, simple_test): '''Test different fixture variants are registered separately.''' reg = fixtures.FixtureRegistry() registered_fixt = set() def register(scope='test', variant=0): # We use a single valid part/env combination registered_fixt.update( reg.add(param_fixture(scope=scope), variant, simple_test(['sys1:p0'], ['e0']))) register(scope='test', variant=0) assert len(registered_fixt) == 1 register(scope='test', variant=1) assert len(registered_fixt) == 2 register(scope='environment', variant=0) assert len(registered_fixt) == 3 register(scope='environment', variant=1) assert len(registered_fixt) == 4 register(scope='partition', variant=0) assert len(registered_fixt) == 5 register(scope='partition', variant=1) assert len(registered_fixt) == 6 register(scope='session', variant=0) assert len(registered_fixt) == 7 register(scope='session', variant=1) assert len(registered_fixt) == 8
def test_bad_fixture_inst(ctx_sys, simple_test): '''Test that instantiate_all does not raise an exception.''' class Foo(rfm.RegressionTest): def __init__(self): raise Exception('raise exception during instantiation') reg = fixtures.FixtureRegistry() reg.add(fixtures.TestFixture(Foo), 0, simple_test(['sys1:p0'], ['e0'])) reg.instantiate_all()
def test_fixture_registry_edge_cases(ctx_sys, simple_fixture, simple_test): '''Test edge cases.''' reg = fixtures.FixtureRegistry() registered_fixt = set() def register(test, **kwargs): registered_fixt.update(reg.add(simple_fixture(**kwargs), 0, test)) # Invalid partitions - NO-OP register(simple_test(['wrong_partition'], ['e1', 'e2'])) assert len(registered_fixt) == 0 # Valid partition but wrong environment - NO-OP (except test scope) register(simple_test(['sys1:p0'], ['wrong_environment']), scope='session') assert len(registered_fixt) == 0 register(simple_test(['sys1:p0'], ['wrong_environment']), scope='partition') assert len(registered_fixt) == 0 register(simple_test(['sys1:p0'], ['wrong_environment']), scope='environment') assert len(registered_fixt) == 0 register(simple_test(['sys1:p0'], ['wrong_environment']), scope='test') assert len(registered_fixt) == 1 registered_fixt.pop() # Environ 'e2' is not supported in 'sys1:p0', but is in 'sys1:p1' register(simple_test(['sys1:p0', 'sys1:p1'], ['e2']), scope='session') assert len(registered_fixt) == 1 # 'sys1:p0' is skipped on this fixture because env 'e2' is not supported last_fixture = reg[simple_fixture().cls][registered_fixt.pop()] assert last_fixture.partitions == ['sys1:p1'] assert last_fixture.environments == ['e2'] # Similar behavior with the partition scope register(simple_test(['sys1:p0', 'sys1:p1'], ['e2']), scope='partition') assert len(registered_fixt) == 1 last_fixture = reg[simple_fixture().cls][registered_fixt.pop()] assert last_fixture.partitions == ['sys1:p1'] assert last_fixture.environments == ['e2'] # And also similar behavior with the environment scope register(simple_test(['sys1:p0', 'sys1:p1'], ['e2']), scope='environment') assert len(registered_fixt) == 1 last_fixture = reg[simple_fixture().cls][registered_fixt.pop()] assert last_fixture.partitions == ['sys1:p1'] assert last_fixture.environments == ['e2'] # However, with the test scope partitions and environments get copied # without any filtering. register(simple_test(['sys1:p0', 'sys1:p1'], ['e2']), scope='test') assert len(registered_fixt) == 1 last_fixture = reg[simple_fixture().cls][registered_fixt.pop()] assert last_fixture.partitions == ['sys1:p0', 'sys1:p1'] assert last_fixture.environments == ['e2']
def test_bad_fixture_inst(ctx_part_env): '''Test that instantiate_all does not raise an exception.''' # Get one valid part+env combination part, env = ctx_part_env() class Foo(rfm.RegressionTest): def __init__(self): raise Exception('raise exception during instantiation') reg = fixtures.FixtureRegistry() reg.add(fixtures.TestFixture(Foo), 0, 'b', [part], [env]) reg.instantiate_all()
def test_fixture_registry_all(ctx_sys, simple_fixture): '''Test with all valid partition and environments available.''' class MyTest(rfm.RegressionTest): valid_systems = ['*'] valid_prog_environs = ['*'] test = MyTest() reg = fixtures.FixtureRegistry() # Get all part and environs all_part = [p.fullname for p in ctx_sys.partitions] all_env = [e.name for p in ctx_sys.partitions for e in p.environs] registered_fixt = set() def register(s, **kwargs): registered_fixt.update( reg.add(simple_fixture(scope=s, **kwargs), 0, test)) register('test') assert len(registered_fixt) == 1 register('environment') assert len(registered_fixt) == 1 + len(all_env) register('partition') assert len(registered_fixt) == 1 + len(all_env) + len(all_part) register('session') assert len(registered_fixt) == 2 + len(all_env) + len(all_part) # Test the __getitem__ method names = reg[simple_fixture().cls].keys() assert len(names) == len(registered_fixt) class Foo: pass assert reg[Foo] == dict() # Test the __contains__ method assert simple_fixture().cls in reg