moving common fixtures to tests/pytests/functional/states/rabbitmq/conftest.py, moving tests to tests/pytests/functional/states/rabbitmq

tests/pytests/functional/states/rabbitmq/conftest.py

@@ -0,0 +1,112 @@
+import logging
+import time
+
+import attr
+import pytest
+from saltfactories.factories.daemons.container import ContainerFactory
+from saltfactories.utils import random_string
+from saltfactories.utils.ports import get_unused_localhost_port
+
+docker = pytest.importorskip("docker")
+docker_errors = pytest.importorskip("docker.errors")
+
+log = logging.getLogger(__name__)
+
+
+@attr.s(kw_only=True, slots=True)
+class RabbitMQImage:
+    name = attr.ib()
+    tag = attr.ib()
+    container_id = attr.ib()
+
+    def __str__(self):
+        return "{}:{}".format(self.name, self.tag)
+
+
+@attr.s(kw_only=True, slots=True)
+class RabbitMQCombo:
+    rabbitmq_name = attr.ib()
+    rabbitmq_version = attr.ib()
+    rabbitmq_port = attr.ib()
+
+    @rabbitmq_port.default
+    def _rabbitmq_port(self):
+        return get_unused_localhost_port()
+
+
+def get_test_versions():
+    test_versions = []
+    name = "rabbitmq"
+    for version in ("3.8",):
+        test_versions.append(
+            RabbitMQImage(
+                name=name,
+                tag=version,
+                container_id=random_string("rabbitmq-{}-".format(version)),
+            )
+        )
+    return test_versions
+
+
+def get_test_version_id(value):
+    return "container={}".format(value)
+
+
+@pytest.fixture(scope="module", params=get_test_versions(), ids=get_test_version_id)
+def rabbitmq_container(request, salt_factories, modules):
+
+    try:
+        docker_client = docker.from_env()
+    except docker_errors.DockerException:
+        pytest.skip("Failed to get a connection to docker running on the system")
+    connectable = ContainerFactory.client_connectable(docker_client)
+    if connectable is not True:  # pragma: no cover
+        pytest.skip(connectable)
+
+    rabbitmq_image = request.param
+
+    combo = RabbitMQCombo(
+        rabbitmq_name=rabbitmq_image.name, rabbitmq_version=rabbitmq_image.tag,
+    )
+    container = salt_factories.get_container(
+        rabbitmq_image.container_id,
+        "{}:{}".format(combo.rabbitmq_name, combo.rabbitmq_version),
+        docker_client=docker_client,
+    )
+    with container.started():
+        # Sleep
+        time.sleep(10)
+
+        authenticated = False
+        login_attempts = 6
+        while login_attempts:
+            login_attempts -= 1
+            ret = container.run("rabbitmqctl ping")
+            authenticated = ret.exitcode == 0
+            if authenticated:
+                break
+
+            time.sleep(10)
+
+        if authenticated:
+            yield container
+        else:
+            pytest.fail(
+                "Failed to connect to rabbitmq in container(id: {})".format(
+                    rabbitmq_image.container_id
+                )
+            )
+
+
+@pytest.fixture(scope="module")
+def docker_cmd_run_all_wrapper(rabbitmq_container):
+    def run_command(cmd, **kwargs):
+        # Update rabbitmqctl location
+        if cmd[0] is None:
+            cmd[0] = "/opt/rabbitmq/sbin/rabbitmqctl"
+
+        ret = rabbitmq_container.run(cmd)
+        res = {"retcode": ret.exitcode, "stdout": ret.stdout, "stderr": ret.stderr}
+        return res
+
+    return run_command

tests/pytests/functional/states/rabbitmq/test_cluster.py

