def test_system_exists(self, plugin, bm_client, bg_system, bg_instance,
current_commands):
bg_system.commands = [Command("test")]
bm_client.update_system.return_value = bg_system
existing_system = System(
id="id",
name="test_system",
version="0.0.1",
instances=[bg_instance],
commands=current_commands,
metadata={"foo": "bar"},
)
bm_client.find_unique_system.return_value = existing_system
plugin._initialize()
bm_client.initialize_instance.assert_called_once_with(bg_instance.id)
bm_client.update_system.assert_called_once_with(
existing_system.id,
new_commands=bg_system.commands,
metadata=bg_system.metadata,
description=bg_system.description,
icon_name=bg_system.icon_name,
display_name=bg_system.display_name,
)
assert bm_client.create_system.called is False
assert bm_client.create_system.return_value == plugin.system
assert bm_client.initialize_instance.return_value == plugin.instance
def test_system_exists(self, plugin, ez_client, bg_system, bg_instance,
current_commands):
existing_system = System(
id="id",
name="test_system",
version="0.0.1",
instances=[bg_instance],
commands=current_commands,
metadata={"foo": "bar"},
template=None,
)
ez_client.find_unique_system.return_value = existing_system
bg_system.commands = [Command("test")]
ez_client.update_system.return_value = bg_system
plugin._initialize_system()
assert ez_client.create_system.called is False
ez_client.update_system.assert_called_once_with(
existing_system.id,
new_commands=bg_system.commands,
metadata=bg_system.metadata,
description=bg_system.description,
icon_name=bg_system.icon_name,
display_name=bg_system.display_name,
template="<html>template</html>",
)
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_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 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)
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 setUp(self):
self.app = brew_view.app.test_client()
self.default_instance = Instance(name='default', status='RUNNING')
self.default_command = Command(id='54ac18f778c4b57e963f3c18',
name='command',
description='foo')
self.default_system = System(id='54ac18f778c4b57e963f3c18',
name='default_system',
version='1.0.0',
instances=[self.default_instance],
commands=[self.default_command])
self.client_mock = Mock(name='client_mock')
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False))
def _generate_command_from_function(func):
"""Generates a Command from a function. Uses first line of pydoc as the description."""
# Required for Python 2/3 compatibility
if hasattr(func, "func_name"):
command_name = func.func_name
else:
command_name = func.__name__
# Required for Python 2/3 compatibility
if hasattr(func, "func_doc"):
docstring = func.func_doc
else:
docstring = func.__doc__
return Command(name=command_name,
description=docstring.split('\n')[0] if docstring else None,
parameters=_generate_params_from_function(func))
def setUp(self):
self.app = brew_view.app.test_client()
self.default_instance = Instance(name="default", status="RUNNING")
self.default_command = Command(
id="54ac18f778c4b57e963f3c18", name="command", description="foo"
)
self.default_system = System(
id="54ac18f778c4b57e963f3c18",
name="default_system",
version="1.0.0",
instances=[self.default_instance],
commands=[self.default_command],
)
self.client_mock = Mock(name="client_mock")
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False),
)
def test_initialize_system_update_metadata(self):
self.system.commands = [Command('test')]
self.bm_client_mock.update_system.return_value = self.system
existing_system = System(id='id', name='test_system', version='1.0.0',
instances=[self.instance],
metadata={})
self.bm_client_mock.find_unique_system.return_value = existing_system
self.plugin._initialize()
self.assertFalse(self.bm_client_mock.create_system.called)
self.bm_client_mock.update_system.assert_called_once_with(self.instance.id,
new_commands=self.system.commands,
description=None,
display_name=None,
icon_name=None,
metadata={"foo": "bar"})
self.bm_client_mock.initialize_instance.assert_called_once_with(self.instance.id)
self.assertEqual(self.plugin.system, self.bm_client_mock.create_system.return_value)
self.assertEqual(self.plugin.instance, self.bm_client_mock.initialize_instance.return_value)
def test_positional_only(self):
"""This is invalid syntax on Python < 3.8 so we have to wrap it in exec"""
import textwrap
exec_locals = {}
class_dec = textwrap.dedent("""
class Tester(object):
def c(self, foo, /):
pass
""")
# Black doesn't handle this well - because we run in 2.7 mode it wants to
# put a space after exec, but then it complains about the space after exec.
# fmt: off
exec(class_dec, globals(), exec_locals)
# fmt: on
with pytest.raises(PluginParamError):
_signature_validate(Command(parameters=[Parameter(key="foo")]),
exec_locals["Tester"].c) # noqa
def _initialize_command(method):
# type: (MethodType) -> Command
"""Initialize a Command
This takes care of ensuring a Command object is in the correct form. Things like:
- Assigning the name from the method name
- Pulling the description from the method docstring, if necessary
- Resolving display modifiers (schema, form, template)
Args:
method: The method with the Command to initialize
Returns:
The initialized Command
"""
cmd = getattr(method, "_command", Command())
cmd.name = _method_name(method)
cmd.description = cmd.description or _method_docstring(method)
try:
base_dir = os.path.dirname(inspect.getfile(method))
cmd.schema = resolve_schema(cmd.schema, base_dir=base_dir)
cmd.form = resolve_form(cmd.form, base_dir=base_dir)
cmd.template = resolve_template(cmd.template, base_dir=base_dir)
except PluginParamError as ex:
six.raise_from(
PluginParamError("Error initializing command '%s': %s" %
(cmd.name, ex)),
ex,
)
return cmd
def test_kwarg(self, cmd_kwargs):
_signature_validate(
Command(parameters=[Parameter(key="foo", is_kwarg=True)]),
cmd_kwargs)
def test_positional(self, cmd):
_signature_validate(Command(parameters=[Parameter(key="foo")]),
cmd)
def test_no_kwargs_in_signature(self, cmd):
with pytest.raises(PluginParamError):
_signature_validate(
Command(
parameters=[Parameter(key="extra", is_kwarg=True)]),
cmd)
def bg_command(command_dict, bg_parameter):
"""Use the bg_command fixture instead."""
dict_copy = copy.deepcopy(command_dict)
dict_copy['parameters'] = [bg_parameter]
dict_copy['system'] = System(id=system_id)
return Command(**dict_copy)
def test_mismatch_is_kwarg_false(self, cmd_kwargs):
with pytest.raises(PluginParamError):
_signature_validate(
Command(parameters=[Parameter(key="foo", is_kwarg=False)]),
cmd_kwargs,
)
def test_has_different_parameters_different_length(self):
c = Command(name="foo", parameters=[Parameter(key="key1")])
assert c.has_different_parameters(
[Parameter(key="key1"),
Parameter(key="key2")])
def test_has_different_parameters(self, p1, p2):
assert Command(parameters=[p1]).has_different_parameters([p2])
def command1(param1):
return Command(name="foo", description="bar", parameters=[param1])
def test_get_parameter_by_key(self, parameter, expected):
command = Command(name="foo", parameters=[parameter])
assert command.get_parameter_by_key("key1") == expected
def __str__(self):
return BrewtilsCommand.__str__(self)
class TestInitialize(object):
def test_new_system(self, plugin, bm_client, bg_system, bg_instance):
bm_client.find_unique_system.return_value = None
plugin._initialize()
bm_client.initialize_instance.assert_called_once_with(bg_instance.id)
bm_client.create_system.assert_called_once_with(bg_system)
assert bm_client.update_system.called is False
assert bm_client.create_system.return_value == plugin.system
assert bm_client.initialize_instance.return_value == plugin.instance
@pytest.mark.parametrize("current_commands",
[[], [Command("test")], [Command("other_test")]])
def test_system_exists(self, plugin, bm_client, bg_system, bg_instance,
current_commands):
bg_system.commands = [Command("test")]
bm_client.update_system.return_value = bg_system
existing_system = System(
id="id",
name="test_system",
version="0.0.1",
instances=[bg_instance],
commands=current_commands,
metadata={"foo": "bar"},
)
bm_client.find_unique_system.return_value = existing_system
plugin._initialize()
bm_client.initialize_instance.assert_called_once_with(bg_instance.id)
bm_client.update_system.assert_called_once_with(
existing_system.id,
new_commands=bg_system.commands,
metadata=bg_system.metadata,
description=bg_system.description,
icon_name=bg_system.icon_name,
display_name=bg_system.display_name,
)
assert bm_client.create_system.called is False
assert bm_client.create_system.return_value == plugin.system
assert bm_client.initialize_instance.return_value == plugin.instance
def test_new_instance(self, plugin, bm_client, bg_system, bg_instance):
plugin.instance_name = "new_instance"
existing_system = System(
id="id",
name="test_system",
version="0.0.1",
instances=[bg_instance],
max_instances=2,
metadata={"foo": "bar"},
)
bm_client.find_unique_system.return_value = existing_system
plugin._initialize()
assert 2 == len(existing_system.instances)
assert bm_client.create_system.called is True
assert bm_client.update_system.called is True
def test_new_instance_maximum(self, plugin, bm_client, bg_system):
plugin.instance_name = "new_instance"
bm_client.find_unique_system.return_value = bg_system
with pytest.raises(PluginValidationError):
plugin._initialize()
def test_unregistered_instance(self, plugin, bm_client, bg_system):
bg_system.has_instance = Mock(return_value=False)
bm_client.find_unique_system.return_value = None
with pytest.raises(PluginValidationError):
plugin._initialize()
def test_str(self):
assert "foo" == str(Command(name="foo"))
def test_has_same_parameters(self, p1, p2):
assert not Command(parameters=p1).has_different_parameters(p2)
def __repr__(self):
return BrewtilsCommand.__repr__(self)
def test_repr(self):
assert "<Command: foo>" == repr(Command(name="foo"))
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)