"""Unit tests for bison.scheme""" import pytest from bison import errors, scheme def test_base_opt_validate(): """Validate the base option, which should fail.""" opt = scheme._BaseOpt() with pytest.raises(NotImplementedError): opt.validate('test-data') def test_base_opt_parse_env(): """Parse env from the base option, which should fail.""" opt = scheme._BaseOpt() with pytest.raises(NotImplementedError): opt.parse_env() class TestOption: """Tests for the `Option` class.""" def test_init_simple(self): """Initialize an Option.""" opt = scheme.Option('test-opt') assert opt.name == 'test-opt' assert type(opt.default) == scheme.NoDefault assert opt.type is None assert opt.choices is None assert opt.bind_env is None def test_init_full(self): """Initialize an Option.""" opt = scheme.Option( name='test-opt', default='foo', field_type=str, choices=['foo', 'bar'], bind_env=True ) assert opt.name == 'test-opt' assert type(opt.default) != scheme.NoDefault assert opt.default == 'foo' assert opt.type == str assert opt.choices == ['foo', 'bar'] assert opt.bind_env is True @pytest.mark.parametrize( 'field_type,value', [ (str, 'test-value'), (str, ''), (int, 0), (int, 1000), (int, -1), (float, 0.0), (float, 1000.999), (float, -1.0), (bool, True), (bool, False), (list, []), (list, [1, 2, 3]), (list, ['a', 'b', 'c']), (tuple, tuple()), (tuple, (1,)), (tuple, ('a', 'b')), (dict, {}), (dict, {'a': 'b'}), (dict, {1: 2}) ] ) def test_validate_type_ok(self, field_type, value): """Validate an Option, where type validation succeeds""" opt = scheme.Option('test-option', field_type=field_type) opt.validate(value) @pytest.mark.parametrize( 'field_type,value', [ (str, None), (str, 1), (str, 1.8), (str, True), (str, ['a', 'b', 'c']), (int, None), (int, 'value'), (int, 1.8), (int, True), (int, ['a', 'b', 'c']), (float, None), (float, 'value'), (float, 1), (float, True), (float, ['a', 'b', 'c']), (bool, None), (bool, 'value'), (bool, 1), (bool, 1.8), (bool, ['a', 'b', 'c']), (list, None), (list, 'value'), (list, 1), (list, 1.8), (list, True), ] ) def test_validate_type_failure(self, field_type, value): """Validate an Option, where type validation fails""" opt = scheme.Option('test-option', field_type=field_type) with pytest.raises(errors.SchemeValidationError): opt.validate(value) @pytest.mark.parametrize( 'choices,value', [ (['one', 'two'], 'one'), # choices can be lists (('one', 'two'), 'one'), # choices can be tuples ([1, 2, 3], 1), ((1, 2, 3), 1), ([None], None), ((None,), None), ([1.21, 1.22, 1.23], 1.23), ((1.21, 1.22, 1.23), 1.23), ([True, False], False), ((True, False), False) ] ) def test_validate_choices_ok(self, choices, value): """Validate an Option, where choice validation succeeds""" opt = scheme.Option('test-option', choices=choices) opt.validate(value) @pytest.mark.parametrize( 'choices,value', [ (['one', 'two'], 'three'), ([1, 2, 3], 0), ([], None), ([0.2, 0.3, 0.4], 0.1), ([False], True) ] ) def test_validate_choices_failure(self, choices, value): """Validate an Option, where choice validation succeeds""" opt = scheme.Option('test-option', choices=choices) with pytest.raises(errors.SchemeValidationError): opt.validate(value) @pytest.mark.parametrize( 'option,value,expected', [ (scheme.Option('foo'), 'foo', 'foo'), (scheme.Option('foo'), 1, 1), (scheme.Option('foo'), None, None), (scheme.Option('foo'), False, False), (scheme.Option('foo', field_type=str), 'foo', 'foo'), (scheme.Option('foo', field_type=str), 1, '1'), (scheme.Option('foo', field_type=int), '1', 1), (scheme.Option('foo', field_type=float), '1', 1.0), (scheme.Option('foo', field_type=float), '1.23', 1.23), (scheme.Option('foo', field_type=bool), 'false', False), (scheme.Option('foo', field_type=bool), 'False', False), (scheme.Option('foo', field_type=bool), 'FALSE', False), (scheme.Option('foo', field_type=bool), 'true', True), (scheme.Option('foo', field_type=bool), 'True', True), (scheme.Option('foo', field_type=bool), 'TRUE', True), ] ) def test_cast(self, option, value, expected): """Cast values to the type set by the Option.""" actual = option.cast(value) assert actual == expected @pytest.mark.parametrize( 'option,value', [ (scheme.Option('foo', field_type=int), 'foo'), (scheme.Option('foo', field_type=list), 'foo'), (scheme.Option('foo', field_type=tuple), 'foo'), ] ) def test_cast_fail(self, option, value): """Cast values to the type set by the Option.""" with pytest.raises(errors.BisonError): option.cast(value) @pytest.mark.parametrize( 'option,prefix,auto_env', [ (scheme.Option('foo'), None, False), (scheme.Option('foo', bind_env=False), None, False), (scheme.Option('foo', bind_env=True), None, False), (scheme.Option('foo', bind_env=True), 'TEST_ENV_', False), (scheme.Option('foo', bind_env='TEST_KEY'), None, False), (scheme.Option('foo', bind_env='TEST_KEY'), 'TEST_ENV_', False), (scheme.Option('foo', bind_env=None), 'TEST_ENV_', False), (scheme.Option('foo', bind_env=None), 'TEST_ENV_', True), (scheme.Option('foo', bind_env=None), None, False), (scheme.Option('foo', bind_env=None), None, True), ] ) def test_parse_env_none(self, option, prefix, auto_env): """Parse environment variables for the Option. All of theses tests should result in None being returned because no environment variables are actually set. """ actual = option.parse_env(prefix=prefix, auto_env=auto_env) assert actual is None @pytest.mark.parametrize( 'option,key,prefix,auto_env,expected', [ (scheme.Option('foo', bind_env=True), 'foo', 'TEST_ENV_', False, 'bar'), (scheme.Option('foo', bind_env=True), 'foo', 'TEST_ENV_', True, 'bar'), (scheme.Option('foo', bind_env='TEST_ENV_FOO'), 'foo', 'TEST_ENV_', False, 'bar'), (scheme.Option('foo', bind_env='TEST_ENV_FOO'), 'foo', 'TEST_ENV_', True, 'bar'), (scheme.Option('foo', bind_env='TEST_ENV_FOO'), 'foo', None, False, 'bar'), (scheme.Option('foo', bind_env='TEST_ENV_FOO'), 'foo', None, True, 'bar'), (scheme.Option('foo', bind_env=None), 'foo', 'TEST_ENV_', True, 'bar'), (scheme.Option('foo', bind_env=None), 'nested.env.key', 'TEST_ENV_', True, 'test'), ] ) def test_parse_env_ok(self, option, key, prefix, auto_env, expected, with_env): """Parse environment variables for the Option.""" actual = option.parse_env(key=key, prefix=prefix, auto_env=auto_env) assert actual == expected class TestDictOption: """Tests for the `DictOption` class.""" def test_init_simple(self): """Initialize a DictOption.""" opt = scheme.DictOption('test-opt', None) assert opt.name == 'test-opt' assert type(opt.default) == scheme.NoDefault assert opt.scheme is None assert opt.bind_env is False def test_init_full(self): """Initialize a DictOption.""" opt = scheme.DictOption( name='test-opt', scheme=scheme.Scheme(), default='foo', bind_env=True ) assert opt.name == 'test-opt' assert type(opt.default) != scheme.NoDefault assert opt.default == 'foo' assert isinstance(opt.scheme, scheme.Scheme) assert opt.bind_env is True @pytest.mark.parametrize( 'value', [ 'foo', 1, 1.234, False, True, None, [1, 2, 3], ['a', 'b', 'c'], [{'a': 1}, {'b': 2}], ('foo', 'bar'), {1, 2, 3} ] ) def test_validate_bad_data(self, value): """Validate a DictOption where the given value is not a dict""" opt = scheme.DictOption('test-opt', scheme.Scheme()) with pytest.raises(errors.SchemeValidationError): opt.validate(value) def test_validate_no_scheme(self): """Validate a DictOption with no scheme""" opt = scheme.DictOption('test-opt', None) opt.validate({'foo': 'bar'}) def test_validate_with_scheme(self): """Validate a DictOption with a scheme""" opt = scheme.DictOption('test-opt', scheme.Scheme( scheme.Option('foo', field_type=str) )) opt.validate({'foo': 'bar'}) @pytest.mark.parametrize( 'option,prefix,auto_env', [ (scheme.DictOption('foo', scheme=None, bind_env=False), None, False), (scheme.DictOption('foo', scheme=None, bind_env=False), None, True), (scheme.DictOption('foo', scheme=None, bind_env=False), 'TEST_ENV', False), (scheme.DictOption('foo', scheme=None, bind_env=False), 'TEST_ENV', True), (scheme.DictOption('foo', scheme=None, bind_env=True), None, False), (scheme.DictOption('foo', scheme=None, bind_env=True), None, True), (scheme.DictOption('foo', scheme=None, bind_env=True), 'TEST_ENV', False), (scheme.DictOption('foo', scheme=None, bind_env=True), 'TEST_ENV', True), ] ) def test_parse_env_none(self, option, prefix, auto_env): """Parse environment variables for the DictOption. All of theses tests should result in None being returned because no environment variables are actually set. """ actual = option.parse_env(prefix=prefix, auto_env=auto_env) assert actual is None @pytest.mark.parametrize( 'option,key,prefix,auto_env,expected', [ (scheme.DictOption('foo', scheme=None, bind_env=True), 'foo', 'TEST_ENV_', False, None), (scheme.DictOption('foo', scheme=None, bind_env=True), 'foo', 'TEST_ENV_', True, None), (scheme.DictOption('foo', scheme=None, bind_env=True), 'nested', 'TEST_ENV_', False, {'env': {'key': 'test'}}), (scheme.DictOption('foo', scheme=None, bind_env=True), 'nested', 'TEST_ENV_', True, {'env': {'key': 'test'}}), (scheme.DictOption('foo', scheme=None, bind_env=True), 'nested.env', 'TEST_ENV_', False, {'key': 'test'}), (scheme.DictOption('foo', scheme=None, bind_env=True), 'nested.env', 'TEST_ENV_', True, {'key': 'test'}), ] ) def test_parse_env_ok(self, option, key, prefix, auto_env, expected, with_env): """Parse environment variables for the DictOption.""" actual = option.parse_env(key=key, prefix=prefix, auto_env=auto_env) assert actual == expected class TestListOption: """Tests for the `ListOption` class.""" def test_init_simple(self): """Initialize a ListOption.""" opt = scheme.ListOption('test-opt') assert opt.name == 'test-opt' assert type(opt.default) == scheme.NoDefault assert opt.member_type is None assert opt.member_scheme is None assert opt.bind_env is False def test_init_full(self): """Initialize a ListOption.""" opt = scheme.ListOption( name='test-opt', default='foo', member_type=dict, member_scheme=scheme.Scheme(), bind_env=True ) assert opt.name == 'test-opt' assert type(opt.default) != scheme.NoDefault assert opt.default == 'foo' assert opt.member_type == dict assert isinstance(opt.member_scheme, scheme.Scheme) assert opt.bind_env is True @pytest.mark.parametrize( 'value', [ 'foo', 1, 1.234, False, True, None, {'a': 1, 'b': 2}, ('foo', 'bar'), {1, 2, 3} ] ) def test_validate_bad_data(self, value): """Validate when the value is not a list""" opt = scheme.ListOption('test-opt') with pytest.raises(errors.SchemeValidationError): opt.validate(value) def test_validate_member_type_scheme_conflict(self): """Validate the ListOption when both member_type and member_scheme are defined.""" opt = scheme.ListOption( name='test-opt', member_type=int, member_scheme=scheme.Scheme() ) with pytest.raises(errors.SchemeValidationError): opt.validate([1, 2, 3]) @pytest.mark.parametrize( 'member_type,value', [ (str, ['a', 'b', 'c']), (int, [1, 2, 3]), (float, [1.0, 2.0, 3.0]), (bool, [False, False, True]), (tuple, [(1,), (2,), (3,)]), (list, [[1], [2], [3]]), (dict, [{'a': 1, 'b': 2}]) ] ) def test_validate_member_type_ok(self, member_type, value): """Validate the ListOption, where member_type validation succeeds.""" opt = scheme.ListOption('test-opt', member_type=member_type) opt.validate(value) @pytest.mark.parametrize( 'member_type,value', [ (str, ['a', 1]), (str, [1, 2]), (int, [1, 2, '3']), (int, ['foo', 'bar']), (float, [1.0, '2.0', 3.0]), (float, ['foo', 'bar']), (bool, ['False', False, True]), (bool, ['foo', 'bar']), (tuple, [(1,), '(2,)', (3,)]), (tuple, ['']), (list, [[1], (2,), [3]]), (list, ['foo', 'bar']), (dict, [{'a': 1}, {1, 2, 3}]), (dict, ['foo', 'bar']) ] ) def test_validate_member_type_failure(self, member_type, value): """Validate the ListOption, where member_type validation fails.""" opt = scheme.ListOption('test-opt', member_type=member_type) with pytest.raises(errors.SchemeValidationError): opt.validate(value) @pytest.mark.parametrize( 'member_scheme,value', [ # an empty scheme will validate every dict as correct (scheme.Scheme(), [{'foo': 'bar'}]), (scheme.Scheme(), [{1: 3}]), (scheme.Scheme(), [{1.23: 2.31}]), (scheme.Scheme(), [{False: True}]), (scheme.Scheme(), [{None: None}]), (scheme.Scheme(), [{(1, 2): (2, 1)}]), (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': 'bar'}]), (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': 'baz'}]), (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': 'baz'}, {'foo': 'bar'}]) ] ) def test_validate_member_scheme_ok(self, member_scheme, value): """Validate the ListOption, where member_scheme validation succeeds.""" opt = scheme.ListOption('test-opt', member_scheme=member_scheme) opt.validate(value) @pytest.mark.parametrize( 'member_scheme,value', [ (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': 1}]), (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': 1.23}]), (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': False}]), (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': True}]), (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': None}]), (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': (1, 2)}]), (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': ['a', 'b']}]), (scheme.Scheme(scheme.Option('foo', field_type=str)), [{'foo': {'a', 'b'}}]), (scheme.Scheme(scheme.Option('bar', field_type=int)), [{'bar': 'foo'}]), (scheme.Scheme(scheme.Option('bar', field_type=int)), [{'bar': 1.23}]), (scheme.Scheme(scheme.Option('bar', field_type=int)), [{'bar': False}]), (scheme.Scheme(scheme.Option('bar', field_type=int)), [{'bar': True}]), (scheme.Scheme(scheme.Option('bar', field_type=int)), [{'bar': None}]), (scheme.Scheme(scheme.Option('bar', field_type=int)), [{'bar': (1, 2)}]), (scheme.Scheme(scheme.Option('bar', field_type=int)), [{'bar': ['a', 'b']}]), (scheme.Scheme(scheme.Option('bar', field_type=int)), [{'bar': {'a', 'b'}}]) ] ) def test_validate_member_scheme_fail(self, member_scheme, value): """Validate the ListOption, where member_scheme validation fails.""" opt = scheme.ListOption('test-opt', member_scheme=member_scheme) with pytest.raises(errors.SchemeValidationError): opt.validate(value) def test_validate_member_scheme_not_a_scheme(self): """Validate the ListOption, where the member_scheme is not a Scheme.""" opt = scheme.ListOption('test-opt', member_scheme='not-none-or-scheme') with pytest.raises(errors.SchemeValidationError): opt.validate(['a', 'b', 'c']) @pytest.mark.parametrize( 'option,prefix,auto_env', [ (scheme.ListOption('foo', bind_env=False), None, False), (scheme.ListOption('foo', bind_env=False), None, True), (scheme.ListOption('foo', bind_env=False), 'TEST_ENV', False), (scheme.ListOption('foo', bind_env=False), 'TEST_ENV', True), (scheme.ListOption('foo', bind_env=True), None, False), (scheme.ListOption('foo', bind_env=True), None, True), (scheme.ListOption('foo', bind_env=True), 'TEST_ENV', False), (scheme.ListOption('foo', bind_env=True), 'TEST_ENV', True), ] ) def test_parse_env_none(self, option, prefix, auto_env): """Parse environment variables for the ListOption. All of theses tests should result in None being returned because no environment variables are actually set. """ actual = option.parse_env(prefix=prefix, auto_env=auto_env) assert actual is None @pytest.mark.parametrize( 'option,key,prefix,auto_env,expected', [ (scheme.ListOption('foo', bind_env=True), 'foo', 'TEST_ENV_', False, ['bar']), (scheme.ListOption('foo', bind_env=True), 'foo', 'TEST_ENV_', True, ['bar']), (scheme.ListOption('foo', bind_env=True), 'bar.list', 'TEST_ENV_', False, ['a', 'b', 'c']), (scheme.ListOption('foo', bind_env=True), 'bar.list', 'TEST_ENV_', True, ['a', 'b', 'c']), ] ) def test_parse_env_ok(self, option, key, prefix, auto_env, expected, with_env): """Parse environment variables for the ListOption.""" actual = option.parse_env(key=key, prefix=prefix, auto_env=auto_env) assert actual == expected class TestScheme: """Tests for the `Scheme` class.""" def test_empty_init(self): """Initialize a Scheme with no arguments.""" sch = scheme.Scheme() assert len(sch.args) == 0 assert sch._flat is None def test_single_arg_init(self): """Initialize a Scheme with one argument.""" sch = scheme.Scheme( 'item' ) assert len(sch.args) == 1 assert sch._flat is None def test_multi_arg_init(self): """Initialize a Scheme with multiple arguments.""" sch = scheme.Scheme( 'item-1', 'item-2', 'item-3' ) assert len(sch.args) == 3 assert sch._flat is None @pytest.mark.parametrize( 'args,expected', [ ( # args (scheme.Option('foo', default='bar'),), # expected {'foo': 'bar'} ), ( # args ( scheme.Option('foo'), scheme.Option('bar', default='baz'), scheme.ListOption('list', default=['a', 'b']) ), # expected { 'bar': 'baz', 'list': ['a', 'b'] } ), ( # args ( scheme.Option('foo', default='bar'), scheme.DictOption('bar', scheme=None) ), # expected { 'foo': 'bar' } ), ( # args ( scheme.DictOption('foo', scheme=scheme.Scheme(), default={}), scheme.DictOption('bar', scheme=scheme.Scheme( scheme.Option('test', default=True), scheme.Option('data', default=None), scheme.Option('value', default=20), scheme.Option('float', default=10.1010), scheme.Option('no_default'), scheme.DictOption('dct', scheme=scheme.Scheme( scheme.Option('nested', default='here') )) )) ), # expected { 'foo': {}, 'bar': { 'test': True, 'data': None, 'value': 20, 'float': 10.1010, 'dct': { 'nested': 'here' } } } ), ] ) def test_build_defaults(self, args, expected): """Build a defaults dict from a Scheme.""" sch = scheme.Scheme(*args) defaults = sch.build_defaults() assert defaults == expected @pytest.mark.parametrize( 'args', [ ('a', 'b'), # not an instance of _BaseOpt ] ) def test_build_defaults_failure(self, args): """Build a defaults dict from a Scheme with bad data.""" sch = scheme.Scheme(*args) with pytest.raises(errors.InvalidSchemeError): sch.build_defaults() @pytest.mark.parametrize( 'args,expected', [ ( (scheme.Option('foo'),), ['foo'] ), ( (scheme.Option('foo'), scheme.Option('bar')), ['foo', 'bar'] ), ( (scheme.Option('foo'), scheme.DictOption('bar', scheme=None)), ['foo', 'bar'] ), ( ( scheme.Option('foo'), scheme.DictOption('bar', scheme=scheme.Scheme( scheme.Option('test'), scheme.DictOption('dct', scheme=scheme.Scheme( scheme.Option('nested') )), scheme.ListOption('list') )) ), ['foo', 'bar', 'bar.test', 'bar.dct', 'bar.list', 'bar.dct.nested'] ) ] ) def test_flatten(self, args, expected): """Flatten a Scheme.""" sch = scheme.Scheme(*args) flattened = sch.flatten() assert len(flattened) == len(expected) for key in expected: assert key in flattened @pytest.mark.parametrize( 'args,value', [ ( # option exists in config (scheme.Option('foo', default='bar', field_type=str),), {'foo': 'baz'} ), ( # option does not exist in config, but has default (scheme.Option('foo', default='bar', field_type=str),), {} ), ( # multiple args ( scheme.Option('foo', field_type=str), scheme.Option('bar', field_type=int), scheme.Option('baz', choices=['test']) ), {'foo': 'a', 'bar': 1, 'baz': 'test'} ) ] ) def test_validate_ok(self, args, value): """Validate a Scheme successfully.""" sch = scheme.Scheme(*args) sch.validate(value) @pytest.mark.parametrize( 'args,value', [ ( # option does not exist in config, no default (scheme.Option('foo', field_type=str),), {} ), ( # option exists in config, fails validation (scheme.Option('foo', default='bar', field_type=str),), {'foo': 1} ), ( # multiple args, one fails validation ( scheme.Option('foo', field_type=str), scheme.Option('bar', field_type=int), scheme.Option('baz', choices=['test']) ), {'foo': 'a', 'bar': 1, 'baz': 'something'} ) ] ) def test_validate_failure(self, args, value): """Validate a Scheme unsuccessfully.""" sch = scheme.Scheme(*args) with pytest.raises(errors.SchemeValidationError): sch.validate(value) @pytest.mark.parametrize( 'value', [ 'foo', 1, 1.23, ['a', 'b', 'c'], {'a', 'b', 'c'}, ('a', 'b', 'c'), None, False, True ] ) def test_validate_failure_bad_config(self, value): """Validate a Scheme where the given config is not a dict.""" sch = scheme.Scheme() with pytest.raises(errors.SchemeValidationError): sch.validate(value)