@@ -0,0 +1,55 @@
+"""
+Integration tests for the rabbitmq_cluster states
+"""
+
+import logging
+
+import pytest
+import salt.modules.rabbitmq as rabbitmq
+import salt.states.rabbitmq_cluster as rabbitmq_cluster
+
+log = logging.getLogger(__name__)
+
+pytestmark = [
+    pytest.mark.slow_test,
+    pytest.mark.skip_on_freebsd(reason="No Docker on FreeBSD available"),
+    pytest.mark.skip_if_binaries_missing(
+        "docker", "dockerd", message="Docker not installed"
+    ),
+]
+
+
+@pytest.fixture
+def configure_loader_modules(docker_cmd_run_all_wrapper):
+    return {
+        rabbitmq_cluster: {
+            "__salt__": {
+                "rabbitmq.cluster_status": rabbitmq.cluster_status,
+                "rabbitmq.join_cluster": rabbitmq.join_cluster,
+            },
+            "__opts__": {"test": False},
+            "_utils__": {},
+        },
+        rabbitmq: {
+            "__salt__": {"cmd.run_all": docker_cmd_run_all_wrapper},
+            "__opts__": {},
+            "_utils__": {},
+        },
+    }
+
+
+@pytest.mark.slow_test
+def test_joined(rabbitmq_container):
+    """
+    Test rabbitmq_cluster.joined
+    """
+
+    hostname = rabbitmq_container.container.attrs["Config"]["Hostname"]
+    ret = rabbitmq_cluster.joined("name", host=hostname)
+    expected = {
+        "name": "name",
+        "result": True,
+        "comment": "Already in cluster",
+        "changes": {},
+    }
+    assert ret == expected

tests/pytests/functional/states/rabbitmq/test_plugin.py

@@ -0,0 +1,132 @@
+"""
+Integration tests for the rabbitmq_plugin states
+"""
+
+import logging
+
+import pytest
+import salt.modules.rabbitmq as rabbitmq
+import salt.states.rabbitmq_plugin as rabbitmq_plugin
+from tests.support.mock import patch
+
+log = logging.getLogger(__name__)
+
+pytestmark = [
+    pytest.mark.slow_test,
+    pytest.mark.skip_on_freebsd(reason="No Docker on FreeBSD available"),
+    pytest.mark.skip_if_binaries_missing(
+        "docker", "dockerd", message="Docker not installed"
+    ),
+]
+
+
+def mock_get_rabbitmq_plugin():
+    return "/opt/rabbitmq/sbin/rabbitmq-plugins"
+
+
+@pytest.fixture
+def configure_loader_modules(docker_cmd_run_all_wrapper):
+    return {
+        rabbitmq_plugin: {
+            "__salt__": {
+                "rabbitmq.plugin_is_enabled": rabbitmq.plugin_is_enabled,
+                "rabbitmq.enable_plugin": rabbitmq.enable_plugin,
+                "rabbitmq.disable_plugin": rabbitmq.disable_plugin,
+            },
+            "__opts__": {"test": False},
+            "_utils__": {},
+        },
+        rabbitmq: {
+            "__salt__": {"cmd.run_all": docker_cmd_run_all_wrapper},
+            "__opts__": {},
+            "_utils__": {},
+        },
+    }
+
+
+@pytest.mark.slow_test
+def test_enabled_enabled_disabled(rabbitmq_container):
+    """
+    Test rabbitmq_plugin.enabled and rabbitmq_plugin_disabled
+
+    First enable the plugin.
+
+    Second try to enable the plugin again.
+
+    Third, try to disable the plugin.
+    """
+
+    with patch.object(rabbitmq, "_get_rabbitmq_plugin", mock_get_rabbitmq_plugin):
+        # Enable the plugin
+        ret = rabbitmq_plugin.enabled("rabbitmq_auth_backend_http")
+        expected = {
+            "name": "rabbitmq_auth_backend_http",
+            "result": True,
+            "comment": "Plugin 'rabbitmq_auth_backend_http' was enabled.",
+            "changes": {"old": "", "new": "rabbitmq_auth_backend_http"},
+        }
+        assert ret == expected
+
+        # Try to enable the plugin again
+        ret = rabbitmq_plugin.enabled("rabbitmq_auth_backend_http")
+        expected = {
+            "name": "rabbitmq_auth_backend_http",
+            "result": True,
+            "comment": "Plugin 'rabbitmq_auth_backend_http' is already enabled.",
+            "changes": {},
+        }
+        assert ret == expected
+
+        # Disable the plugin
+        ret = rabbitmq_plugin.disabled("rabbitmq_auth_backend_http")
+        expected = {
+            "name": "rabbitmq_auth_backend_http",
+            "result": True,
+            "comment": "Plugin 'rabbitmq_auth_backend_http' was disabled.",
+            "changes": {"new": "", "old": "rabbitmq_auth_backend_http"},
+        }
+        assert ret == expected
+
+
+@pytest.mark.slow_test
+def test_disabled(rabbitmq_container):
+    """
+    Test rabbitmq_plugin.enabled and rabbitmq_plugin_disabled
+
+    First try to disable the plugin.
+
+    Second enable the plugin again.
+
+    Third disable the plugin.
+    """
+
+    with patch.object(rabbitmq, "_get_rabbitmq_plugin", mock_get_rabbitmq_plugin):
+        # Try to disable the plugin
+        ret = rabbitmq_plugin.disabled("rabbitmq_auth_backend_http")
+        expected = {
+            "name": "rabbitmq_auth_backend_http",
+            "result": True,
+            "comment": "Plugin 'rabbitmq_auth_backend_http' is already disabled.",
+            "changes": {},
+        }
+        assert ret == expected
+
+        # Enable the plugin
+        ret = rabbitmq_plugin.enabled("rabbitmq_auth_backend_http")
+        expected = {
+            "name": "rabbitmq_auth_backend_http",
+            "result": True,
+            "comment": "Plugin 'rabbitmq_auth_backend_http' was enabled.",
+            "changes": {"old": "", "new": "rabbitmq_auth_backend_http"},
+        }
+        assert ret == expected
+
+        # Disable the plugin
+        ret = rabbitmq_plugin.disabled("rabbitmq_auth_backend_http")
+        expected = {
+            "name": "rabbitmq_auth_backend_http",
+            "result": True,
+            "comment": "Plugin 'rabbitmq_auth_backend_http' was disabled.",
+            "changes": {"new": "", "old": "rabbitmq_auth_backend_http"},
+        }
+        assert ret == expected

