コード例 #1
0
def test_ping(proxy_minion_config):
    """
    check netmiko_proxy ping method
    """

    proxy_minion_config["skip_connect_on_init"] = True

    netmiko_proxy.init(proxy_minion_config)

    result = netmiko_proxy.ping()
    assert result is True
コード例 #2
0
    def test_ping(self):
        """ check netmiko_proxy ping method """

        opts = salt.config.proxy_config(RUNTIME_VARS.TMP_PROXY_CONF_DIR +
                                        "/proxy",
                                        minion_id="proxytest")
        opts["skip_connect_on_init"] = True

        netmiko_proxy.init(opts)

        result = netmiko_proxy.ping()
        self.assertEqual(result, True)
コード例 #3
0
def test_make_con(proxy_minion_config):
    """
    check netmiko_proxy make_con method
    """

    proxy_minion_config["skip_connect_on_init"] = True

    netmiko_proxy.init(proxy_minion_config)

    mock_connection = MockNetmikoConnection

    with patch.object(netmiko_proxy, "ConnectHandler", mock_connection, create=True):
        result = netmiko_proxy.make_con()
        assert result is not None
コード例 #4
0
    def test_init_skip_connect_on_init_false(self):
        """ check netmiko_proxy init method """

        opts = salt.config.proxy_config(RUNTIME_VARS.TMP_PROXY_CONF_DIR +
                                        "/proxy",
                                        minion_id="proxytest")
        opts["skip_connect_on_init"] = False

        mock_make_con = MagicMock()
        with patch.object(netmiko_proxy, "make_con", mock_make_con):
            result = netmiko_proxy.init(opts)

        self.assertIn("netmiko_device", netmiko_proxy.__context__)
        self.assertIn("args", netmiko_proxy.__context__["netmiko_device"])

        self.assertIn("initialized",
                      netmiko_proxy.__context__["netmiko_device"])
        self.assertTrue(
            netmiko_proxy.__context__["netmiko_device"]["initialized"])

        self.assertIn("up", netmiko_proxy.__context__["netmiko_device"])
        self.assertTrue(netmiko_proxy.__context__["netmiko_device"]["up"])

        self.assertIn("always_alive",
                      netmiko_proxy.__context__["netmiko_device"])

        self.assertNotIn("conneciton",
                         netmiko_proxy.__context__["netmiko_device"])
コード例 #5
0
    def test_make_con(self):
        """ check netmiko_proxy make_con method """

        opts = salt.config.proxy_config(RUNTIME_VARS.TMP_PROXY_CONF_DIR +
                                        "/proxy",
                                        minion_id="proxytest")
        opts["skip_connect_on_init"] = True

        netmiko_proxy.init(opts)

        mock_connection = MockNetmikoConnection

        with patch.object(netmiko_proxy,
                          "ConnectHandler",
                          mock_connection,
                          create=True):
            result = netmiko_proxy.make_con()
            self.assertNotEqual(result, None)
コード例 #6
0
def test_initialized(proxy_minion_config):
    """
    check netmiko_proxy alive method
    """

    proxy_minion_config["skip_connect_on_init"] = True

    netmiko_proxy.init(proxy_minion_config)

    result = netmiko_proxy.initialized()
    assert not result

    # Always alive True with skip_connect_on_init on False
    # should return alive as True
    proxy_minion_config["skip_connect_on_init"] = False

    mock_make_con = MagicMock()
    with patch.object(netmiko_proxy, "make_con", mock_make_con):
        netmiko_proxy.init(proxy_minion_config)
        result = netmiko_proxy.initialized()
        assert result
コード例 #7
0
    def test_alive(self):
        """ check netmiko_proxy alive method """

        # Always alive False with skip_connect_on_init on True
        # should return alive as True
        opts = salt.config.proxy_config(RUNTIME_VARS.TMP_PROXY_CONF_DIR +
                                        "/proxy",
                                        minion_id="proxytest")
        opts["skip_connect_on_init"] = True
        opts["proxy_always_alive"] = False

        netmiko_proxy.init(opts)

        result = netmiko_proxy.alive(opts)
        self.assertTrue(result)

        # Always alive True with skip_connect_on_init on True
        # should return alive as False
        opts["proxy_always_alive"] = True

        netmiko_proxy.init(opts)

        result = netmiko_proxy.alive(opts)
        self.assertFalse(result)

        # Always alive True with skip_connect_on_init on False
        # should return alive as True
        opts["skip_connect_on_init"] = False
        opts["proxy_always_alive"] = True

        mock_make_con = MagicMock()
        with patch.object(netmiko_proxy, "make_con", mock_make_con):
            netmiko_proxy.init(opts)
            result = netmiko_proxy.alive(opts)
            self.assertTrue(result)
