class TestSystem(object):
@pytest.fixture
def default_system(self, command1):
return System(name='foo',
version='1.0.0',
instances=[Instance(name='foo')],
commands=[command1])
def test_get_command_by_name_found(self, default_system):
mock_name = PropertyMock(return_value='name')
command = Mock()
type(command).name = mock_name
default_system.commands.append(command)
assert default_system.get_command_by_name('name') == command
def test_get_command_by_name_none(self, default_system):
mock_name = PropertyMock(return_value='foo')
command = Mock()
type(command).name = mock_name
default_system.commands.append(command)
assert default_system.get_command_by_name('name') is None
def test_has_instance(self, default_system):
assert default_system.has_instance('foo')
assert not default_system.has_instance('bar')
def test_instance_names(self, default_system):
assert default_system.instance_names == ['foo']
def test_get_instance(self, default_system):
assert default_system.get_instance('foo').name == 'foo'
assert default_system.get_instance('bar') is None
@pytest.mark.parametrize('commands', [
([Command(name='bar')]),
([Command(name='foo', parameters=[Parameter(key='blah')])]),
([Command(name='bar'), Command(name='baz')]),
])
def test_has_different_commands(self, default_system, commands):
assert default_system.has_different_commands(commands)
@pytest.mark.parametrize('command', [
(Command(name='foo', parameters=[Parameter(key='key1', type="String")
])),
(Command(name='foo',
description='Different description',
parameters=[Parameter(key='key1', type="String")])),
])
def test_has_same_commands(self, default_system, command):
assert not default_system.has_different_commands([command])
def test_str(self, default_system):
assert str(default_system) == 'foo-1.0.0'
def test_repr(self, default_system):
assert 'foo' in repr(default_system)
assert '1.0.0' in repr(default_system)
def key_parameter(parameter_dict, bg_choices):
"""Parameter with a different key"""
dict_copy = copy.deepcopy(parameter_dict)
dict_copy["parameters"] = [Parameter(**dict_copy["parameters"][0])]
dict_copy["choices"] = bg_choices
# Change key
dict_copy["key"] = "key1"
return Parameter(**dict_copy)
def choices_parameter(parameter_dict, choices_dict):
"""Parameter with a different choices"""
# Change the choices value
choices_copy = copy.deepcopy(choices_dict)
choices_copy["value"] = ["choiceA", "choiceB", "choiceC"]
dict_copy = copy.deepcopy(parameter_dict)
dict_copy["parameters"] = [Parameter(**dict_copy["parameters"][0])]
dict_copy["choices"] = Choices(**choices_copy)
return Parameter(**dict_copy)
def test_validate_regex_nullable(self, validator):
req = Request(system="foo", command="command1", parameters={"key1": None})
command_parameter = Parameter(
key="key1", multi=False, type="String", regex=r"^Hi.*", nullable=True
)
command = Command("test", parameters=[command_parameter])
validator.get_and_validate_parameters(req, command)
def test_validate_minimum_non_sequence(self, validator):
req = Request(system="foo", command="command1", parameters={"key1": 5})
command_parameter = Parameter(
key="key1", multi=False, type="Integer", optional=False, minimum=3
)
command = Command("test", parameters=[command_parameter])
validator.get_and_validate_parameters(req, command)
command_parameter = Parameter(
key="key1", multi=False, type="Integer", optional=False, minimum=10
)
command = Command("test", parameters=[command_parameter])
with pytest.raises(ModelValidationError):
validator.get_and_validate_parameters(req, command)
def test_validate_command_choices_dictionary_list_response(
self, monkeypatch, validator
):
process_mock = _process_mock(monkeypatch, return_value='[{"value": "value"}]')
request = Request(
system="foo",
command="command1",
parameters={"key1": "value"},
system_version="0.0.1",
instance_name="instance_name",
)
command = Mock(
parameters=[
Parameter(
key="key1",
type="String",
choices=Choices(type="command", value="command_name", strict=True),
optional=False,
)
]
)
validator.get_and_validate_parameters(request, command)
choices_request = process_mock.call_args[0][0]
assert choices_request.command == "command_name"
assert choices_request.system == "foo"
assert choices_request.system_version == "0.0.1"
assert choices_request.instance_name == "instance_name"
def test_model_and_parameters(self, outer, inner):
"""This is not allowed"""
with pytest.raises(PluginParamError):
_initialize_parameter(
Parameter(key="nested",
model=outer,
parameters=inner.parameters))
def test_nested_model_list(self, nested_1, nested_2):
class MyModel(object):
parameters = [
Parameter(
key="key1",
multi=False,
display_name="x",
optional=True,
description="key1",
parameters=[nested_1, nested_2],
default="xval",
)
]
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
p = _initialize_parameter(
Parameter(key="nested", model=MyModel))
# There are 2 nested model class objects so there should be 2 warnings
assert len(w) == 2
assert w[0].category == DeprecationWarning
assert w[1].category == DeprecationWarning
self._assert_correct(p)
def test_mixed_list(self, nested_1, nested_2):
class MyModel(object):
parameters = [
Parameter(
key="key1",
multi=False,
display_name="x",
optional=True,
description="key1",
parameters=nested_1.parameters + [nested_2],
default="xval",
)
]
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
p = _initialize_parameter(
Parameter(key="nested", model=MyModel))
# Only 1 nested model class object this time
assert len(w) == 1
assert w[0].category == DeprecationWarning
self._assert_correct(p)
def test_validate_command_choices_bad_value_type(self, monkeypatch, validator):
_process_mock(monkeypatch, return_value='["value"]')
request = Request(
system="foo",
command="command1",
parameters={"key1": "value"},
system_version="0.0.1",
instance_name="instance_name",
)
command = Mock(
parameters=[
Parameter(
key="key1",
type="String",
optional=False,
choices=Choices(
type="command",
value=1,
strict=True,
),
)
]
)
with pytest.raises(ModelValidationError):
validator.get_and_validate_parameters(request, command)
def test_is_kwarg(self, param_definition):
@parameter(is_kwarg=True, **param_definition)
def cmd(_, **kwargs):
return kwargs
param = cmd._command.get_parameter_by_key('foo')
assert_parameter_equal(param, Parameter(**param_definition))
def test_validate_regex(self, validator):
req = Request(
system="foo", command="command1", parameters={"key1": "Hi World!"}
)
command_parameter = Parameter(
key="key1", multi=False, type="String", optional=False, regex=r"^Hi.*"
)
command = Command("test", parameters=[command_parameter])
validator.get_and_validate_parameters(req, command)
command_parameter = Parameter(
key="key1", multi=False, type="String", optional=False, regex=r"^Hello.*"
)
command = Command("test", parameters=[command_parameter])
with pytest.raises(ModelValidationError):
validator.get_and_validate_parameters(req, command)
def test_validate_maximum_sequence(self, validator):
req = BrewtilsRequest(
system="foo", command="command1", parameters={"key1": "value"}
)
command_parameter = Parameter(
key="key1", multi=False, type="String", optional=False, maximum=10
)
command = Command("test", parameters=[command_parameter])
validator.get_and_validate_parameters(req, command)
command_parameter = Parameter(
key="key1", multi=False, type="String", optional=False, maximum=3
)
command = Command("test", parameters=[command_parameter])
with pytest.raises(ModelValidationError):
validator.get_and_validate_parameters(req, command)
def param_1(self):
return Parameter(
key="key1",
type="Integer",
multi=False,
display_name="x",
optional=True,
default=1,
description="key1",
)
class MyNestedModel(object):
my_nested_string = Parameter(
key="my_nested_string",
multi=False,
display_name="My Nested String",
optional=False,
type="String",
description="Just Testing a String",
)
my_nested_int = Parameter(
key="my_nested_int",
multi=False,
display_name="My Nested Int",
optional=False,
type="Integer",
description="Just Testing an Int",
)
parameters = [my_nested_string, my_nested_int]
def param_2(self):
return Parameter(
key="key2",
type="String",
multi=False,
display_name="y",
optional=False,
default="100",
description="key2",
)
def param_1(self):
return Parameter(
key='key1',
type='Integer',
multi=False,
display_name='x',
optional=True,
default=1,
description='key1',
)
def test_update_and_validate_parameter_extract_parameter_nullable_no_default(
self, validator
):
req = Request(system="foo", command="command1", parameters={})
command_parameter = Parameter(
key="key1", multi=False, nullable=True, default=None, optional=True
)
command = Mock(parameters=[command_parameter])
validated_parameters = validator.get_and_validate_parameters(req, command)
assert validated_parameters["key1"] is None
def param_2(self):
return Parameter(
key='key2',
type='String',
multi=False,
display_name='y',
optional=False,
default='100',
description='key2',
)
class MyModel:
parameters = [
Parameter(key='key1',
multi=False,
display_name='x',
optional=True,
description='key1',
parameters=[MyNestedModel],
default="xval")
]
class MyNestedModel:
parameters = [
Parameter(key='key2',
type='String',
multi=False,
display_name='y',
optional=False,
default='100',
description='key2')
]
def test_update_and_validate_parameter_extract_parameter_optional_no_default(
self, validator
):
req = Request(system="foo", command="command1", parameters={})
command_parameter = Parameter(
key="key1", multi=False, optional=True, default=None
)
command = Mock(parameters=[command_parameter])
with pytest.raises(ModelValidationError):
validator.get_and_validate_parameters(req, command)
class MyListModel(object):
my_choices_string = Parameter(
key="my_choices_string",
type="String",
multi=False,
display_name="Choices!",
optional=False,
description="This has some choices",
choices=["a", "b", "c"],
)
my_list_of_strings = Parameter(
key="my_list_of_strings",
multi=True,
display_name="My List of Strings",
optional=False,
type="String",
description="Just testing a list of Strings.",
)
parameters = [my_choices_string, my_list_of_strings]
class MyModel(object):
parameters = [
Parameter(
key="key1",
multi=False,
display_name="x",
optional=True,
description="key1",
parameters=nested_1.parameters + [nested_2],
default="xval",
)
]
class MyModelWithDefaults(object):
my_foo = Parameter(
key="my_foo",
multi=False,
display_name="Foo",
optional=False,
type="String",
description="Foo With Defaults.",
default="defaultFooFromModel",
)
my_bar = Parameter(
key="my_bar",
multi=False,
display_name="Bar",
optional=False,
type="String",
description="Bar With Defaults.",
default="defaultBarFromModel",
)
parameters = [my_foo, my_bar]
class MyNestedModel:
parameters = [
Parameter(
key="key2",
type="String",
multi=False,
display_name="y",
optional=False,
default="100",
description="key2",
)
]
class MyModel(object):
parameters = [
Parameter(
key="key1",
multi=False,
display_name="x",
optional=True,
description="key1",
parameters=["Not valid!"],
default="xval",
)
]
class MyModel:
parameters = [
Parameter(
key="key1",
multi=False,
display_name="x",
optional=True,
description="key1",
parameters=[MyNestedModel],
default="xval",
)
]
class NestedModel2(object):
parameters = [
Parameter(
key="key3",
type="String",
multi=False,
display_name="z",
optional=False,
default="101",
description="key3",
)
]
def test_validate_maximum_nullable(self, validator):
req = Request(system="foo", command="command1", parameters={"key1": None})
command_parameter = Parameter(
key="key1",
multi=False,
type="Integer",
optional=False,
minimum=3,
nullable=True,
)
command = Command("test", parameters=[command_parameter])
validator.get_and_validate_parameters(req, command)