def test_sls_print(self, mocker: MockerFixture,
runway_context: MockRunwayContext,
tmp_path: Path) -> None:
"""Test sls_print."""
# pylint: disable=no-member
expected_dict = {"status": "success"}
mock_check_output = MagicMock(
return_value=yaml.safe_dump(expected_dict))
mocker.patch.object(Serverless, "gen_cmd",
MagicMock(return_value=["print"]))
mocker.patch.object(Serverless, "npm_install", MagicMock())
mocker.patch("subprocess.check_output", mock_check_output)
obj = Serverless(runway_context, module_root=tmp_path)
assert obj.sls_print() == expected_dict
obj.npm_install.assert_called_once()
mock_check_output.assert_called_once_with(
["print"],
env={
"SLS_DEPRECATION_DISABLE": "*",
**runway_context.env.vars
})
obj.gen_cmd.assert_called_once_with("print",
args_list=["--format", "yaml"])
obj.gen_cmd.reset_mock()
assert (obj.sls_print(item_path="something.status",
skip_install=True) == expected_dict)
obj.npm_install.assert_called_once()
obj.gen_cmd.assert_called_once_with(
"print",
args_list=["--format", "yaml", "--path", "something.status"])
def test_gen_cmd(self, mock_cmd, command, monkeypatch, runway_context,
tmp_path):
"""Test gen_cmd."""
# pylint: disable=no-member
monkeypatch.setattr(Serverless, 'log_npm_command', MagicMock())
monkeypatch.setattr(runway_context, 'no_color', False)
mock_cmd.return_value = ['success']
obj = Serverless(runway_context, tmp_path,
{'options': {
'args': ['--config', 'test']
}})
expected_opts = [
command, '--region', runway_context.env_region, '--stage',
runway_context.env_name, '--config', 'test', '--extra-arg'
]
assert obj.gen_cmd(command, args_list=['--extra-arg']) == ['success']
mock_cmd.assert_called_once_with(command='sls',
command_opts=expected_opts,
path=tmp_path)
obj.log_npm_command.assert_called_once_with(['success'])
mock_cmd.reset_mock()
obj.context.env_vars['CI'] = '1'
monkeypatch.setattr(runway_context, 'no_color', True)
expected_opts.append('--no-color')
if command not in ['remove', 'print']:
expected_opts.append('--conceal')
assert obj.gen_cmd(command, args_list=['--extra-arg']) == ['success']
mock_cmd.assert_called_once_with(command='sls',
command_opts=expected_opts,
path=tmp_path)
def test_sls_print(self, monkeypatch, runway_context):
"""Test sls_print."""
# pylint: disable=no-member
expected_dict = {"status": "success"}
mock_check_output = MagicMock(
return_value=yaml.safe_dump(expected_dict))
monkeypatch.setattr(Serverless, "gen_cmd",
MagicMock(return_value=["print"]))
monkeypatch.setattr(Serverless, "npm_install", MagicMock())
monkeypatch.setattr("subprocess.check_output", mock_check_output)
obj = Serverless(runway_context, "./tests")
assert obj.sls_print() == expected_dict
obj.npm_install.assert_called_once()
mock_check_output.assert_called_once_with(["print"],
env=runway_context.env_vars)
obj.gen_cmd.assert_called_once_with("print",
args_list=["--format", "yaml"])
obj.gen_cmd.reset_mock()
assert (obj.sls_print(item_path="something.status",
skip_install=True) == expected_dict)
obj.npm_install.assert_called_once()
obj.gen_cmd.assert_called_once_with(
"print",
args_list=["--format", "yaml", "--path", "something.status"])
def test_sls_print(self, monkeypatch, runway_context):
"""Test sls_print."""
# pylint: disable=no-member
expected_dict = {'status': 'success'}
mock_check_output = MagicMock(
return_value=yaml.safe_dump(expected_dict))
monkeypatch.setattr(Serverless, 'gen_cmd',
MagicMock(return_value=['print']))
monkeypatch.setattr(Serverless, 'npm_install', MagicMock())
monkeypatch.setattr('subprocess.check_output', mock_check_output)
obj = Serverless(runway_context, './tests')
assert obj.sls_print() == expected_dict
obj.npm_install.assert_called_once()
mock_check_output.assert_called_once_with(['print'],
env=runway_context.env_vars)
obj.gen_cmd.assert_called_once_with('print',
args_list=['--format', 'yaml'])
obj.gen_cmd.reset_mock()
assert obj.sls_print(item_path='something.status',
skip_install=True) == expected_dict
obj.npm_install.assert_called_once()
obj.gen_cmd.assert_called_once_with(
'print',
args_list=['--format', 'yaml', '--path', 'something.status'])
def test_plan(self, caplog, runway_context):
"""Test plan."""
caplog.set_level(logging.INFO, logger='runway')
obj = Serverless(runway_context, './tests')
assert not obj.plan()
assert ['Planning not currently supported for Serverless'] == \
caplog.messages
def test_plan(self, caplog, runway_context):
"""Test plan."""
caplog.set_level(logging.INFO, logger="runway")
obj = Serverless(runway_context, "./tests")
assert not obj.plan()
assert ["tests:plan not currently supported for Serverless"
] == caplog.messages
def test_init(
self,
caplog: LogCaptureFixture,
runway_context: MockRunwayContext,
tmp_path: Path,
) -> None:
"""Test init."""
caplog.set_level(logging.WARNING, logger=MODULE)
obj = Serverless(runway_context, module_root=tmp_path)
assert not obj.init()
assert (f"init not currently supported for {Serverless.__name__}"
in caplog.messages)
def test_plan(
self,
caplog: LogCaptureFixture,
runway_context: MockRunwayContext,
tmp_path: Path,
) -> None:
"""Test plan."""
caplog.set_level(logging.INFO, logger="runway")
obj = Serverless(runway_context, module_root=tmp_path)
assert not obj.plan()
assert [
f"{tmp_path.name}:plan not currently supported for Serverless"
] == caplog.messages
def test_sls_remove(self, monkeypatch, runway_context):
"""Test sls_remove."""
# pylint: disable=no-member
# TODO use pytest-subprocess for when dropping python 2
sls_error = [
" Serverless Error ---------------------------------------",
"",
" Stack 'test-stack' does not exist",
"",
" Get Support --------------------------------------------",
" Docs: docs.serverless.com",
" Bugs: github.com/serverless/serverless/issues",
" Issues: forum.serverless.com",
]
mock_popen = MagicMock(
return_value=MockProcess(returncode=0, stdout="success"))
monkeypatch.setattr("subprocess.Popen", mock_popen)
monkeypatch.setattr(Serverless, "gen_cmd",
MagicMock(return_value=["remove"]))
monkeypatch.setattr(Serverless, "npm_install", MagicMock())
obj = Serverless(runway_context, "./tests")
assert not obj.sls_remove()
obj.npm_install.assert_called_once()
obj.gen_cmd.assert_called_once_with("remove")
mock_popen.assert_called_once_with(
["remove"],
bufsize=1,
env=runway_context.env_vars,
stdout=subprocess.PIPE,
universal_newlines=True,
)
mock_popen.return_value.wait.assert_called_once()
mock_popen = MagicMock(
return_value=MockProcess(returncode=1, stdout=sls_error))
monkeypatch.setattr("subprocess.Popen", mock_popen)
assert not obj.sls_remove(skip_install=True)
obj.npm_install.assert_called_once()
mock_popen.return_value.wait.assert_called_once()
sls_error[2] = " Some other error"
mock_popen = MagicMock(
return_value=MockProcess(returncode=1, stdout=sls_error))
monkeypatch.setattr("subprocess.Popen", mock_popen)
with pytest.raises(SystemExit):
assert not obj.sls_remove()
mock_popen.return_value.wait.assert_called_once()
def test_skip(self, caplog, monkeypatch, runway_context, tmp_path):
"""Test skip."""
caplog.set_level(logging.INFO, logger="runway")
obj = Serverless(runway_context, tmp_path)
monkeypatch.setattr(obj, "package_json_missing", lambda: True)
monkeypatch.setattr(obj, "env_file", False)
assert obj.skip
assert [
'{}:skipped; package.json with "serverless" in devDependencies'
" is required for this module type".format(tmp_path.name)
] == caplog.messages
caplog.clear()
monkeypatch.setattr(obj, "package_json_missing", lambda: False)
assert obj.skip
assert [
"{}:skipped; config file for this stage/region not found"
" -- looking for one of: {}".format(
tmp_path.name,
", ".join(gen_sls_config_files(obj.stage, obj.region)))
] == caplog.messages
caplog.clear()
obj.environments = True
assert not obj.skip
obj.environments = False
obj.parameters = True
assert not obj.skip
obj.parameters = False
obj.env_file = True
assert not obj.skip
def test_sls_remove(self, monkeypatch, runway_context):
"""Test sls_remove."""
# pylint: disable=no-member
# TODO use pytest-subprocess for when dropping python 2
sls_error = [
' Serverless Error ---------------------------------------', '',
" Stack 'test-stack' does not exist", '',
' Get Support --------------------------------------------',
' Docs: docs.serverless.com',
' Bugs: github.com/serverless/serverless/issues',
' Issues: forum.serverless.com'
]
mock_popen = MagicMock(
return_value=MockProcess(returncode=0, stdout='success'))
monkeypatch.setattr('subprocess.Popen', mock_popen)
monkeypatch.setattr(Serverless, 'gen_cmd',
MagicMock(return_value=['remove']))
monkeypatch.setattr(Serverless, 'npm_install', MagicMock())
obj = Serverless(runway_context, './tests')
assert not obj.sls_remove()
obj.npm_install.assert_called_once()
obj.gen_cmd.assert_called_once_with('remove')
mock_popen.assert_called_once_with(['remove'],
bufsize=1,
env=runway_context.env_vars,
stdout=subprocess.PIPE,
universal_newlines=True)
mock_popen.return_value.wait.assert_called_once()
mock_popen = MagicMock(
return_value=MockProcess(returncode=1, stdout=sls_error))
monkeypatch.setattr('subprocess.Popen', mock_popen)
assert not obj.sls_remove(skip_install=True)
obj.npm_install.assert_called_once()
mock_popen.return_value.wait.assert_called_once()
sls_error[2] = ' Some other error'
mock_popen = MagicMock(
return_value=MockProcess(returncode=1, stdout=sls_error))
monkeypatch.setattr('subprocess.Popen', mock_popen)
with pytest.raises(SystemExit):
assert not obj.sls_remove()
mock_popen.return_value.wait.assert_called_once()
def test___init__(self, runway_context: MockRunwayContext,
tmp_path: Path) -> None:
"""Test __init__ and the attributes set in __init__."""
obj = Serverless(runway_context,
module_root=tmp_path,
options={"skip_npm_ci": True})
assert isinstance(obj.options, ServerlessOptions)
assert obj.region == runway_context.env.aws_region
assert obj.stage == runway_context.env.name
with pytest.raises(ValidationError):
assert not Serverless(
runway_context,
module_root=tmp_path,
options={"promotezip": {
"invalid": "value"
}},
)
def test_gen_cmd(
self,
command: str,
mocker: MockerFixture,
runway_context: MockRunwayContext,
tmp_path: Path,
) -> None:
"""Test gen_cmd."""
# pylint: disable=no-member
mock_cmd = mocker.patch(
"runway.module.serverless.generate_node_command",
return_value=["success"])
mocker.patch.object(runway_context, "no_color", False)
obj = Serverless(runway_context,
module_root=tmp_path,
options={"args": ["--config", "test"]})
expected_opts = [
command,
"--region",
runway_context.env.aws_region,
"--stage",
runway_context.env.name,
"--config",
"test",
"--extra-arg",
]
assert obj.gen_cmd(command, args_list=["--extra-arg"]) == ["success"]
mock_cmd.assert_called_once_with(command="sls",
command_opts=expected_opts,
logger=obj.logger,
path=tmp_path)
mock_cmd.reset_mock()
obj.ctx.env.vars["CI"] = "1"
mocker.patch.object(runway_context, "no_color", True)
expected_opts.append("--no-color")
if command not in ["remove", "print"]:
expected_opts.append("--conceal")
assert obj.gen_cmd(command, args_list=["--extra-arg"]) == ["success"]
mock_cmd.assert_called_once_with(command="sls",
command_opts=expected_opts,
logger=obj.logger,
path=tmp_path)
def test_env_file(self, runway_context: MockRunwayContext,
tmp_path: Path) -> None:
"""Test env_file.
Testing the precedence of each path, create the files in order from
lowerst to highest. After creating the file, the property's value
is checked then cleared since the value is cached after the first
time it is resolved.
"""
env_dir = tmp_path / "env"
env_dir.mkdir()
obj = Serverless(runway_context, module_root=tmp_path)
assert not obj.env_file
del obj.env_file
config_test_json = tmp_path / "config-test.json"
config_test_json.touch()
assert obj.env_file == config_test_json
del obj.env_file
env_test_json = env_dir / "test.json"
env_test_json.touch()
assert obj.env_file == env_test_json
del obj.env_file
config_test_us_east_1_json = tmp_path / "config-test-us-east-1.json"
config_test_us_east_1_json.touch()
assert obj.env_file == config_test_us_east_1_json
del obj.env_file
env_test_us_east_1_json = env_dir / "test-us-east-1.json"
env_test_us_east_1_json.touch()
assert obj.env_file == env_test_us_east_1_json
del obj.env_file
config_test_yml = tmp_path / "config-test.yml"
config_test_yml.touch()
assert obj.env_file == config_test_yml
del obj.env_file
env_test_yml = env_dir / "test.yml"
env_test_yml.touch()
assert obj.env_file == env_test_yml
del obj.env_file
config_test_us_east_1_yml = tmp_path / "config-test-us-east-1.yml"
config_test_us_east_1_yml.touch()
assert obj.env_file == config_test_us_east_1_yml
del obj.env_file
env_test_us_east_1_yml = env_dir / "test-us-east-1.yml"
env_test_us_east_1_yml.touch()
assert obj.env_file == env_test_us_east_1_yml
del obj.env_file
def test_extend_serverless_yml(
self,
caplog: LogCaptureFixture,
mocker: MockerFixture,
runway_context: MockRunwayContext,
tmp_path: Path,
) -> None:
"""Test extend_serverless_yml."""
# pylint: disable=no-member
mock_merge = mocker.patch("runway.module.serverless.merge_dicts")
caplog.set_level(logging.DEBUG, logger="runway")
mock_func = MagicMock()
mock_merge.return_value = {"key": "val"}
mocker.patch.object(Serverless, "npm_install", MagicMock())
mocker.patch.object(Serverless, "sls_print",
MagicMock(return_value="original"))
mocker.patch.object(ServerlessOptions, "update_args", MagicMock())
options = {"extend_serverless_yml": {"new-key": "val"}}
obj = Serverless(runway_context, module_root=tmp_path, options=options)
assert not obj.extend_serverless_yml(mock_func)
obj.npm_install.assert_called_once()
obj.sls_print.assert_called_once()
mock_merge.assert_called_once_with("original",
options["extend_serverless_yml"])
mock_func.assert_called_once_with(skip_install=True)
obj.options.update_args.assert_called_once_with("config", ANY)
tmp_file = obj.options.update_args.call_args[0][1]
# 'no way to check the prefix since it will be a uuid'
assert tmp_file.endswith(".tmp.serverless.yml")
assert not (tmp_path / tmp_file
).exists(), 'should always be deleted after calling "func"'
caplog.clear()
mocker.patch("pathlib.Path.unlink",
MagicMock(side_effect=OSError("test OSError")))
assert not obj.extend_serverless_yml(mock_func)
assert ("{}:encountered an error when trying to delete the "
"temporary Serverless config".format(tmp_path.name)
in caplog.messages)
def test_sls_remove(
self,
fake_process: FakeProcess,
mocker: MockerFixture,
runway_context: MockRunwayContext,
tmp_path: Path,
) -> None:
"""Test sls_remove."""
# pylint: disable=no-member
sls_error_01: List[Union[bytes, str]] = [
" Serverless Error ---------------------------------------",
"",
" Stack 'test-stack' does not exist",
"",
" Get Support --------------------------------------------",
" Docs: docs.serverless.com",
" Bugs: github.com/serverless/serverless/issues",
" Issues: forum.serverless.com",
]
sls_error_02 = sls_error_01.copy()
sls_error_02[2] = " Some other error"
fake_process.register_subprocess("remove", stdout="success")
fake_process.register_subprocess("remove",
stdout=sls_error_01,
returncode=1)
fake_process.register_subprocess("remove",
stdout=sls_error_02,
returncode=1)
mocker.patch.object(Serverless, "gen_cmd",
MagicMock(return_value=["remove"]))
mocker.patch.object(Serverless, "npm_install", MagicMock())
obj = Serverless(runway_context, module_root=tmp_path)
assert not obj.sls_remove()
obj.npm_install.assert_called_once()
obj.gen_cmd.assert_called_once_with("remove")
assert not obj.sls_remove(skip_install=True)
obj.npm_install.assert_called_once()
with pytest.raises(SystemExit):
assert not obj.sls_remove()
def test_extend_serverless_yml(self, mock_merge, caplog, monkeypatch,
runway_context, tmp_path):
"""Test extend_serverless_yml."""
# pylint: disable=no-member
caplog.set_level(logging.DEBUG, logger="runway")
mock_func = MagicMock()
mock_merge.return_value = {"key": "val"}
monkeypatch.setattr(Serverless, "npm_install", MagicMock())
monkeypatch.setattr(Serverless, "sls_print",
MagicMock(return_value="original"))
monkeypatch.setattr(ServerlessOptions, "update_args", MagicMock())
options = {"extend_serverless_yml": {"new-key": "val"}}
obj = Serverless(runway_context,
tmp_path,
options={"options": options})
assert not obj.extend_serverless_yml(mock_func)
obj.npm_install.assert_called_once()
obj.sls_print.assert_called_once()
mock_merge.assert_called_once_with("original",
options["extend_serverless_yml"])
mock_func.assert_called_once_with(skip_install=True)
obj.options.update_args.assert_called_once_with("config", ANY)
tmp_file = obj.options.update_args.call_args[0][1]
# 'no way to check the prefix since it will be a uuid'
assert tmp_file.endswith(".tmp.serverless.yml")
assert not (tmp_path / tmp_file
).exists(), 'should always be deleted after calling "func"'
caplog.clear()
monkeypatch.setattr(
"{}.Path.unlink".format("pathlib" if sys.version_info.major ==
3 else "pathlib2"),
MagicMock(side_effect=OSError("test OSError")),
)
assert not obj.extend_serverless_yml(mock_func)
assert ("{}:encountered an error when trying to delete the "
"temporary Serverless config".format(tmp_path.name)
in caplog.messages)
def test_deploy(self, monkeypatch, runway_context):
"""Test deploy."""
# pylint: disable=no-member
monkeypatch.setattr(Serverless, "extend_serverless_yml", MagicMock())
monkeypatch.setattr(Serverless, "sls_deploy", MagicMock())
obj = Serverless(runway_context, "./tests")
monkeypatch.setattr(Serverless, "skip", True)
assert not obj.deploy()
obj.extend_serverless_yml.assert_not_called()
obj.sls_deploy.assert_not_called()
monkeypatch.setattr(Serverless, "skip", False)
monkeypatch.setattr(obj.options, "extend_serverless_yml", True)
assert not obj.deploy()
obj.extend_serverless_yml.assert_called_once_with(obj.sls_deploy)
obj.sls_deploy.assert_not_called()
monkeypatch.setattr(obj.options, "extend_serverless_yml", False)
assert not obj.deploy()
obj.extend_serverless_yml.assert_called_once()
obj.sls_deploy.assert_called_once_with()
def test_destroy(self, monkeypatch, runway_context):
"""Test destroy."""
# pylint: disable=no-member
monkeypatch.setattr(Serverless, 'extend_serverless_yml', MagicMock())
monkeypatch.setattr(Serverless, 'sls_remove', MagicMock())
obj = Serverless(runway_context, './tests')
monkeypatch.setattr(Serverless, 'skip', True)
assert not obj.destroy()
obj.extend_serverless_yml.assert_not_called()
obj.sls_remove.assert_not_called()
monkeypatch.setattr(Serverless, 'skip', False)
monkeypatch.setattr(obj.options, 'extend_serverless_yml', True)
assert not obj.destroy()
obj.extend_serverless_yml.assert_called_once_with(obj.sls_remove)
obj.sls_remove.assert_not_called()
monkeypatch.setattr(obj.options, 'extend_serverless_yml', False)
assert not obj.destroy()
obj.extend_serverless_yml.assert_called_once()
obj.sls_remove.assert_called_once_with()
def test_gen_cmd(self, mock_cmd, command, monkeypatch, runway_context,
tmp_path):
"""Test gen_cmd."""
# pylint: disable=no-member
monkeypatch.setattr(runway_context, "no_color", False)
mock_cmd.return_value = ["success"]
obj = Serverless(runway_context, tmp_path,
{"options": {
"args": ["--config", "test"]
}})
expected_opts = [
command,
"--region",
runway_context.env_region,
"--stage",
runway_context.env_name,
"--config",
"test",
"--extra-arg",
]
assert obj.gen_cmd(command, args_list=["--extra-arg"]) == ["success"]
mock_cmd.assert_called_once_with(command="sls",
command_opts=expected_opts,
logger=obj.logger,
path=tmp_path)
mock_cmd.reset_mock()
obj.context.env_vars["CI"] = "1"
monkeypatch.setattr(runway_context, "no_color", True)
expected_opts.append("--no-color")
if command not in ["remove", "print"]:
expected_opts.append("--conceal")
assert obj.gen_cmd(command, args_list=["--extra-arg"]) == ["success"]
mock_cmd.assert_called_once_with(command="sls",
command_opts=expected_opts,
logger=obj.logger,
path=tmp_path)
def test_extend_serverless_yml(self, mock_merge, caplog, monkeypatch,
runway_context, tmp_path):
"""Test extend_serverless_yml."""
# pylint: disable=no-member
caplog.set_level(logging.DEBUG, logger='runway')
mock_func = MagicMock()
mock_merge.return_value = {'key': 'val'}
monkeypatch.setattr(Serverless, 'npm_install', MagicMock())
monkeypatch.setattr(Serverless, 'sls_print',
MagicMock(return_value='original'))
monkeypatch.setattr(ServerlessOptions, 'update_args', MagicMock())
options = {'extend_serverless_yml': {'new-key': 'val'}}
obj = Serverless(runway_context,
tmp_path,
options={'options': options})
assert not obj.extend_serverless_yml(mock_func)
obj.npm_install.assert_called_once()
obj.sls_print.assert_called_once()
mock_merge.assert_called_once_with('original',
options['extend_serverless_yml'])
mock_func.assert_called_once_with(skip_install=True)
obj.options.update_args.assert_called_once_with('config', ANY)
tmp_file = obj.options.update_args.call_args[0][1]
# 'no way to check the prefix since it will be a uuid'
assert tmp_file.endswith('.tmp.serverless.yml')
assert not (tmp_path / tmp_file).exists(), \
'should always be deleted after calling "func"'
caplog.clear()
monkeypatch.setattr(
'{}.Path.unlink'.format('pathlib' if sys.version_info.major ==
3 else 'pathlib2'),
MagicMock(side_effect=OSError('test OSError')))
assert not obj.extend_serverless_yml(mock_func)
assert '{}: test OSError'.format(tmp_path.name) in caplog.messages
def test_deploy(self, mocker: MockerFixture,
runway_context: MockRunwayContext, tmp_path: Path) -> None:
"""Test deploy."""
mock_extend_serverless_yml = mocker.patch.object(
Serverless, "extend_serverless_yml")
mock_sls_deploy = mocker.patch.object(Serverless, "sls_deploy")
obj = Serverless(runway_context, module_root=tmp_path)
mocker.patch.object(Serverless, "skip", True)
assert not obj.deploy()
mock_extend_serverless_yml.assert_not_called()
mock_sls_deploy.assert_not_called()
mocker.patch.object(Serverless, "skip", False)
mocker.patch.object(obj.options, "extend_serverless_yml", True)
assert not obj.deploy()
mock_extend_serverless_yml.assert_called_once_with(mock_sls_deploy)
mock_sls_deploy.assert_not_called()
mocker.patch.object(obj.options, "extend_serverless_yml", False)
assert not obj.deploy()
mock_extend_serverless_yml.assert_called_once()
mock_sls_deploy.assert_called_once_with()
def test_init(self, caplog, runway_context):
"""Test init and the attributes set in init."""
caplog.set_level(logging.ERROR, logger="runway")
obj = Serverless(runway_context, "./tests",
{"options": {
"skip_npm_ci": True
}})
assert isinstance(obj.options, ServerlessOptions)
assert obj.region == runway_context.env_region
assert obj.stage == runway_context.env_name
with pytest.raises(SystemExit):
assert not Serverless(
runway_context,
"./tests",
{"options": {
"promotezip": {
"invalid": "value"
}
}},
)
assert ["tests:error encountered while parsing options"
] == caplog.messages
def test_cli_args(self, runway_context):
"""Test cli_args."""
obj = Serverless(runway_context, './tests')
assert obj.cli_args == [
'--region', runway_context.env_region, '--stage',
runway_context.env_name
]
runway_context.env_vars['DEBUG'] = '1'
assert obj.cli_args == [
'--region', runway_context.env_region, '--stage',
runway_context.env_name, '--verbose'
]
def test_init(self, caplog, runway_context):
"""Test init and the attributes set in init."""
caplog.set_level(logging.ERROR, logger='runway')
obj = Serverless(runway_context, './tests',
{'options': {
'skip_npm_ci': True
}})
assert isinstance(obj.options, ServerlessOptions)
assert obj.region == runway_context.env_region
assert obj.stage == runway_context.env_name
with pytest.raises(SystemExit):
assert not Serverless(
runway_context, './tests',
{'options': {
'promotezip': {
'invalid': 'value'
}
}})
assert [
'tests: "bucketname" must be provided when using '
'"options.promotezip": {\'invalid\': \'value\'}'
] == caplog.messages
def test_destroy(self, mocker: MockerFixture,
runway_context: MockRunwayContext,
tmp_path: Path) -> None:
"""Test destroy."""
# pylint: disable=no-member
mocker.patch.object(Serverless, "extend_serverless_yml")
mocker.patch.object(Serverless, "sls_remove", MagicMock())
obj = Serverless(runway_context, module_root=tmp_path)
mocker.patch.object(Serverless, "skip", True)
assert not obj.destroy()
obj.extend_serverless_yml.assert_not_called() # type: ignore
obj.sls_remove.assert_not_called()
mocker.patch.object(Serverless, "skip", False)
mocker.patch.object(obj.options, "extend_serverless_yml", True)
assert not obj.destroy()
obj.extend_serverless_yml.assert_called_once_with(obj.sls_remove)
obj.sls_remove.assert_not_called()
mocker.patch.object(obj.options, "extend_serverless_yml", False)
assert not obj.destroy()
obj.extend_serverless_yml.assert_called_once()
obj.sls_remove.assert_called_once_with()
def test_sls_deploy(self, mock_run, mock_deploy, monkeypatch,
runway_context, tmp_path):
"""Test sls_deploy."""
# pylint: disable=no-member
monkeypatch.setattr(runway_context, 'no_color', False)
monkeypatch.setattr(Serverless, 'gen_cmd',
MagicMock(return_value=['deploy']))
monkeypatch.setattr(Serverless, 'npm_install', MagicMock())
obj = Serverless(
runway_context,
tmp_path,
options={'options': {
'args': ['--config', 'test.yml']
}})
assert not obj.sls_deploy()
obj.npm_install.assert_called_once()
obj.gen_cmd.assert_called_once_with('deploy')
mock_run.assert_called_once_with(cmd_list=['deploy'],
env_vars=runway_context.env_vars)
obj.options.promotezip['bucketname'] = 'test-bucket'
assert not obj.sls_deploy(skip_install=True)
obj.npm_install.assert_called_once()
mock_deploy.assert_called_once_with([
'deploy', '--region', runway_context.env_region, '--stage',
runway_context.env_name, '--config', 'test.yml'
], 'test-bucket', runway_context, str(tmp_path))
mock_run.assert_called_once()
monkeypatch.setattr(runway_context, 'no_color', True)
assert not obj.sls_deploy(skip_install=True)
mock_deploy.assert_called_with([
'deploy', '--region', runway_context.env_region, '--stage',
runway_context.env_name, '--config', 'test.yml', '--no-color'
], 'test-bucket', runway_context, str(tmp_path))
def test_cli_args(self, runway_context):
"""Test cli_args."""
obj = Serverless(runway_context, "./tests")
assert obj.cli_args == [
"--region",
runway_context.env_region,
"--stage",
runway_context.env_name,
]
runway_context.env_vars["DEBUG"] = "1"
assert obj.cli_args == [
"--region",
runway_context.env_region,
"--stage",
runway_context.env_name,
"--verbose",
]
def test_cli_args(self, runway_context: MockRunwayContext,
tmp_path: Path) -> None:
"""Test cli_args."""
obj = Serverless(runway_context, module_root=tmp_path)
assert obj.cli_args == [
"--region",
runway_context.env.aws_region,
"--stage",
runway_context.env.name,
]
runway_context.env.vars["DEBUG"] = "1"
assert obj.cli_args == [
"--region",
runway_context.env.aws_region,
"--stage",
runway_context.env.name,
"--verbose",
]
def test_skip(
self,
caplog: LogCaptureFixture,
mocker: MockerFixture,
runway_context: MockRunwayContext,
tmp_path: Path,
) -> None:
"""Test skip."""
caplog.set_level(logging.INFO, logger="runway")
obj = Serverless(runway_context, module_root=tmp_path)
mocker.patch.object(obj, "package_json_missing", lambda: True)
mocker.patch.object(obj, "env_file", False)
assert obj.skip
assert [
'{}:skipped; package.json with "serverless" in devDependencies'
" is required for this module type".format(tmp_path.name)
] == caplog.messages
caplog.clear()
mocker.patch.object(obj, "package_json_missing", lambda: False)
assert obj.skip
assert [
"{}:skipped; config file for this stage/region not found"
" -- looking for one of: {}".format(
tmp_path.name,
", ".join(gen_sls_config_files(obj.stage, obj.region)))
] == caplog.messages
caplog.clear()
obj.explicitly_enabled = True
assert not obj.skip
obj.explicitly_enabled = False
obj.parameters = True # type: ignore
assert not obj.skip
obj.parameters = False # type: ignore
obj.env_file = True # type: ignore
assert not obj.skip
