def test_default_cli_flags_with_timeout(minion_id, config_dir, config_file, cli_script_name):
default_timeout = 10
config = {"conf_file": config_file, "id": "the-id"}
args = ["test.ping"]
kwargs = {"minion_tgt": minion_id}
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--timeout={}".format(default_timeout - 5),
"--out=json",
"--log-level=quiet",
minion_id,
"test.ping",
]
proc = SaltCliFactory(
cli_script_name=cli_script_name, config=config, default_timeout=default_timeout
)
# We set __cli_timeout_supported__ to True just to test. This would be an attribute set
# at the class level for Salt CLI's that support the timeout flag, like for example, salt-run
proc.__cli_timeout_supported__ = True
# We set the _terminal_timeout attribute just to test. This attribute would be set when calling
# SaltScriptBase.run() but we don't really want to call it
proc._terminal_timeout = proc.default_timeout
cmdline = proc.build_cmdline(*args, **kwargs)
assert cmdline == expected
def test_override_output(minion_id, config_dir, config_file, cli_script_name, flag):
config = {"conf_file": config_file, "id": "the-id"}
args = []
if flag.endswith("="):
flag_overrides_args = [flag + "nested"]
else:
flag_overrides_args = [flag, "nested"]
args.extend(flag_overrides_args)
args.append("test.ping")
kwargs = {"minion_tgt": minion_id}
expected = (
[
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--log-level=quiet",
minion_id,
]
+ flag_overrides_args
+ ["test.ping"]
)
proc = SaltCliFactory(cli_script_name=cli_script_name, config=config)
cmdline = proc.build_cmdline(*args, **kwargs)
assert cmdline == expected
def test_salt_cli_factory_id_attr_comes_first_in_repr(config_file):
proc = SaltCliFactory(
cli_script_name="foo-bar", config={"id": "TheID", "conf_file": config_file}
)
regex = r"{}(id='TheID'".format(proc.__class__.__name__)
assert repr(proc).startswith(regex)
assert str(proc).startswith(regex)
def test_override_config_dir(minion_id, config_dir, config_file,
cli_script_name, flag):
passed_config_dir = config_dir.strpath + ".new"
if flag is None:
flag_overrides_args = ["--config-dir={}".format(config_dir.strpath)]
elif flag.endswith("="):
flag_overrides_args = [flag + passed_config_dir]
else:
flag_overrides_args = [flag, passed_config_dir]
default_timeout = 10
config = {"conf_file": config_file, "id": "the-id"}
args = flag_overrides_args + ["test.ping"]
kwargs = {"minion_tgt": minion_id}
expected = ([
sys.executable,
cli_script_name,
"--out=json",
"--log-level=quiet",
minion_id,
] + flag_overrides_args + [
"test.ping",
])
proc = SaltCliFactory(cli_script_name=cli_script_name, config=config)
# We set the _terminal_timeout attribute just to test. This attribute would be set when calling
# SaltScriptBase.run() but we don't really want to call it
cmdline = proc.build_cmdline(*args, **kwargs)
assert cmdline == expected
def test_override_config_dir(minion_id, config_dir, config_file, cli_script_name, flag):
passed_config_dir = config_dir.strpath + ".new"
if flag is None:
flag_overrides_args = ["--config-dir={}".format(config_dir.strpath)]
elif flag.endswith("="):
flag_overrides_args = [flag + passed_config_dir]
else:
flag_overrides_args = [flag, passed_config_dir]
default_timeout = 10
config = {"conf_file": config_file, "id": "the-id"}
args = flag_overrides_args + ["test.ping"]
kwargs = {"minion_tgt": minion_id}
expected = (
[
sys.executable,
cli_script_name,
"--out=json",
"--out-indent=0",
"--log-level=quiet",
minion_id,
]
+ flag_overrides_args
+ ["test.ping"]
)
proc = SaltCliFactory(cli_script_name=cli_script_name, config=config)
cmdline = proc.build_cmdline(*args, **kwargs)
assert cmdline == expected
def test_process_output(cli_script_name, config_file):
in_stdout = '"The salt master could not be contacted. Is master running?"\n'
in_stderr = ""
cmdline = ["--out=json"]
config = {"conf_file": config_file, "id": "the-id"}
proc = SaltCliFactory(cli_script_name=cli_script_name, config=config)
stdout, stderr, json_out = proc.process_output(in_stdout, in_stderr, cmdline=cmdline)
assert stdout == json.loads(in_stdout)
assert stderr == in_stderr
assert json_out is None
def test_default_cli_flags(minion_id, config_dir, config_file, cli_script_name):
config = {"conf_file": config_file, "id": "the-id"}
args = ["test.ping"]
kwargs = {"minion_tgt": minion_id}
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--out=json",
"--log-level=quiet",
minion_id,
"test.ping",
]
proc = SaltCliFactory(cli_script_name=cli_script_name, config=config)
cmdline = proc.build_cmdline(*args, **kwargs)
assert cmdline == expected
def test_non_string_cli_flags(minion_id, config_dir, config_file, cli_script_name):
config = {"conf_file": config_file, "id": "the-id"}
args = ["test.ping"]
foo = ["the", "foo", "list"]
kwargs = {"minion_tgt": minion_id, "foo": foo}
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--out=json",
"--out-indent=0",
"--log-level=quiet",
minion_id,
"test.ping",
"foo={}".format(json.dumps(foo)),
]
proc = SaltCliFactory(cli_script_name=cli_script_name, config=config)
cmdline = proc.build_cmdline(*args, **kwargs)
assert cmdline == expected
def test_cli_timeout_greater_than_timeout_kw(minion_id, config_dir, config_file, cli_script_name):
# Both --timeout and _timeout are passed.
# Since --timeout is greater than _timeout, the value of _timeout is updated to the value of --timeout plus 5
default_timeout = 10
explicit_timeout = 20
cli_timeout = 60
config = {"conf_file": config_file, "id": "the-id"}
args = ["--timeout", str(cli_timeout), "test.ping"]
kwargs = {"minion_tgt": minion_id, "_timeout": explicit_timeout}
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--out=json",
"--out-indent=0",
"--log-level=quiet",
minion_id,
"--timeout",
"60",
"test.ping",
]
popen_mock = mock.MagicMock()
popen_mock.pid = os.getpid()
popen_mock.poll = mock.MagicMock(side_effect=[None, None, None, None, True])
terminate_mock = mock.MagicMock(return_value=ProcessResult(0, "", "", cmdline=()))
popen_mock.terminate = terminate_mock
proc = SaltCliFactory(
cli_script_name=cli_script_name, config=config, default_timeout=default_timeout
)
with mock.patch.object(proc.impl, "init_terminal", popen_mock), mock.patch.object(
proc, "terminate", terminate_mock
):
proc.impl._terminal = popen_mock
# We set __cli_timeout_supported__ to True just to test. This would be an attribute set
# at the class level for Salt CLI's that support the timeout flag, like for example, salt-run
proc.__cli_timeout_supported__ = True
ret = proc.run(*args, **kwargs)
assert proc.impl._terminal_timeout == cli_timeout + 5
assert popen_mock.call_args[0][0] == expected # pylint: disable=unsubscriptable-object
def test_override_timeout_bad_value(minion_id, config_dir, config_file, cli_script_name, flag):
flag_value = 15
if flag.endswith("="):
flag_overrides_args = [flag + str(flag_value) + "i"]
else:
flag_overrides_args = [flag, str(flag_value) + "i"]
default_timeout = 10
config = {"conf_file": config_file, "id": "the-id"}
args = flag_overrides_args + ["test.ping"]
kwargs = {"minion_tgt": minion_id}
expected = (
[
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--out=json",
"--out-indent=0",
"--log-level=quiet",
minion_id,
]
+ flag_overrides_args
+ ["test.ping"]
)
proc = SaltCliFactory(
cli_script_name=cli_script_name, config=config, default_timeout=default_timeout
)
# We set __cli_timeout_supported__ to True just to test. This would be an attribute set
# at the class level for Salt CLI's that support the timeout flag, like for example, salt-run
proc.__cli_timeout_supported__ = True
# We set the _terminal_timeout attribute just to test. This attribute would be set when calling
# SaltScriptBase.run() but we don't really want to call it
proc.impl._terminal_timeout = flag_value
cmdline = proc.build_cmdline(*args, **kwargs)
assert cmdline == expected
# Let's confirm that even though we tried to parse the timeout flag value, it was a bad value and the
# SaltScriptBase _terminal_timeout attribute was not update
assert proc.impl._terminal_timeout == flag_value
def test_salt_cli_display_name(config_file):
factory_id = "TheID"
proc = SaltCliFactory(
cli_script_name="foo-bar", config={"id": factory_id, "conf_file": config_file}
)
assert proc.get_display_name() == "{}(id={!r})".format(SaltCliFactory.__name__, factory_id)
def test_jsonify_kwargs(minion_id, config_dir, config_file, cli_script_name):
config = {"conf_file": config_file, "id": "the-id"}
args = ["test.ping"]
# Strings
extra_kwargs = OrderedDict((("look", "Ma"), ("no", "Hands!")))
kwargs = OrderedDict((("minion_tgt", minion_id),))
kwargs.update(extra_kwargs)
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--out=json",
"--log-level=quiet",
minion_id,
"test.ping",
]
for key, value in extra_kwargs.items():
expected.append("{}={}".format(key, value))
proc = SaltCliFactory(cli_script_name=cli_script_name, config=config)
cmdline = proc.build_cmdline(*args, **kwargs)
# Function **kwargs are not ordered dictionaries on some python versions
# let's just use sorted to make sure everything is in the output
assert sorted(cmdline) == sorted(expected)
# Numbers
extra_kwargs = OrderedDict((("width", 1.27), ("height", 3)))
kwargs = OrderedDict((("minion_tgt", minion_id),))
kwargs.update(extra_kwargs)
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--out=json",
"--log-level=quiet",
minion_id,
"test.ping",
]
for key, value in extra_kwargs.items():
value = json.dumps(value)
expected.append("{}={}".format(key, value))
proc = SaltCliFactory(cli_script_name=cli_script_name, config=config)
cmdline = proc.build_cmdline(*args, **kwargs)
# Function **kwargs are not ordered dictionaries on some python versions
# let's just use sorted to make sure everything is in the output
assert sorted(cmdline) == sorted(expected)
# Booleans
extra_kwargs = OrderedDict((("short", False), ("tall", True)))
kwargs = OrderedDict((("minion_tgt", minion_id),))
kwargs.update(extra_kwargs)
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--out=json",
"--log-level=quiet",
minion_id,
"test.ping",
]
for key, value in extra_kwargs.items():
value = json.dumps(value)
expected.append("{}={}".format(key, value))
proc = SaltCliFactory(cli_script_name=cli_script_name, config=config)
cmdline = proc.build_cmdline(*args, **kwargs)
# Function **kwargs are not ordered dictionaries on some python versions
# let's just use sorted to make sure everything is in the output
assert sorted(cmdline) == sorted(expected)
# JSon structure
extra_kwargs = {"look": "Ma", "no": "Hands!"}
kwargs = {"minion_tgt": minion_id, "extra": extra_kwargs}
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--out=json",
"--log-level=quiet",
minion_id,
"test.ping",
"extra={}".format(json.dumps(extra_kwargs)),
]
proc = SaltCliFactory(cli_script_name=cli_script_name, config=config)
cmdline = proc.build_cmdline(*args, **kwargs)
# Function **kwargs are not ordered dictionaries on some python versions
# let's just use sorted to make sure everything is in the output
assert sorted(cmdline) == sorted(expected)
def test_default_cli_flags_with_timeout_and_timeout_kwargs(
minion_id, config_dir, config_file, cli_script_name
):
"""
This test assures that when _timeout is passed as a keyword argument, that the _terminal_timeout property
does not get get updated to the value of --timeout
"""
default_timeout = 10
explicit_timeout = 60
config = {"conf_file": config_file, "id": "the-id"}
args = ["--timeout=6", "test.ping"]
kwargs = {"minion_tgt": minion_id, "_timeout": explicit_timeout}
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--out=json",
"--log-level=quiet",
minion_id,
"--timeout=6",
"test.ping",
]
popen_mock = mock.MagicMock()
popen_mock.pid = os.getpid()
popen_mock.poll = mock.MagicMock(side_effect=[None, None, None, None, True])
terminate_mock = mock.MagicMock(return_value=ProcessResult(0, "", "", cmdline=()))
popen_mock.terminate = terminate_mock
proc = SaltCliFactory(
cli_script_name=cli_script_name, config=config, default_timeout=default_timeout
)
with mock.patch.object(proc, "init_terminal", popen_mock), mock.patch.object(
proc, "terminate", terminate_mock
):
proc._terminal = popen_mock
# We set __cli_timeout_supported__ to True just to test. This would be an attribute set
# at the class level for Salt CLI's that support the timeout flag, like for example, salt-run
proc.__cli_timeout_supported__ = True
ret = proc.run(*args, **kwargs)
assert proc._terminal_timeout_set_explicitly is True
assert proc._terminal_timeout == explicit_timeout
assert popen_mock.call_args[0][0] == expected # pylint: disable=unsubscriptable-object
# To confirm behavior, let's NOT pass --timeout in args
default_timeout = 10
explicit_timeout = 60
config = {"conf_file": config_file, "id": "the-id"}
args = ["test.ping"]
kwargs = {"minion_tgt": minion_id, "_timeout": explicit_timeout}
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--timeout={}".format(explicit_timeout),
"--out=json",
"--log-level=quiet",
minion_id,
"test.ping",
]
popen_mock = mock.MagicMock()
popen_mock.pid = os.getpid()
popen_mock.poll = mock.MagicMock(side_effect=[None, None, None, None, True])
popen_mock.terminate = mock.MagicMock(return_value=ProcessResult(0, "", "", cmdline=()))
terminate_mock = mock.MagicMock(return_value=ProcessResult(0, "", ""))
proc = SaltCliFactory(
cli_script_name=cli_script_name, config=config, default_timeout=default_timeout
)
with mock.patch.object(proc, "init_terminal", popen_mock), mock.patch.object(
proc, "terminate", terminate_mock
):
proc._terminal = popen_mock
# We set __cli_timeout_supported__ to True just to test. This would be an attribute set
# at the class level for Salt CLI's that support the timeout flag, like for example, salt-run
proc.__cli_timeout_supported__ = True
ret = proc.run(*args, **kwargs)
assert proc._terminal_timeout_set_explicitly is True
assert proc._terminal_timeout == explicit_timeout
assert popen_mock.call_args[0][0] == expected # pylint: disable=unsubscriptable-object
# To confirm behavior, let's NOT pass --timeout in args nor _timeout in kwargs
default_timeout = 10
config = {"conf_file": config_file, "id": "the-id"}
args = ["test.ping"]
kwargs = {"minion_tgt": minion_id}
expected = [
sys.executable,
cli_script_name,
"--config-dir={}".format(config_dir.strpath),
"--timeout={}".format(default_timeout - 5),
"--out=json",
"--log-level=quiet",
minion_id,
"test.ping",
]
popen_mock = mock.MagicMock()
popen_mock.pid = os.getpid()
popen_mock.poll = mock.MagicMock(side_effect=[None, None, None, None, True])
popen_mock.terminate = mock.MagicMock(return_value=ProcessResult(0, "", "", cmdline=()))
terminate_mock = mock.MagicMock(return_value=ProcessResult(0, "", ""))
proc = SaltCliFactory(
cli_script_name=cli_script_name, config=config, default_timeout=default_timeout
)
with mock.patch.object(proc, "init_terminal", popen_mock), mock.patch.object(
proc, "terminate", terminate_mock
):
proc._terminal = popen_mock
# We set __cli_timeout_supported__ to True just to test. This would be an attribute set
# at the class level for Salt CLI's that support the timeout flag, like for example, salt-run
proc.__cli_timeout_supported__ = True
ret = proc.run(*args, **kwargs)
assert proc._terminal_timeout_set_explicitly is False
assert proc._terminal_timeout == default_timeout
assert popen_mock.call_args[0][0] == expected # pylint: disable=unsubscriptable-object