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