tests/pytests/functional/states/rabbitmq/test_policy.py

@@ -0,0 +1,94 @@
+"""
+Integration tests for the rabbitmq_policy states
+"""
+
+import logging
+
+import pytest
+import salt.modules.rabbitmq as rabbitmq
+import salt.states.rabbitmq_policy as rabbitmq_policy
+from tests.support.mock import MagicMock, patch
+
+log = logging.getLogger(__name__)
+
+pytestmark = [
+    pytest.mark.slow_test,
+    pytest.mark.skip_on_freebsd(reason="No Docker on FreeBSD available"),
+    pytest.mark.skip_if_binaries_missing(
+        "docker", "dockerd", message="Docker not installed"
+    ),
+]
+
+
+@pytest.fixture
+def configure_loader_modules(docker_cmd_run_all_wrapper):
+    return {
+        rabbitmq_policy: {
+            "__salt__": {
+                "rabbitmq.set_policy": rabbitmq.set_policy,
+                "rabbitmq.delete_policy": rabbitmq.delete_policy,
+                "rabbitmq.policy_exists": rabbitmq.policy_exists,
+                "rabbitmq.list_policies": rabbitmq.list_policies,
+            },
+            "__opts__": {"test": False},
+            "_utils__": {},
+        },
+        rabbitmq: {
+            "__salt__": {
+                "rabbitmq.list_policies": rabbitmq.list_policies,
+                "cmd.run_all": docker_cmd_run_all_wrapper,
+            },
+            "__grains__": {"os_family": "Linux"},
+            "__opts__": {},
+            "_utils__": {},
+        },
+    }
+
+
+@pytest.mark.slow_test
+def test_present_absent(rabbitmq_container):
+    """
+    Test rabbitmq_policy.present and rabbitmq_policy.absent
+    """
+
+    with patch.dict(rabbitmq.__salt__, {"pkg.version": MagicMock(return_value="3.8")}):
+        # Clear the policy
+        ret = rabbitmq_policy.present(
+            name="HA", pattern=".*", definition={"ha-mode": "all"}
+        )
+        expected = {
+            "name": "HA",
+            "result": True,
+            "comment": 'Setting policy "HA" for pattern ".*" to "{"ha-mode": "all"}" with priority "0" for vhost "/" ...\n',
+            "changes": {"old": {}, "new": "HA"},
+        }
+        assert ret == expected
+
+        # Delete the policy
+        ret = rabbitmq_policy.absent("HA")
+        expected = {
+            "name": "HA",
+            "result": True,
+            "comment": "Deleted",
+            "changes": {"new": "", "old": "HA"},
+        }
+
+        assert ret == expected
+
+
+def test_absent(rabbitmq_container):
+    """
+    Test rabbitmq_policy.absent
+    """
+
+    with patch.dict(rabbitmq.__salt__, {"pkg.version": MagicMock(return_value="3.8")}):
+        # Delete the policy
+        ret = rabbitmq_policy.absent("HA")
+        expected = {
+            "name": "HA",
+            "result": True,
+            "comment": "Policy '/ HA' is not present.",
+            "changes": {},
+        }
+
+        assert ret == expected

