コード例 #1
0
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
コード例 #2
0
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
コード例 #3
0
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)
コード例 #4
0
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
コード例 #5
0
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
コード例 #6
0
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
コード例 #7
0
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
コード例 #8
0
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
コード例 #9
0
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
コード例 #10
0
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
コード例 #11
0
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)
コード例 #12
0
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)
コード例 #13
0
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