コード例 #8
0
def test_make_con_raise_exception(proxy_minion_config):
    """
    check netmiko_proxy make_con method
    """

    class ExpectedException(Exception):
        """
        Custom exception class expected to raise as a side_effect
        """

    def raise_exception(*arg, **kwarg):
        raise ExpectedException("expected")

    proxy_minion_config["skip_connect_on_init"] = True

    netmiko_proxy.init(proxy_minion_config)

    with patch.object(netmiko_proxy, "DEFAULT_CONNECTION_TIMEOUT", 0), patch.object(
        netmiko_proxy, "ConnectHandler", raise_exception, create=True
    ):
        with pytest.raises(ExpectedException):
            netmiko_proxy.make_con(0)
コード例 #9
0
    def test_make_con_raise_exception(self):
        """ check netmiko_proxy make_con method """
        def raise_exception(*arg, **kwarg):
            raise Exception("expected")

        opts = salt.config.proxy_config(RUNTIME_VARS.TMP_PROXY_CONF_DIR +
                                        "/proxy",
                                        minion_id="proxytest")
        opts["skip_connect_on_init"] = True

        netmiko_proxy.init(opts)

        mock_connection = MockNetmikoConnection

        with patch.object(netmiko_proxy, "DEFAULT_CONNECTION_TIMEOUT",
                          0), patch.object(netmiko_proxy,
                                           "ConnectHandler",
                                           raise_exception,
                                           create=True):
            result = None
            try:
                result = netmiko_proxy.make_con(0)
            except Exception:  # pylint: disable=broad-except
                self.assertEqual(result, None)
コード例 #10
0
def test_init_skip_connect_on_init_true(proxy_minion_config):
    """
    check netmiko_proxy init method
    """

    proxy_minion_config["skip_connect_on_init"] = True

    assert netmiko_proxy.init(proxy_minion_config)
    assert "netmiko_device" in netmiko_proxy.__context__
    netmiko_device = netmiko_proxy.__context__["netmiko_device"]
    assert "args" in netmiko_device

    assert "initialized" in netmiko_device
    assert not netmiko_device["initialized"]

    assert "up" in netmiko_device
    assert netmiko_device["up"]

    assert "always_alive" in netmiko_device
    assert "connection" not in netmiko_device
コード例 #11
0
def test_init_skip_connect_on_init_false(proxy_minion_config):
    """
    check netmiko_proxy init method
    """

    proxy_minion_config["skip_connect_on_init"] = False

    mock_make_con = MagicMock()
    with patch.object(netmiko_proxy, "make_con", mock_make_con):
        assert netmiko_proxy.init(proxy_minion_config) is None

    assert "netmiko_device" in netmiko_proxy.__context__
    netmiko_device = netmiko_proxy.__context__["netmiko_device"]
    assert "args" in netmiko_device

    assert "initialized" in netmiko_device
    assert netmiko_device["initialized"]

    assert "up" in netmiko_device
    assert netmiko_device["up"]

    assert "always_alive" in netmiko_device
    assert "connection" in netmiko_device
コード例 #12
0
def test_alive(proxy_minion_config, subtests):
    """
    check netmiko_proxy alive method
    """

    # Always alive False with skip_connect_on_init on True
    # should return alive as True
    with subtests.test("skip_connect_on_init=True, proxy_always_alive=False"):
        proxy_minion_config["skip_connect_on_init"] = True
        proxy_minion_config["proxy_always_alive"] = False

        netmiko_proxy.init(proxy_minion_config)

        result = netmiko_proxy.alive(proxy_minion_config)
        assert result

    # Always alive True with skip_connect_on_init on True
    # should return alive as False
    with subtests.test("skip_connect_on_init=True, proxy_always_alive=True"):
        proxy_minion_config["skip_connect_on_init"] = True
        proxy_minion_config["proxy_always_alive"] = True

        netmiko_proxy.init(proxy_minion_config)

        result = netmiko_proxy.alive(proxy_minion_config)
        assert not result

    # Always alive True with skip_connect_on_init on False
    # should return alive as True
    with subtests.test("skip_connect_on_init=False, proxy_always_alive=True"):
        proxy_minion_config["skip_connect_on_init"] = False
        proxy_minion_config["proxy_always_alive"] = True

        mock_make_con = MagicMock()
        with patch.object(netmiko_proxy, "make_con", mock_make_con):
            netmiko_proxy.init(proxy_minion_config)
            result = netmiko_proxy.alive(proxy_minion_config)
            assert result