tests/pytests/functional/states/rabbitmq/test_upstream.py

@@ -0,0 +1,54 @@
+"""
+Integration tests for the rabbitmq_user states
+"""
+
+import logging
+
+import pytest
+import salt.modules.rabbitmq as rabbitmq
+import salt.states.rabbitmq_upstream as rabbitmq_upstream
+
+log = logging.getLogger(__name__)
+
+pytestmark = [
+    pytest.mark.slow_test,
+    pytest.mark.skip_on_freebsd(reason="No Docker on FreeBSD available"),
+    pytest.mark.skip_if_binaries_missing(
+        "docker", "dockerd", message="Docker not installed"
+    ),
+]
+
+
+@pytest.fixture
+def configure_loader_modules(docker_cmd_run_all_wrapper):
+    return {
+        rabbitmq_upstream: {
+            "__salt__": {
+                "rabbitmq.upstream_exists": rabbitmq.upstream_exists,
+                "rabbitmq.list_user_permissions": rabbitmq.list_user_permissions,
+            },
+            "__opts__": {"test": False},
+            "_utils__": {},
+        },
+        rabbitmq: {
+            "__salt__": {"cmd.run_all": docker_cmd_run_all_wrapper},
+            "__opts__": {},
+            "_utils__": {},
+        },
+    }
+
+
+def test_absent(rabbitmq_container):
+    """
+    Test rabbitmq_upstream.absent
+    """
+
+    # Delete the user
+    ret = rabbitmq_upstream.absent("upstream")
+    expected = {
+        "name": "upstream",
+        "result": True,
+        "comment": 'The upstream "upstream" is already absent.',
+        "changes": {},
+    }
+    assert ret == expected

tests/pytests/functional/states/rabbitmq/test_user.py

@@ -0,0 +1,91 @@
+"""
+Integration tests for the rabbitmq_user states
+"""
+
+import logging
+
+import pytest
+import salt.modules.rabbitmq as rabbitmq
+import salt.states.rabbitmq_user as rabbitmq_user
+
+log = logging.getLogger(__name__)
+
+pytestmark = [
+    pytest.mark.slow_test,
+    pytest.mark.skip_on_freebsd(reason="No Docker on FreeBSD available"),
+    pytest.mark.skip_if_binaries_missing(
+        "docker", "dockerd", message="Docker not installed"
+    ),
+]
+
+
+@pytest.fixture
+def configure_loader_modules(docker_cmd_run_all_wrapper):
+    return {
+        rabbitmq_user: {
+            "__salt__": {
+                "rabbitmq.user_exists": rabbitmq.user_exists,
+                "rabbitmq.add_user": rabbitmq.add_user,
+                "rabbitmq.delete_user": rabbitmq.delete_user,
+                "rabbitmq.list_user_permissions": rabbitmq.list_user_permissions,
+            },
+            "__opts__": {"test": False},
+            "_utils__": {},
+        },
+        rabbitmq: {
+            "__salt__": {
+                "rabbitmq.user_exists": rabbitmq.user_exists,
+                "rabbitmq.add_user": rabbitmq.add_user,
+                "rabbitmq.list_user_permissions": rabbitmq.list_user_permissions,
+                "cmd.run_all": docker_cmd_run_all_wrapper,
+            },
+            "__opts__": {},
+            "_utils__": {},
+        },
+    }
+
+
+@pytest.mark.slow_test
+def test_present_absent(docker_cmd_run_all_wrapper, rabbitmq_container):
+    """
+    Test rabbitmq_user.present
+
+    Create user then delete it.
+    """
+
+    # Clear the user
+    ret = rabbitmq_user.present("myuser")
+    expected = {
+        "name": "myuser",
+        "result": True,
+        "comment": "'myuser' was configured.",
+        "changes": {"user": {"old": "", "new": "myuser"}},
+    }
+    assert ret == expected
+
+    # Delete the user
+    ret = rabbitmq_user.absent("myuser")
+    expected = {
+        "name": "myuser",
+        "result": True,
+        "comment": "The user 'myuser' was removed.",
+        "changes": {"name": {"old": "myuser", "new": ""}},
+    }
+
+    assert ret == expected
+
+
+def test_absent(docker_cmd_run_all_wrapper, rabbitmq_container):
+    """
+    Test rabbitmq_user.absent
+    """
+
+    # Delete the user
+    ret = rabbitmq_user.absent("myuser")
+    expected = {
+        "name": "myuser",
+        "result": True,
+        "comment": "The user 'myuser' is not present.",
+        "changes": {},
+    }
+    assert ret == expected

tests/pytests/functional/states/rabbitmq/test_vhost.py

@@ -0,0 +1,83 @@
+"""
+Integration tests for the rabbitmq_user states
+"""
+
+import logging
+
+import pytest
+import salt.modules.rabbitmq as rabbitmq
+import salt.states.rabbitmq_vhost as rabbitmq_vhost
+
+log = logging.getLogger(__name__)
+
+pytestmark = [
+    pytest.mark.slow_test,
+    pytest.mark.skip_on_freebsd(reason="No Docker on FreeBSD available"),
+    pytest.mark.skip_if_binaries_missing(
+        "docker", "dockerd", message="Docker not installed"
+    ),
+]
+
+
+@pytest.fixture
+def configure_loader_modules(docker_cmd_run_all_wrapper):
+    return {
+        rabbitmq_vhost: {
+            "__salt__": {
+                "rabbitmq.vhost_exists": rabbitmq.vhost_exists,
+                "rabbitmq.add_vhost": rabbitmq.add_vhost,
+                "rabbitmq.delete_vhost": rabbitmq.delete_vhost,
+            },
+            "__opts__": {"test": False},
+            "_utils__": {},
+        },
+        rabbitmq: {
+            "__salt__": {"cmd.run_all": docker_cmd_run_all_wrapper},
+            "__opts__": {},
+            "_utils__": {},
+        },
+    }
+
+
+@pytest.mark.slow_test
+def test_present_absent(docker_cmd_run_all_wrapper):
+    """
+    Test rabbitmq_vhost.present
+    """
+
+    # Clear the user
+    ret = rabbitmq_vhost.present("vhost")
+    expected = {
+        "name": "vhost",
+        "result": True,
+        "comment": 'Adding vhost "vhost" ...\n',
+        "changes": {"old": "", "new": "vhost"},
+    }
+    assert ret == expected
+
+    # Delete the user
+    ret = rabbitmq_vhost.absent("vhost")
+    expected = {
+        "name": "vhost",
+        "result": True,
+        "comment": 'Deleting vhost "vhost" ...\n',
+        "changes": {"old": "vhost", "new": ""},
+    }
+
+    assert ret == expected
+
+
+def test_absent(docker_cmd_run_all_wrapper):
+    """
+    Test rabbitmq_vhost.present
+    """
+
+    # Delete the user
+    ret = rabbitmq_vhost.absent("vhost")
+    expected = {
+        "name": "vhost",
+        "result": True,
+        "comment": "Virtual Host 'vhost' is not present.",
+        "changes": {},
+    }
+    assert ret == expected