deep_scrub_choked

tests/library/ca_test_common.py

@@ -0,0 +1,29 @@
+from ansible.module_utils import basic
+from ansible.module_utils._text import to_bytes
+import json
+
+
+def set_module_args(args):
+    if '_ansible_remote_tmp' not in args:
+        args['_ansible_remote_tmp'] = '/tmp'
+    if '_ansible_keep_remote_files' not in args:
+        args['_ansible_keep_remote_files'] = False
+
+    args = json.dumps({'ANSIBLE_MODULE_ARGS': args})
+    basic._ANSIBLE_ARGS = to_bytes(args)
+
+
+class AnsibleExitJson(Exception):
+    pass
+
+
+class AnsibleFailJson(Exception):
+    pass
+
+
+def exit_json(*args, **kwargs):
+    raise AnsibleExitJson(kwargs)
+
+
+def fail_json(*args, **kwargs):
+    raise AnsibleFailJson(kwargs)

tests/library/test_ceph_crush.py

@@ -0,0 +1,112 @@
+import sys
+import pytest
+
+sys.path.append('./library')
+import ceph_crush  # noqa: E402
+
+
+class TestCephCrushModule(object):
+
+    def test_no_host(self):
+        location = [
+            ("chassis", "monchassis"),
+            ("rack", "monrack"),
+            ("row", "marow"),
+            ("pdu", "monpdu"),
+            ("pod", "monpod"),
+            ("room", "maroom"),
+            ("datacenter", "mondc"),
+            ("region", "maregion"),
+            ("root", "maroute"),
+        ]
+        with pytest.raises(Exception):
+            ceph_crush.sort_osd_crush_location(location, None)
+
+    def test_lower_than_two_bucket(self):
+        location = [
+            ("chassis", "monchassis"),
+        ]
+        with pytest.raises(Exception):
+            ceph_crush.sort_osd_crush_location(location, None)
+
+    def test_invalid_bucket_type(self):
+        location = [
+            ("host", "monhost"),
+            ("chassis", "monchassis"),
+            ("rackyyyyy", "monrack"),
+        ]
+        with pytest.raises(Exception):
+            ceph_crush.sort_osd_crush_location(location, None)
+
+    def test_ordering(self):
+        expected_result = [
+            ("host", "monhost"),
+            ("chassis", "monchassis"),
+            ("rack", "monrack"),
+            ("row", "marow"),
+            ("pdu", "monpdu"),
+            ("pod", "monpod"),
+            ("room", "maroom"),
+            ("datacenter", "mondc"),
+            ("region", "maregion"),
+            ("root", "maroute"),
+        ]
+        expected_result_reverse = expected_result[::-1]
+        result = ceph_crush.sort_osd_crush_location(
+            expected_result_reverse, None)
+        assert expected_result == result
+
+    def test_generate_commands(self):
+        cluster = "test"
+        expected_command_list = [
+            ['ceph', '--cluster', cluster, 'osd',
+                'crush', "add-bucket", "monhost", "host"],
+            ['ceph', '--cluster', cluster, 'osd', 'crush',
+                "add-bucket", "monchassis", "chassis"],
+            ['ceph', '--cluster', cluster, 'osd', 'crush',
+                "move", "monhost", "chassis=monchassis"],
+            ['ceph', '--cluster', cluster, 'osd',
+                'crush', "add-bucket", "monrack", "rack"],
+            ['ceph', '--cluster', cluster, 'osd', 'crush',
+                "move", "monchassis", "rack=monrack"],
+        ]
+
+        location = [
+            ("host", "monhost"),
+            ("chassis", "monchassis"),
+            ("rack", "monrack"),
+        ]
+
+        crush_map = {"nodes": []}
+
+        result = ceph_crush.create_and_move_buckets_list(
+            cluster, location, crush_map)
+        assert result == expected_command_list
+
+    def test_generate_commands_container(self):
+        cluster = "test"
+        containerized = "docker exec -ti ceph-mon"
+        expected_command_list = [
+            ['docker', 'exec', '-ti', 'ceph-mon', 'ceph', '--cluster',
+                cluster, 'osd', 'crush', "add-bucket", "monhost", "host"],
+            ['docker', 'exec', '-ti', 'ceph-mon', 'ceph', '--cluster',
+                cluster, 'osd', 'crush', "add-bucket", "monchassis", "chassis"],
+            ['docker', 'exec', '-ti', 'ceph-mon', 'ceph', '--cluster', cluster,
+                'osd', 'crush', "move", "monhost", "chassis=monchassis"],
+            ['docker', 'exec', '-ti', 'ceph-mon', 'ceph', '--cluster',
+                cluster, 'osd', 'crush', "add-bucket", "monrack", "rack"],
+            ['docker', 'exec', '-ti', 'ceph-mon', 'ceph', '--cluster',
+                cluster, 'osd', 'crush', "move", "monchassis", "rack=monrack"],
+        ]
+
+        location = [
+            ("host", "monhost"),
+            ("chassis", "monchassis"),
+            ("rack", "monrack"),
+        ]
+
+        crush_map = {"nodes": []}
+
+        result = ceph_crush.create_and_move_buckets_list(
+            cluster, location, crush_map, containerized)
+        assert result == expected_command_list

tests/library/test_ceph_crush_rule.py

@@ -0,0 +1,439 @@
+from mock.mock import patch
+import os
+import pytest
+import ca_test_common
+import ceph_crush_rule
+import ceph_crush_rule_info
+
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'quay.io/ceph/daemon:latest'
+fake_name = 'foo'
+fake_bucket_root = 'default'
+fake_bucket_type = 'host'
+fake_device_class = 'ssd'
+fake_profile = 'default'
+fake_user = 'client.admin'
+fake_keyring = '/etc/ceph/{}.{}.keyring'.format(fake_cluster, fake_user)
+
+
+class TestCephCrushRuleModule(object):
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_with_name_only(self, m_fail_json):
+        ca_test_common.set_module_args({
+            'name': fake_name
+        })
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == 'state is present but all of the following are missing: rule_type'
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    def test_with_check_mode(self, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'rule_type': 'replicated',
+            'bucket_root': fake_bucket_root,
+            'bucket_type': fake_bucket_type,
+            '_ansible_check_mode': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['rc'] == 0
+        assert not result['stdout']
+        assert not result['stderr']
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_create_non_existing_replicated_rule(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'rule_type': 'replicated',
+            'bucket_root': fake_bucket_root,
+            'bucket_type': fake_bucket_type
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        get_rc = 2
+        get_stderr = 'Error ENOENT: unknown crush rule \'{}\''.format(fake_name)
+        get_stdout = ''
+        create_rc = 0
+        create_stderr = ''
+        create_stdout = ''
+        m_run_command.side_effect = [
+            (get_rc, get_stdout, get_stderr),
+            (create_rc, create_stdout, create_stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'create-replicated', fake_name, fake_bucket_root, fake_bucket_type]
+        assert result['rc'] == create_rc
+        assert result['stderr'] == create_stderr
+        assert result['stdout'] == create_stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_create_existing_replicated_rule(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'rule_type': 'replicated',
+            'bucket_root': fake_bucket_root,
+            'bucket_type': fake_bucket_type
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        rc = 0
+        stderr = ''
+        stdout = '{{"rule_name":"{}","type":1,"steps":[{{"item_name":"{}"}},{{"type":"{}"}}]}}'.format(fake_name, fake_bucket_root, fake_bucket_type)
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'dump', fake_name, '--format=json']
+        assert result['rc'] == 0
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_create_non_existing_replicated_rule_device_class(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'rule_type': 'replicated',
+            'bucket_root': fake_bucket_root,
+            'bucket_type': fake_bucket_type,
+            'device_class': fake_device_class
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        get_rc = 2
+        get_stderr = 'Error ENOENT: unknown crush rule \'{}\''.format(fake_name)
+        get_stdout = ''
+        create_rc = 0
+        create_stderr = ''
+        create_stdout = ''
+        m_run_command.side_effect = [
+            (get_rc, get_stdout, get_stderr),
+            (create_rc, create_stdout, create_stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'create-replicated', fake_name, fake_bucket_root, fake_bucket_type, fake_device_class]
+        assert result['rc'] == create_rc
+        assert result['stderr'] == create_stderr
+        assert result['stdout'] == create_stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_create_existing_replicated_rule_device_class(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'rule_type': 'replicated',
+            'bucket_root': fake_bucket_root,
+            'bucket_type': fake_bucket_type,
+            'device_class': fake_device_class
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        rc = 0
+        stderr = ''
+        stdout = '{{"rule_name":"{}","type":1,"steps":[{{"item_name":"{}"}},{{"type":"{}"}}]}}'.format(fake_name, fake_bucket_root, fake_bucket_type)
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'dump', fake_name, '--format=json']
+        assert result['rc'] == 0
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_create_non_existing_erasure_rule(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'rule_type': 'erasure',
+            'profile': fake_profile
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        get_rc = 2
+        get_stderr = 'Error ENOENT: unknown crush rule \'{}\''.format(fake_name)
+        get_stdout = ''
+        create_rc = 0
+        create_stderr = ''
+        create_stdout = 'created rule {} at 1'.format(fake_name)
+        m_run_command.side_effect = [
+            (get_rc, get_stdout, get_stderr),
+            (create_rc, create_stdout, create_stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'create-erasure', fake_name, fake_profile]
+        assert result['rc'] == create_rc
+        assert result['stderr'] == create_stderr
+        assert result['stdout'] == create_stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_create_existing_erasure_rule(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'rule_type': 'erasure',
+            'profile': fake_profile
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        rc = 0
+        stderr = ''
+        stdout = '{{"type":3,"rule_name":"{}","steps":[{{"item_name":"default"}},{{"type":"host"}}]}}'.format(fake_name)
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'dump', fake_name, '--format=json']
+        assert result['rc'] == 0
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_update_existing_replicated_rule(self, m_run_command, m_fail_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'rule_type': 'replicated',
+            'bucket_root': fake_bucket_root,
+            'bucket_type': fake_bucket_type,
+            'device_class': fake_device_class
+        })
+        m_fail_json.side_effect = ca_test_common.fail_json
+        rc = 0
+        stderr = ''
+        stdout = '{{"type":3,"rule_name":"{}","steps":[{{"item_name":"default"}},{{"type":"host"}}]}}'.format(fake_name)
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        print(result)
+        assert not result['changed']
+        assert result['msg'] == 'Can not convert crush rule {} to replicated'.format(fake_name)
+        assert result['rc'] == 1
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_update_existing_erasure_rule(self, m_run_command, m_fail_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'rule_type': 'erasure',
+            'profile': fake_profile
+        })
+        m_fail_json.side_effect = ca_test_common.fail_json
+        rc = 0
+        stderr = ''
+        stdout = '{{"type":1,"rule_name":"{}","steps":[{{"item_name":"default"}},{{"type":"host"}}]}}'.format(fake_name)
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        print(result)
+        assert not result['changed']
+        assert result['msg'] == 'Can not convert crush rule {} to erasure'.format(fake_name)
+        assert result['rc'] == 1
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_remove_non_existing_rule(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'state': 'absent'
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        rc = 2
+        stderr = 'Error ENOENT: unknown crush rule \'{}\''.format(fake_name)
+        stdout = ''
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'dump', fake_name, '--format=json']
+        assert result['rc'] == 0
+        assert result['stderr'] == stderr
+        assert result['stdout'] == "Crush Rule {} doesn't exist".format(fake_name)
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_remove_existing_rule(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'state': 'absent'
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        get_rc = 0
+        get_stderr = ''
+        get_stdout = '{{"rule_name":"{}","steps":[{{"item_name":"{}"}},{{"type":"{}"}}]}}'.format(fake_name, fake_bucket_root, fake_bucket_type)
+        remove_rc = 0
+        remove_stderr = ''
+        remove_stdout = ''
+        m_run_command.side_effect = [
+            (get_rc, get_stdout, get_stderr),
+            (remove_rc, remove_stdout, remove_stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'rm', fake_name]
+        assert result['rc'] == remove_rc
+        assert result['stderr'] == remove_stderr
+        assert result['stdout'] == remove_stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_get_non_existing_rule(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        rc = 2
+        stderr = 'Error ENOENT: unknown crush rule \'{}\''.format(fake_name)
+        stdout = ''
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule_info.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'dump', fake_name, '--format=json']
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_get_existing_rule(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        rc = 0
+        stderr = ''
+        stdout = '{{"rule_name":"{}","steps":[{{"item_name":"{}"}},{{"type":"{}"}}]}}'.format(fake_name, fake_bucket_root, fake_bucket_type)
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule_info.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'dump', fake_name, '--format=json']
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_get_all_rules(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': str(),
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        rc = 0
+        stderr = ''
+        stdout = '{{"rule_name":"{}","steps":[{{"item_name":"{}"}},{{"type":"{}"}}]}}'.format(fake_name, fake_bucket_root, fake_bucket_type)
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule_info.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush', 'rule',
+                                 'dump', '', '--format=json']
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_container(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        rc = 0
+        stderr = ''
+        stdout = '{{"rule_name":"{}","steps":[{{"item_name":"{}"}},{{"type":"{}"}}]}}'.format(fake_name, fake_bucket_root, fake_bucket_type)
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_crush_rule_info.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == [fake_container_binary, 'run', '--rm', '--net=host',
+                                 '-v', '/etc/ceph:/etc/ceph:z',
+                                 '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                 '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                 '--entrypoint=ceph', fake_container_image,
+                                 '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'crush',
+                                 'rule', 'dump', fake_name, '--format=json']
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout

tests/library/test_ceph_dashboard_user.py

@@ -0,0 +1,170 @@
+from mock.mock import MagicMock, patch
+import pytest
+import os
+import ca_test_common
+import ceph_dashboard_user
+
+fake_container_binary = 'podman'
+fake_container_image = 'docker.io/ceph/daemon:latest'
+
+
+class TestCephDashboardUserModule(object):
+    def setup_method(self):
+        self.fake_binary = 'ceph'
+        self.fake_cluster = 'ceph'
+        self.fake_name = 'foo'
+        self.fake_user = 'foo'
+        self.fake_password = 'bar'
+        self.fake_roles = ['read-only', 'block-manager']
+        self.fake_params = {'cluster': self.fake_cluster,
+                            'name': self.fake_user,
+                            'password': self.fake_password,
+                            'roles': self.fake_roles}
+        self.fake_module = MagicMock()
+        self.fake_module.params = self.fake_params
+
+    def test_create_user(self):
+        self.fake_module.params = self.fake_params
+        expected_cmd = [
+            self.fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', self.fake_cluster,
+            'dashboard', 'ac-user-create',
+            '-i', '-',
+            self.fake_user
+        ]
+
+        assert ceph_dashboard_user.create_user(self.fake_module) == expected_cmd
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    def test_create_user_container(self):
+        fake_container_cmd = [
+            fake_container_binary,
+            'run',
+            '--interactive',
+            '--rm',
+            '--net=host',
+            '-v', '/etc/ceph:/etc/ceph:z',
+            '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+            '-v', '/var/log/ceph/:/var/log/ceph/:z',
+            '--entrypoint=' + self.fake_binary,
+            fake_container_image
+        ]
+        self.fake_module.params = self.fake_params
+        expected_cmd = fake_container_cmd + [
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', self.fake_cluster,
+            'dashboard', 'ac-user-create',
+            '-i', '-',
+            self.fake_user
+        ]
+
+        assert ceph_dashboard_user.create_user(self.fake_module, container_image=fake_container_image) == expected_cmd
+
+    def test_set_roles(self):
+        self.fake_module.params = self.fake_params
+        expected_cmd = [
+            self.fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', self.fake_cluster,
+            'dashboard', 'ac-user-set-roles',
+            self.fake_user
+        ]
+        expected_cmd.extend(self.fake_roles)
+
+        assert ceph_dashboard_user.set_roles(self.fake_module) == expected_cmd
+
+    def test_set_password(self):
+        self.fake_module.params = self.fake_params
+        expected_cmd = [
+            self.fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', self.fake_cluster,
+            'dashboard', 'ac-user-set-password',
+            '-i', '-',
+            self.fake_user
+        ]
+
+        assert ceph_dashboard_user.set_password(self.fake_module) == expected_cmd
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    def test_set_password_container(self):
+        fake_container_cmd = [
+            fake_container_binary,
+            'run',
+            '--interactive',
+            '--rm',
+            '--net=host',
+            '-v', '/etc/ceph:/etc/ceph:z',
+            '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+            '-v', '/var/log/ceph/:/var/log/ceph/:z',
+            '--entrypoint=' + self.fake_binary,
+            fake_container_image
+        ]
+        self.fake_module.params = self.fake_params
+        expected_cmd = fake_container_cmd + [
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', self.fake_cluster,
+            'dashboard', 'ac-user-set-password',
+            '-i', '-',
+            self.fake_user
+        ]
+
+        assert ceph_dashboard_user.set_password(self.fake_module, container_image=fake_container_image) == expected_cmd
+
+    def test_get_user(self):
+        self.fake_module.params = self.fake_params
+        expected_cmd = [
+            self.fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', self.fake_cluster,
+            'dashboard', 'ac-user-show',
+            self.fake_user,
+            '--format=json'
+        ]
+
+        assert ceph_dashboard_user.get_user(self.fake_module) == expected_cmd
+
+    def test_remove_user(self):
+        self.fake_module.params = self.fake_params
+        expected_cmd = [
+            self.fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', self.fake_cluster,
+            'dashboard', 'ac-user-delete',
+            self.fake_user
+        ]
+
+        assert ceph_dashboard_user.remove_user(self.fake_module) == expected_cmd
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_create_user_fail_with_weak_password(self, m_run_command, m_fail_json):
+        ca_test_common.set_module_args(self.fake_module.params)
+        m_fail_json.side_effect = ca_test_common.fail_json
+        get_rc = 2
+        get_stderr = 'Error ENOENT: User {} does not exist.'.format(self.fake_user)
+        get_stdout = ''
+        create_rc = 22
+        create_stderr = 'Error EINVAL: Password is too weak.'
+        create_stdout = ''
+        m_run_command.side_effect = [
+            (get_rc, get_stdout, get_stderr),
+            (create_rc, create_stdout, create_stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_dashboard_user.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == create_stderr
+        assert result['rc'] == 1

tests/library/test_ceph_ec_profile.py

@@ -0,0 +1,243 @@
+from mock.mock import MagicMock, patch
+import ca_test_common
+import ceph_ec_profile
+import pytest
+
+
+class TestCephEcProfile(object):
+    def setup_method(self):
+        self.fake_params = []
+        self.fake_binary = 'ceph'
+        self.fake_cluster = 'ceph'
+        self.fake_name = 'foo'
+        self.fake_k = 2
+        self.fake_m = 4
+        self.fake_module = MagicMock()
+        self.fake_module.params = self.fake_params
+
+    def test_get_profile(self):
+        expected_cmd = [
+            self.fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', self.fake_cluster,
+            'osd', 'erasure-code-profile',
+            'get', self.fake_name,
+            '--format=json'
+        ]
+
+        assert ceph_ec_profile.get_profile(self.fake_name) == expected_cmd
+
+    @pytest.mark.parametrize("stripe_unit,crush_device_class,force", [(False, None, False),
+                                                                      (32, None, True),
+                                                                      (False, None, True),
+                                                                      (32, None, False),
+                                                                      (False, 'hdd', False),
+                                                                      (32, 'ssd', True),
+                                                                      (False, 'nvme', True),
+                                                                      (32, 'hdd', False)])
+    def test_create_profile(self, stripe_unit, crush_device_class, force):
+        expected_cmd = [
+            self.fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', self.fake_cluster,
+            'osd', 'erasure-code-profile',
+            'set', self.fake_name,
+            'k={}'.format(self.fake_k), 'm={}'.format(self.fake_m),
+        ]
+        if stripe_unit:
+            expected_cmd.append('stripe_unit={}'.format(stripe_unit))
+        if crush_device_class:
+            expected_cmd.append('crush-device-class={}'.format(crush_device_class))
+        if force:
+            expected_cmd.append('--force')
+
+        user_profile = {
+            "k": self.fake_k,
+            "m": self.fake_m
+        }
+
+        if stripe_unit:
+            user_profile["stripe_unit"] = stripe_unit
+        if crush_device_class:
+            user_profile["crush-device-class"] = crush_device_class
+
+        assert ceph_ec_profile.create_profile(self.fake_name,
+                                              user_profile,
+                                              force) == expected_cmd
+
+    def test_delete_profile(self):
+        expected_cmd = [
+            self.fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', self.fake_cluster,
+            'osd', 'erasure-code-profile',
+            'rm', self.fake_name
+            ]
+
+        assert ceph_ec_profile.delete_profile(self.fake_name,
+                                              self.fake_cluster) == expected_cmd
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ceph_ec_profile.exec_command')
+    def test_state_present_nothing_to_update(self, m_exec_command, m_exit_json, m_fail_json):
+        ca_test_common.set_module_args({"state": "present",
+                                        "name": "foo",
+                                        "k": 2,
+                                        "m": 4,
+                                        "stripe_unit": 32,
+                                        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        m_fail_json.side_effect = ca_test_common.fail_json
+        m_exec_command.return_value = (0,
+                                       ['ceph', 'osd', 'erasure-code-profile', 'get', 'foo', '--format', 'json'],
+                                       '{"crush-device-class":"","crush-failure-domain":"host","crush-root":"default","jerasure-per-chunk-alignment":"false","k":"2","m":"4","plugin":"jerasure","stripe_unit":"32","technique":"reed_sol_van","w":"8"}',  # noqa: E501
+                                       '')
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as r:
+            ceph_ec_profile.run_module()
+
+        result = r.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', 'osd', 'erasure-code-profile', 'get', 'foo', '--format', 'json']
+        assert result['stdout'] == '{"crush-device-class":"","crush-failure-domain":"host","crush-root":"default","jerasure-per-chunk-alignment":"false","k":"2","m":"4","plugin":"jerasure","stripe_unit":"32","technique":"reed_sol_van","w":"8"}'  # noqa: E501
+        assert not result['stderr']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ceph_ec_profile.exec_command')
+    def test_state_present_profile_to_update(self, m_exec_command, m_exit_json, m_fail_json):
+        ca_test_common.set_module_args({"state": "present",
+                                        "name": "foo",
+                                        "k": 2,
+                                        "m": 6,
+                                        "stripe_unit": 32
+                                        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        m_fail_json.side_effect = ca_test_common.fail_json
+        m_exec_command.side_effect = [
+                                       (0,
+                                        ['ceph', 'osd', 'erasure-code-profile', 'get', 'foo', '--format', 'json'],
+                                        '{"crush-device-class":"","crush-failure-domain":"host","crush-root":"default","jerasure-per-chunk-alignment":"false","k":"2","m":"4","plugin":"jerasure","stripe_unit":"32","technique":"reed_sol_van","w":"8"}',  # noqa: E501
+                                        ''),
+                                       (0,
+                                        ['ceph', 'osd', 'erasure-code-profile', 'set', 'foo', 'k=2', 'm=6', 'stripe_unit=32', '--force'],
+                                        '',
+                                        ''
+                                        )
+                                    ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as r:
+            ceph_ec_profile.run_module()
+
+        result = r.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', 'osd', 'erasure-code-profile', 'set', 'foo', 'k=2', 'm=6', 'stripe_unit=32', '--force']
+        assert not result['stdout']
+        assert not result['stderr']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ceph_ec_profile.exec_command')
+    def test_state_present_profile_doesnt_exist(self, m_exec_command, m_exit_json, m_fail_json):
+        ca_test_common.set_module_args({"state": "present",
+                                        "name": "foo",
+                                        "k": 2,
+                                        "m": 4,
+                                        "stripe_unit": 32
+                                        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        m_fail_json.side_effect = ca_test_common.fail_json
+        m_exec_command.side_effect = [
+                                       (2,
+                                        ['ceph', 'osd', 'erasure-code-profile', 'get', 'foo', '--format', 'json'],
+                                        '',
+                                        "Error ENOENT: unknown erasure code profile 'foo'"),
+                                       (0,
+                                        ['ceph', 'osd', 'erasure-code-profile', 'set', 'foo', 'k=2', 'm=4', 'stripe_unit=32', '--force'],
+                                        '',
+                                        ''
+                                        )
+                                    ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as r:
+            ceph_ec_profile.run_module()
+
+        result = r.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', 'osd', 'erasure-code-profile', 'set', 'foo', 'k=2', 'm=4', 'stripe_unit=32', '--force']
+        assert not result['stdout']
+        assert not result['stderr']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ceph_ec_profile.exec_command')
+    def test_state_absent_on_existing_profile(self, m_exec_command, m_exit_json, m_fail_json):
+        ca_test_common.set_module_args({"state": "absent",
+                                        "name": "foo"
+                                        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        m_fail_json.side_effect = ca_test_common.fail_json
+        m_exec_command.return_value = (0,
+                                       ['ceph', 'osd', 'erasure-code-profile', 'rm', 'foo'],
+                                       '',
+                                       '')
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as r:
+            ceph_ec_profile.run_module()
+
+        result = r.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', 'osd', 'erasure-code-profile', 'rm', 'foo']
+        assert result['stdout'] == 'Profile foo removed.'
+        assert not result['stderr']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ceph_ec_profile.exec_command')
+    def test_state_absent_on_nonexisting_profile(self, m_exec_command, m_exit_json, m_fail_json):
+        ca_test_common.set_module_args({"state": "absent",
+                                        "name": "foo"
+                                        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        m_fail_json.side_effect = ca_test_common.fail_json
+        m_exec_command.return_value = (0,
+                                       ['ceph', 'osd', 'erasure-code-profile', 'rm', 'foo'],
+                                       '',
+                                       'erasure-code-profile foo does not exist')
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as r:
+            ceph_ec_profile.run_module()
+
+        result = r.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', 'osd', 'erasure-code-profile', 'rm', 'foo']
+        assert result['stdout'] == "Skipping, the profile foo doesn't exist"
+        assert result['stderr'] == 'erasure-code-profile foo does not exist'
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    def test_check_mode(self, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': 'foo',
+            'k': 2,
+            'm': 4,
+            '_ansible_check_mode': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_ec_profile.run_module()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['rc'] == 0
+        assert not result['stdout']
+        assert not result['stderr']

tests/library/test_ceph_fs.py

@@ -0,0 +1,107 @@
+from mock.mock import MagicMock
+import ceph_fs
+
+
+fake_binary = 'ceph'
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'docker.io/ceph/daemon:latest'
+fake_container_cmd = [
+    fake_container_binary,
+    'run',
+    '--rm',
+    '--net=host',
+    '-v', '/etc/ceph:/etc/ceph:z',
+    '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+    '-v', '/var/log/ceph/:/var/log/ceph/:z',
+    '--entrypoint=' + fake_binary,
+    fake_container_image
+]
+fake_fs = 'foo'
+fake_data_pool = 'bar_data'
+fake_metadata_pool = 'bar_metadata'
+fake_max_mds = 2
+fake_params = {'cluster': fake_cluster,
+               'name': fake_fs,
+               'data': fake_data_pool,
+               'metadata': fake_metadata_pool,
+               'max_mds': fake_max_mds}
+
+
+class TestCephFsModule(object):
+
+    def test_create_fs(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', fake_cluster,
+            'fs', 'new',
+            fake_fs,
+            fake_metadata_pool,
+            fake_data_pool
+        ]
+
+        assert ceph_fs.create_fs(fake_module) == expected_cmd
+
+    def test_set_fs(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', fake_cluster,
+            'fs', 'set',
+            fake_fs,
+            'max_mds',
+            str(fake_max_mds)
+        ]
+
+        assert ceph_fs.set_fs(fake_module) == expected_cmd
+
+    def test_get_fs(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', fake_cluster,
+            'fs', 'get',
+            fake_fs,
+            '--format=json'
+        ]
+
+        assert ceph_fs.get_fs(fake_module) == expected_cmd
+
+    def test_remove_fs(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', fake_cluster,
+            'fs', 'rm',
+            fake_fs,
+            '--yes-i-really-mean-it'
+        ]
+
+        assert ceph_fs.remove_fs(fake_module) == expected_cmd
+
+    def test_fail_fs(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '-n', 'client.admin',
+            '-k', '/etc/ceph/ceph.client.admin.keyring',
+            '--cluster', fake_cluster,
+            'fs', 'fail',
+            fake_fs
+        ]
+
+        assert ceph_fs.fail_fs(fake_module) == expected_cmd

tests/library/test_ceph_key.py

@@ -0,0 +1,589 @@
+import json
+import os
+import mock
+import pytest
+import ca_test_common
+import ceph_key
+import ceph_key_info
+
+
+@mock.patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': 'docker'})
+class TestCephKeyModule(object):
+
+    def test_generate_secret(self):
+        expected_length = 40
+        result = len(ceph_key.generate_secret())
+        assert result == expected_length
+
+    def test_generate_caps_ceph_authtool(self):
+        fake_caps = {
+            'mon': 'allow *',
+            'osd': 'allow rwx',
+        }
+        fake_type = "ceph-authtool"
+        expected_command_list = [
+            '--cap',
+            'mon',
+            'allow *',
+            '--cap',
+            'osd',
+            'allow rwx'
+        ]
+        result = ceph_key.generate_caps(fake_type, fake_caps)
+        assert result == expected_command_list
+
+    def test_generate_caps_not_ceph_authtool(self):
+        fake_caps = {
+            'mon': 'allow *',
+            'osd': 'allow rwx',
+        }
+        fake_type = ""
+        expected_command_list = [
+            'mon',
+            'allow *',
+            'osd',
+            'allow rwx'
+        ]
+        result = ceph_key.generate_caps(fake_type, fake_caps)
+        assert result == expected_command_list
+
+    def test_generate_ceph_cmd_list_non_container(self):
+        fake_cluster = "fake"
+        fake_args = ['arg']
+        fake_user = "fake-user"
+        fake_user_key = "/tmp/my-key"
+        expected_command_list = [
+            'ceph',
+            '-n',
+            "fake-user",
+            '-k',
+            "/tmp/my-key",
+            '--cluster',
+            fake_cluster,
+            'auth',
+            'arg'
+        ]
+        result = ceph_key.generate_cmd(
+            sub_cmd=['auth'],
+            args=fake_args,
+            cluster=fake_cluster,
+            user=fake_user,
+            user_key=fake_user_key)
+        assert result == expected_command_list
+
+    def test_generate_ceph_cmd_list_container(self):
+        fake_cluster = "fake"
+        fake_args = ['arg']
+        fake_user = "fake-user"
+        fake_user_key = "/tmp/my-key"
+        fake_container_image = "quay.io/ceph/daemon:latest-luminous"
+        expected_command_list = ['docker',
+                                 'run',
+                                 '--rm',
+                                 '--net=host',  # noqa E501
+                                 '-v', '/etc/ceph:/etc/ceph:z',
+                                 '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                 '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                 '--entrypoint=ceph',
+                                 'quay.io/ceph/daemon:latest-luminous',
+                                 '-n',
+                                 "fake-user",
+                                 '-k',
+                                 "/tmp/my-key",
+                                 '--cluster',
+                                 fake_cluster,
+                                 'auth',
+                                 'arg']
+        result = ceph_key.generate_cmd(
+            sub_cmd=['auth'],
+            args=fake_args,
+            cluster=fake_cluster,
+            user=fake_user,
+            user_key=fake_user_key,
+            container_image=fake_container_image)
+        assert result == expected_command_list
+
+    def test_generate_ceph_authtool_cmd_non_container_no_auid(self):
+        fake_cluster = "fake"
+        fake_name = "client.fake"
+        fake_secret = "super-secret"
+        fake_caps = {
+            'mon': 'allow *',
+            'osd': 'allow rwx',
+        }
+        fake_dest = "/fake/ceph"
+        fake_keyring_filename = fake_cluster + "." + fake_name + ".keyring"
+        fake_file_destination = os.path.join(fake_dest, fake_keyring_filename)
+        expected_command_list = [
+            'ceph-authtool',
+            '--create-keyring',
+            fake_file_destination,
+            '--name',
+            fake_name,
+            '--add-key',
+            fake_secret,
+            '--cap',
+            'mon',
+            'allow *',
+            '--cap',
+            'osd',
+            'allow rwx',
+        ]
+        result = ceph_key.generate_ceph_authtool_cmd(
+            fake_cluster, fake_name, fake_secret, fake_caps, fake_file_destination)  # noqa E501
+        assert result == expected_command_list
+
+    def test_generate_ceph_authtool_cmd_container(self):
+        fake_cluster = "fake"
+        fake_name = "client.fake"
+        fake_secret = "super-secret"
+        fake_caps = {
+            'mon': 'allow *',
+            'osd': 'allow rwx',
+        }
+        fake_dest = "/fake/ceph"
+        fake_keyring_filename = fake_cluster + "." + fake_name + ".keyring"
+        fake_file_destination = os.path.join(fake_dest, fake_keyring_filename)
+        fake_container_image = "quay.io/ceph/daemon:latest-luminous"
+        expected_command_list = ['docker',
+                                 'run',
+                                 '--rm',
+                                 '--net=host',
+                                 '-v', '/etc/ceph:/etc/ceph:z',
+                                 '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                 '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                 '--entrypoint=ceph-authtool',
+                                 'quay.io/ceph/daemon:latest-luminous',
+                                 '--create-keyring',
+                                 fake_file_destination,
+                                 '--name',
+                                 fake_name,
+                                 '--add-key',
+                                 fake_secret,
+                                 '--cap',
+                                 'mon',
+                                 'allow *',
+                                 '--cap',
+                                 'osd',
+                                 'allow rwx']
+        result = ceph_key.generate_ceph_authtool_cmd(
+            fake_cluster, fake_name, fake_secret, fake_caps, fake_file_destination, fake_container_image)  # noqa E501
+        assert result == expected_command_list
+
+    def test_create_key_non_container(self):
+        fake_module = "fake"
+        fake_user = 'client.admin'
+        fake_user_key = '/etc/ceph/fake.client.admin.keyring'
+        fake_cluster = "fake"
+        fake_name = "client.fake"
+        fake_secret = "super-secret"
+        fake_caps = {
+            'mon': 'allow *',
+            'osd': 'allow rwx',
+        }
+        fake_import_key = True
+        fake_dest = "/fake/ceph"
+        fake_keyring_filename = fake_cluster + "." + fake_name + ".keyring"
+        fake_file_destination = os.path.join(fake_dest, fake_keyring_filename)
+        expected_command_list = [
+            ['ceph-authtool', '--create-keyring', fake_file_destination, '--name', fake_name,
+                '--add-key', fake_secret, '--cap', 'mon', 'allow *', '--cap', 'osd', 'allow rwx'],
+            ['ceph', '-n', fake_user, '-k', fake_user_key, '--cluster', fake_cluster, 'auth',
+                'import', '-i', fake_file_destination],
+        ]
+        result = ceph_key.create_key(fake_module, fake_cluster, fake_user, fake_user_key,
+                                     fake_name, fake_secret, fake_caps, fake_import_key,
+                                     fake_file_destination)
+        assert result == expected_command_list
+
+    def test_create_key_container(self):
+        fake_module = "fake"
+        fake_user = 'client.admin'
+        fake_user_key = '/etc/ceph/fake.client.admin.keyring'
+        fake_cluster = "fake"
+        fake_name = "client.fake"
+        fake_secret = "super-secret"
+        fake_caps = {
+            'mon': 'allow *',
+            'osd': 'allow rwx',
+        }
+        fake_dest = "/fake/ceph"
+        fake_import_key = True
+        fake_keyring_filename = fake_cluster + "." + fake_name + ".keyring"
+        fake_file_destination = os.path.join(fake_dest, fake_keyring_filename)
+        fake_container_image = "quay.io/ceph/daemon:latest-luminous"
+        expected_command_list = [
+            ['docker',
+             'run',
+             '--rm',
+             '--net=host',
+             '-v', '/etc/ceph:/etc/ceph:z',
+             '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+             '-v', '/var/log/ceph/:/var/log/ceph/:z',
+             '--entrypoint=ceph-authtool',
+             'quay.io/ceph/daemon:latest-luminous',
+             '--create-keyring', fake_file_destination,
+             '--name', fake_name,
+             '--add-key', fake_secret,
+             '--cap', 'mon', 'allow *',
+             '--cap', 'osd', 'allow rwx'],
+            ['docker',
+             'run',
+             '--rm',
+             '--net=host',
+             '-v', '/etc/ceph:/etc/ceph:z',
+             '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+             '-v', '/var/log/ceph/:/var/log/ceph/:z',
+             '--entrypoint=ceph',
+             'quay.io/ceph/daemon:latest-luminous',
+             '-n', 'client.admin',
+             '-k', '/etc/ceph/fake.client.admin.keyring',
+             '--cluster', fake_cluster,
+             'auth', 'import',
+             '-i', fake_file_destination]]
+        result = ceph_key.create_key(fake_module, fake_cluster, fake_user, fake_user_key, fake_name,
+                                     fake_secret, fake_caps, fake_import_key, fake_file_destination,
+                                     fake_container_image)
+        assert result == expected_command_list
+
+    def test_create_key_non_container_no_import(self):
+        fake_module = "fake"
+        fake_user = 'client.admin'
+        fake_user_key = '/etc/ceph/fake.client.admin.keyring'
+        fake_cluster = "fake"
+        fake_name = "client.fake"
+        fake_secret = "super-secret"
+        fake_caps = {
+            'mon': 'allow *',
+            'osd': 'allow rwx',
+        }
+        fake_dest = "/fake/ceph"
+        fake_import_key = False
+        fake_keyring_filename = fake_cluster + "." + fake_name + ".keyring"
+        fake_file_destination = os.path.join(fake_dest, fake_keyring_filename)
+        # create_key passes (one for ceph-authtool and one for itself) itw own array so the expected result is an array within an array # noqa E501
+        expected_command_list = [[
+            'ceph-authtool',
+            '--create-keyring',
+            fake_file_destination,
+            '--name',
+            fake_name,
+            '--add-key',
+            fake_secret,
+            '--cap',
+            'mon',
+            'allow *',
+            '--cap',
+            'osd',
+            'allow rwx', ]
+        ]
+        result = ceph_key.create_key(fake_module, fake_cluster, fake_user, fake_user_key,
+                                     fake_name, fake_secret, fake_caps, fake_import_key,
+                                     fake_file_destination)  # noqa E501
+        assert result == expected_command_list
+
+    def test_create_key_container_no_import(self):
+        fake_module = "fake"
+        fake_user = 'client.admin'
+        fake_user_key = '/etc/ceph/fake.client.admin.keyring'
+        fake_cluster = "fake"
+        fake_name = "client.fake"
+        fake_secret = "super-secret"
+        fake_caps = {
+            'mon': 'allow *',
+            'osd': 'allow rwx',
+        }
+        fake_dest = "/fake/ceph"
+        fake_import_key = False
+        fake_keyring_filename = fake_cluster + "." + fake_name + ".keyring"
+        fake_file_destination = os.path.join(fake_dest, fake_keyring_filename)
+        # create_key passes (one for ceph-authtool and one for itself) itw own array so the expected result is an array within an array # noqa E501
+        fake_container_image = "quay.io/ceph/daemon:latest-luminous"
+        expected_command_list = [['docker',   # noqa E128
+                                  'run',
+                                  '--rm',
+                                  '--net=host',
+                                  '-v', '/etc/ceph:/etc/ceph:z',
+                                  '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                  '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                  '--entrypoint=ceph-authtool',
+                                  'quay.io/ceph/daemon:latest-luminous',
+                                  '--create-keyring',
+                                  fake_file_destination,
+                                  '--name',
+                                  fake_name,
+                                  '--add-key',
+                                  fake_secret,
+                                  '--cap',
+                                  'mon',
+                                  'allow *',
+                                  '--cap',
+                                  'osd',
+                                  'allow rwx']]
+        result = ceph_key.create_key(fake_module, fake_cluster, fake_user, fake_user_key, fake_name,
+                                     fake_secret, fake_caps, fake_import_key, fake_file_destination,
+                                     fake_container_image)
+        assert result == expected_command_list
+
+    def test_delete_key_non_container(self):
+        fake_user = 'client.admin'
+        fake_user_key = '/etc/ceph/fake.client.admin.keyring'
+        fake_cluster = "fake"
+        fake_name = "client.fake"
+        expected_command_list = [
+            ['ceph',  '-n', 'client.admin', '-k', '/etc/ceph/fake.client.admin.keyring',
+                '--cluster', fake_cluster, 'auth', 'del', fake_name],
+        ]
+        result = ceph_key.delete_key(fake_cluster, fake_user, fake_user_key, fake_name)
+        assert result == expected_command_list
+
+    def test_delete_key_container(self):
+        fake_user = 'client.admin'
+        fake_user_key = '/etc/ceph/fake.client.admin.keyring'
+        fake_cluster = "fake"
+        fake_name = "client.fake"
+        fake_container_image = "quay.io/ceph/daemon:latest-luminous"
+        expected_command_list = [['docker',
+                                  'run',
+                                  '--rm',
+                                  '--net=host',
+                                  '-v', '/etc/ceph:/etc/ceph:z',
+                                  '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                  '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                  '--entrypoint=ceph',
+                                  'quay.io/ceph/daemon:latest-luminous',
+                                  '-n', 'client.admin',
+                                  '-k', '/etc/ceph/fake.client.admin.keyring',
+                                  '--cluster', fake_cluster,
+                                  'auth', 'del', fake_name]]
+        result = ceph_key.delete_key(
+            fake_cluster, fake_user, fake_user_key, fake_name, fake_container_image)
+        assert result == expected_command_list
+
+    @pytest.mark.parametrize('output_format', ['json', 'plain', 'xml', 'yaml'])
+    def test_info_key_non_container(self, output_format):
+        fake_user = 'client.admin'
+        fake_user_key = '/etc/ceph/fake.client.admin.keyring'
+        fake_cluster = "fake"
+        fake_name = "client.fake"
+        fake_user = "fake-user"
+        expected_command_list = [
+            ['ceph', '-n', fake_user, '-k', fake_user_key, '--cluster', fake_cluster, 'auth',
+                'get', fake_name, '-f', output_format],
+        ]
+        result = ceph_key.info_key(
+            fake_cluster, fake_name, fake_user, fake_user_key, output_format)
+        assert result == expected_command_list
+
+    @pytest.mark.parametrize('output_format', ['json', 'plain', 'xml', 'yaml'])
+    def test_info_key_container_json(self, output_format):
+        fake_cluster = "fake"
+        fake_name = "client.fake"
+        fake_user = 'client.admin'
+        fake_user_key = '/etc/ceph/fake.client.admin.keyring'
+        fake_container_image = "quay.io/ceph/daemon:latest-luminous"
+        expected_command_list = [['docker',   # noqa E128
+                                  'run',
+                                  '--rm',
+                                  '--net=host',
+                                  '-v', '/etc/ceph:/etc/ceph:z',
+                                  '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                  '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                  '--entrypoint=ceph',
+                                  'quay.io/ceph/daemon:latest-luminous',
+                                  '-n', fake_user,
+                                  '-k', fake_user_key,
+                                  '--cluster', fake_cluster,
+                                  'auth', 'get', fake_name,
+                                  '-f', output_format]]
+        result = ceph_key.info_key(
+            fake_cluster, fake_name, fake_user, fake_user_key, output_format, fake_container_image)  # noqa E501
+        assert result == expected_command_list
+
+    def test_list_key_non_container(self):
+        fake_cluster = "fake"
+        fake_user = "fake-user"
+        fake_key = "/tmp/my-key"
+        expected_command_list = [
+            ['ceph', '-n', "fake-user", '-k', "/tmp/my-key",
+                '--cluster', fake_cluster, 'auth', 'ls', '-f', 'json'],
+        ]
+        result = ceph_key.list_keys(fake_cluster, fake_user, fake_key)
+        assert result == expected_command_list
+
+    def test_get_key_container(self):
+        fake_cluster = "fake"
+        fake_user = 'client.admin'
+        fake_user_key = '/etc/ceph/fake.client.admin.keyring'
+        fake_name = "client.fake"
+        fake_container_image = "quay.io/ceph/daemon:latest-luminous"
+        fake_dest = "/fake/ceph"
+        fake_keyring_filename = fake_cluster + "." + fake_name + ".keyring"
+        fake_file_destination = os.path.join(fake_dest, fake_keyring_filename)
+        expected_command_list = [['docker',   # noqa E128
+                                  'run',
+                                  '--rm',
+                                  '--net=host',
+                                  '-v', '/etc/ceph:/etc/ceph:z',
+                                  '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                  '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                  '--entrypoint=ceph',
+                                  'quay.io/ceph/daemon:latest-luminous',
+                                  '-n', fake_user,
+                                  '-k', fake_user_key,
+                                  '--cluster', fake_cluster,
+                                  'auth', 'get',
+                                  fake_name, '-o', fake_file_destination]]
+        result = ceph_key.get_key(
+            fake_cluster, fake_user, fake_user_key, fake_name, fake_file_destination, fake_container_image)
+        assert result == expected_command_list
+
+    def test_get_key_non_container(self):
+        fake_cluster = "fake"
+        fake_user = 'client.admin'
+        fake_user_key = '/etc/ceph/fake.client.admin.keyring'
+        fake_dest = "/fake/ceph"
+        fake_name = "client.fake"
+        fake_keyring_filename = fake_cluster + "." + fake_name + ".keyring"
+        fake_file_destination = os.path.join(fake_dest, fake_keyring_filename)
+        expected_command_list = [
+            ['ceph', '-n', fake_user, '-k', fake_user_key,
+                '--cluster', fake_cluster, 'auth', 'get', fake_name, '-o', fake_file_destination],
+        ]
+        result = ceph_key.get_key(
+            fake_cluster, fake_user, fake_user_key, fake_name, fake_file_destination)
+        assert result == expected_command_list
+
+    def test_list_key_non_container_with_mon_key(self):
+        fake_hostname = "mon01"
+        fake_cluster = "fake"
+        fake_user = "mon."
+        fake_keyring_dirname = fake_cluster + "-" + fake_hostname
+        fake_key = os.path.join("/var/lib/ceph/mon/", fake_keyring_dirname, 'keyring')
+        expected_command_list = [
+            ['ceph', '-n', "mon.", '-k', "/var/lib/ceph/mon/fake-mon01/keyring",
+                '--cluster', fake_cluster, 'auth', 'ls', '-f', 'json'],
+        ]
+        result = ceph_key.list_keys(fake_cluster, fake_user, fake_key)
+        assert result == expected_command_list
+
+    def test_list_key_container_with_mon_key(self):
+        fake_hostname = "mon01"
+        fake_cluster = "fake"
+        fake_user = "mon."
+        fake_keyring_dirname = fake_cluster + "-" + fake_hostname
+        fake_key = os.path.join("/var/lib/ceph/mon/", fake_keyring_dirname, 'keyring')
+        fake_container_image = "quay.io/ceph/daemon:latest-luminous"
+        expected_command_list = [['docker',
+                                  'run',
+                                  '--rm',
+                                  '--net=host',
+                                  '-v', '/etc/ceph:/etc/ceph:z',
+                                  '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                  '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                  '--entrypoint=ceph',
+                                  'quay.io/ceph/daemon:latest-luminous',
+                                  '-n', "mon.",
+                                  '-k', "/var/lib/ceph/mon/fake-mon01/keyring",
+                                  '--cluster', fake_cluster,
+                                  'auth', 'ls',
+                                  '-f', 'json'], ]
+        result = ceph_key.list_keys(fake_cluster, fake_user, fake_key, fake_container_image)
+        assert result == expected_command_list
+
+    def test_list_key_container(self):
+        fake_cluster = "fake"
+        fake_user = "fake-user"
+        fake_key = "/tmp/my-key"
+        fake_container_image = "quay.io/ceph/daemon:latest-luminous"
+        expected_command_list = [['docker',
+                                  'run',
+                                  '--rm',
+                                  '--net=host',
+                                  '-v', '/etc/ceph:/etc/ceph:z',
+                                  '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                  '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                  '--entrypoint=ceph',
+                                  'quay.io/ceph/daemon:latest-luminous',
+                                  '-n', "fake-user",
+                                  '-k', "/tmp/my-key",
+                                  '--cluster', fake_cluster,
+                                  'auth', 'ls',
+                                  '-f', 'json'], ]
+        result = ceph_key.list_keys(
+            fake_cluster, fake_user, fake_key, fake_container_image)
+        assert result == expected_command_list
+
+    def test_lookup_ceph_initial_entities(self):
+        fake_module = "fake"
+        fake_ceph_dict = { "auth_dump":[ { "entity":"osd.0", "key":"AQAJkMhbszeBBBAA4/V1tDFXGlft1GnHJS5wWg==", "caps":{ "mgr":"allow profile osd", "mon":"allow profile osd", "osd":"allow *" } }, { "entity":"osd.1", "key":"AQAjkMhbshueAhAAjZec50aBgd1NObLz57SQvg==", "caps":{ "mgr":"allow profile osd", "mon":"allow profile osd", "osd":"allow *" } }, { "entity":"client.admin", "key":"AQDZjshbrJv6EhAAY9v6LzLYNDpPdlC3HD5KHA==", "auid":0, "caps":{ "mds":"allow", "mgr":"allow *", "mon":"allow *", "osd":"allow *" } }, { "entity":"client.bootstrap-mds", "key":"AQDojshbc4QCHhAA1ZTrkt9dbSZRVU2GzI6U4A==", "caps":{ "mon":"allow profile bootstrap-mds" } }, { "entity":"client.bootstrap-mgr", "key":"AQBfiu5bAAAAABAARcNG24hUMlk4AdstVA5MVQ==", "caps":{ "mon":"allow profile bootstrap-mgr" } }, { "entity":"client.bootstrap-osd", "key":"AQDjjshbYW+uGxAAyHcPCXXmVoL8VsTBI8z1Ng==", "caps":{ "mon":"allow profile bootstrap-osd" } }, { "entity":"client.bootstrap-rbd", "key":"AQDyjshb522eIhAAtAz6nUPMOdG4H9u0NgpXhA==", "caps":{ "mon":"allow profile bootstrap-rbd" } }, { "entity":"client.bootstrap-rbd-mirror", "key":"AQDfh+5bAAAAABAAEGBD59Lj2vAKIdN8pq4lbQ==", "caps":{ "mon":"allow profile bootstrap-rbd-mirror" } }, { "entity":"client.bootstrap-rgw", "key":"AQDtjshbDl8oIBAAq1SfSYQKDR49hJNWJVwDQw==", "caps":{ "mon":"allow profile bootstrap-rgw" } }, { "entity":"mgr.mon0", "key":"AQA0j8hbgGapORAAoDkyAvXVkM5ej4wNn4cwTQ==", "caps":{ "mds":"allow *", "mon":"allow profile mgr", "osd":"allow *" } } ] }  # noqa E501
+        fake_ceph_dict_str = json.dumps(fake_ceph_dict)  # convert to string
+        expected_entity_list = ['client.admin', 'client.bootstrap-mds', 'client.bootstrap-mgr',  # noqa E501
+                     'client.bootstrap-osd', 'client.bootstrap-rbd', 'client.bootstrap-rbd-mirror', 'client.bootstrap-rgw']  # noqa E501
+        result = ceph_key.lookup_ceph_initial_entities(fake_module, fake_ceph_dict_str)
+        assert result == expected_entity_list
+
+    def test_build_key_path_admin(self):
+        fake_cluster = "fake"
+        entity = "client.admin"
+        expected_result = "/etc/ceph/fake.client.admin.keyring"
+        result = ceph_key.build_key_path(fake_cluster, entity)
+        assert result == expected_result
+
+    def test_build_key_path_bootstrap_osd(self):
+        fake_cluster = "fake"
+        entity = "client.bootstrap-osd"
+        expected_result = "/var/lib/ceph/bootstrap-osd/fake.keyring"
+        result = ceph_key.build_key_path(fake_cluster, entity)
+        assert result == expected_result
+
+    @mock.patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @mock.patch('ceph_key_info.exec_commands')
+    @pytest.mark.parametrize('output_format', ['json', 'plain', 'xml', 'yaml'])
+    def test_state_info(self, m_exec_commands, m_exit_json, output_format):
+        ca_test_common.set_module_args({"state": "info",
+                                        "cluster": "ceph",
+                                        "name": "client.admin",
+                                        "output_format": output_format})
+        m_exit_json.side_effect = ca_test_common.exit_json
+        m_exec_commands.return_value = (0,
+                                        ['ceph', 'auth', 'get', 'client.admin', '-f', output_format],
+                                        '[{"entity":"client.admin","key":"AQC1tw5fF156GhAAoJCvHGX/jl/k7/N4VZm8iQ==","caps":{"mds":"allow *","mgr":"allow *","mon":"allow *","osd":"allow *"}}]',  # noqa: E501
+                                        'exported keyring for client.admin')
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_key_info.run_module()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', 'auth', 'get', 'client.admin', '-f', output_format]
+        assert result['stdout'] == '[{"entity":"client.admin","key":"AQC1tw5fF156GhAAoJCvHGX/jl/k7/N4VZm8iQ==","caps":{"mds":"allow *","mgr":"allow *","mon":"allow *","osd":"allow *"}}]'  # noqa: E501
+        assert result['stderr'] == 'exported keyring for client.admin'
+        assert result['rc'] == 0
+
+    @mock.patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_state_info_invalid_format(self, m_fail_json):
+        invalid_format = 'txt'
+        ca_test_common.set_module_args({"state": "info",
+                                        "cluster": "ceph",
+                                        "name": "client.admin",
+                                        "output_format": invalid_format})
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_key_info.run_module()
+
+        result = result.value.args[0]
+        assert result['msg'] == 'value of output_format must be one of: json, plain, xml, yaml, got: {}'.format(invalid_format)
+
+    @mock.patch('ceph_key.generate_secret')
+    @mock.patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    def test_generate_key(self, m_exit_json, m_generate_secret):
+        fake_secret = b'AQDaLb1fAAAAABAAsIMKdGEKu+lGOyXnRfT0Hg=='
+        ca_test_common.set_module_args({"state": "generate_secret"})
+        m_exit_json.side_effect = ca_test_common.exit_json
+        m_generate_secret.return_value = fake_secret
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_key.run_module()
+        assert result.value.args[0]['stdout'] == fake_secret.decode()

tests/library/test_ceph_mgr_module.py

@@ -0,0 +1,162 @@
+from mock.mock import patch
+import os
+import pytest
+import ca_test_common
+import ceph_mgr_module
+
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'quay.io/ceph/daemon:latest'
+fake_module = 'noup'
+fake_user = 'client.admin'
+fake_keyring = '/etc/ceph/{}.{}.keyring'.format(fake_cluster, fake_user)
+
+
+class TestCephMgrModuleModule(object):
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_without_parameters(self, m_fail_json):
+        ca_test_common.set_module_args({})
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_mgr_module.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == 'missing required arguments: name'
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    def test_with_check_mode(self, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_module,
+            '_ansible_check_mode': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_mgr_module.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'mgr', 'module', 'enable', fake_module]
+        assert result['rc'] == 0
+        assert not result['stdout']
+        assert not result['stderr']
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_failure(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_module
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = 'Error ENOENT: all mgr daemons do not support module \'{}\', pass --force to force enablement'.format(fake_module)
+        rc = 2
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_mgr_module.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'mgr', 'module', 'enable', fake_module]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_enable_module(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_module,
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_mgr_module.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'mgr', 'module', 'enable', fake_module]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_already_enable_module(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_module,
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stderr = 'module \'{}\' is already enabled'.format(fake_module)
+        stdout = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_mgr_module.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'mgr', 'module', 'enable', fake_module]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_disable_module(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_module,
+            'state': 'disable'
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_mgr_module.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'mgr', 'module', 'disable', fake_module]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_container(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_module,
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = '{} is set'.format(fake_module)
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_mgr_module.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == [fake_container_binary, 'run', '--rm', '--net=host',
+                                 '-v', '/etc/ceph:/etc/ceph:z',
+                                 '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                 '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                 '--entrypoint=ceph', fake_container_image,
+                                 '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'mgr', 'module', 'enable', fake_module]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout

tests/library/test_ceph_osd.py

@@ -0,0 +1,244 @@
+from mock.mock import patch
+import os
+import pytest
+import ca_test_common
+import ceph_osd
+
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'quay.io/ceph/daemon:latest'
+fake_id = '42'
+fake_ids = ['0', '7', '13']
+fake_user = 'client.admin'
+fake_keyring = '/etc/ceph/{}.{}.keyring'.format(fake_cluster, fake_user)
+invalid_state = 'foo'
+
+
+class TestCephOSDModule(object):
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_without_parameters(self, m_fail_json):
+        ca_test_common.set_module_args({})
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_osd.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == 'missing required arguments: ids, state'
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_with_invalid_state(self, m_fail_json):
+        ca_test_common.set_module_args({
+            'ids': fake_id,
+            'state': invalid_state,
+        })
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_osd.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == ('value of state must be one of: destroy, down, '
+                                 'in, out, purge, rm, got: {}'.format(invalid_state))
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    def test_with_check_mode(self, m_exit_json):
+        ca_test_common.set_module_args({
+            'ids': fake_id,
+            'state': 'rm',
+            '_ansible_check_mode': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'osd', 'rm', fake_id]
+        assert result['rc'] == 0
+        assert not result['stdout']
+        assert not result['stderr']
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_failure(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'ids': fake_id,
+            'state': 'rm'
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = 'Error EBUSY: osd.{} is still up; must be down before removal.'.format(fake_id)
+        rc = 16
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'osd', 'rm', fake_id]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    @pytest.mark.parametrize('state', ['destroy', 'down', 'in', 'out', 'purge', 'rm'])
+    def test_set_state(self, m_run_command, m_exit_json, state):
+        ca_test_common.set_module_args({
+            'ids': fake_id,
+            'state': state
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = 'marked {} osd.{}'.format(state, fake_id)
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+        cmd = ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'osd', state, fake_id]
+        if state in ['destroy', 'purge']:
+            cmd.append('--yes-i-really-mean-it')
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == cmd
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    @pytest.mark.parametrize('state', ['down', 'in', 'out', 'rm'])
+    def test_set_state_multiple_ids(self, m_run_command, m_exit_json, state):
+        ca_test_common.set_module_args({
+            'ids': fake_ids,
+            'state': state
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stderr = ''
+        stdout = ''
+        for osd in fake_ids:
+            stderr += 'marked {} osd.{} '.format(state, osd)
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+        cmd = ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'osd', state]
+        cmd.extend(fake_ids)
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == cmd
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    @pytest.mark.parametrize('state', ['destroy', 'purge'])
+    def test_invalid_state_multiple_ids(self, m_run_command, m_fail_json, state):
+        ca_test_common.set_module_args({
+            'ids': fake_ids,
+            'state': state
+        })
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_osd.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == 'destroy and purge only support one OSD at at time'
+        assert result['rc'] == 1
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    @pytest.mark.parametrize('state', ['down', 'in', 'out'])
+    def test_already_set_state(self, m_run_command, m_exit_json, state):
+        ca_test_common.set_module_args({
+            'ids': fake_id,
+            'state': state
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = 'osd.{} is already {}.'.format(fake_id, state)
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+        cmd = ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'osd', state, fake_id]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == cmd
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    @pytest.mark.parametrize('state', ['down', 'in', 'out', 'rm'])
+    def test_one_already_set_state_multiple_ids(self, m_run_command, m_exit_json, state):
+        ca_test_common.set_module_args({
+            'ids': fake_ids,
+            'state': state
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = 'marked {} osd.{}. osd.{} does not exist. osd.{} does not exist.'.format(state, fake_ids[0], fake_ids[1], fake_ids[2])
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+        cmd = ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'osd', state]
+        cmd.extend(fake_ids)
+        if state in ['destroy', 'purge']:
+            cmd.append('--yes-i-really-mean-it')
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == cmd
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    @pytest.mark.parametrize('state', ['destroy', 'down', 'in', 'out', 'purge', 'rm'])
+    def test_set_state_with_container(self, m_run_command, m_exit_json, state):
+        ca_test_common.set_module_args({
+            'ids': fake_id,
+            'state': state
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = 'marked {} osd.{}'.format(state, fake_id)
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+        cmd = [fake_container_binary, 'run', '--rm', '--net=host',
+               '-v', '/etc/ceph:/etc/ceph:z',
+               '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+               '-v', '/var/log/ceph/:/var/log/ceph/:z',
+               '--entrypoint=ceph', fake_container_image,
+               '-n', fake_user, '-k', fake_keyring,
+               '--cluster', fake_cluster, 'osd', state, fake_id]
+        if state in ['destroy', 'purge']:
+            cmd.append('--yes-i-really-mean-it')
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == cmd
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout

tests/library/test_ceph_osd_flag.py

@@ -0,0 +1,156 @@
+from mock.mock import patch
+import os
+import pytest
+import ca_test_common
+import ceph_osd_flag
+
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'quay.io/ceph/daemon:latest'
+fake_flag = 'noup'
+fake_user = 'client.admin'
+fake_keyring = '/etc/ceph/{}.{}.keyring'.format(fake_cluster, fake_user)
+invalid_flag = 'nofoo'
+
+
+class TestCephOSDFlagModule(object):
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_without_parameters(self, m_fail_json):
+        ca_test_common.set_module_args({})
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_osd_flag.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == 'missing required arguments: name'
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_with_invalid_flag(self, m_fail_json):
+        ca_test_common.set_module_args({
+            'name': invalid_flag,
+        })
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_osd_flag.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == ('value of name must be one of: noup, nodown, '
+                                 'noout, nobackfill, norebalance, norecover, '
+                                 'noscrub, nodeep-scrub, noautoscale, got: {}'.format(invalid_flag))
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    def test_with_check_mode(self, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_flag,
+            '_ansible_check_mode': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd_flag.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'osd', 'set', fake_flag]
+        assert result['rc'] == 0
+        assert not result['stdout']
+        assert not result['stderr']
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_failure(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_flag
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = 'Error EINVAL: invalid command'
+        rc = 22
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd_flag.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'osd', 'set', fake_flag]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_set_flag(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_flag,
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = '{} is set'.format(fake_flag)
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd_flag.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'osd', 'set', fake_flag]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_unset_flag(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_flag,
+            'state': 'absent'
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = '{} is unset'.format(fake_flag)
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd_flag.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph', '-n', fake_user, '-k', fake_keyring, '--cluster', fake_cluster, 'osd', 'unset', fake_flag]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_container(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_flag,
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = '{} is set'.format(fake_flag)
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_osd_flag.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == [fake_container_binary, 'run', '--rm', '--net=host',
+                                 '-v', '/etc/ceph:/etc/ceph:z',
+                                 '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                 '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                 '--entrypoint=ceph', fake_container_image,
+                                 '-n', fake_user, '-k', fake_keyring,
+                                 '--cluster', fake_cluster, 'osd', 'set', fake_flag]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout

tests/library/test_ceph_pool.py

@@ -0,0 +1,763 @@
+import os
+import sys
+import ceph_pool
+from mock.mock import patch
+import pytest
+
+sys.path.append('./library')
+fake_user = 'client.admin'
+fake_user_key = '/etc/ceph/ceph.client.admin.keyring'
+fake_pool_name = 'foo'
+fake_cluster_name = 'ceph'
+fake_container_image_name = 'quay.io/ceph/daemon:latest-luminous'
+
+
+@patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': 'podman'})
+class TestCephPoolModule(object):
+    def setup_method(self):
+        self.fake_running_pool_details = {
+            'pool_id': 39,
+            'pool_name': 'foo2',
+            'create_time': '2020-05-12T12:32:03.696673+0000',
+            'flags': 32769,
+            'flags_names': 'hashpspool,creating',
+            'type': 1,
+            'size': 2,
+            'min_size': 1,
+            'crush_rule': 'replicated_rule',
+            'object_hash': 2,
+            'pg_autoscale_mode': 'on',
+            'pg_num': 32,
+            'pg_placement_num': 32,
+            'pg_placement_num_target': 32,
+            'pg_num_target': 32,
+            'pg_num_pending': 32,
+            'last_pg_merge_meta': {
+                'source_pgid': '0.0',
+                'ready_epoch': 0,
+                'last_epoch_started': 0,
+                'last_epoch_clean': 0,
+                'source_version': "0'0",
+                'target_version': "0'0"
+            },
+            'last_change': '109',
+            'last_force_op_resend': '0',
+            'last_force_op_resend_prenautilus': '0',
+            'last_force_op_resend_preluminous': '0',
+            'auid': 0,
+            'snap_mode': 'selfmanaged',
+            'snap_seq': 0,
+            'snap_epoch': 0,
+            'pool_snaps': [],
+            'removed_snaps': '[]',
+            'quota_max_bytes': 0,
+            'quota_max_objects': 0,
+            'tiers': [],
+            'tier_of': -1,
+            'read_tier': -1,
+            'write_tier': -1,
+            'cache_mode': 'none',
+            'target_max_bytes': 0,
+            'target_max_objects': 0,
+            'cache_target_dirty_ratio_micro': 400000,
+            'cache_target_dirty_high_ratio_micro': 600000,
+            'cache_target_full_ratio_micro': 800000,
+            'cache_min_flush_age': 0,
+            'cache_min_evict_age': 0,
+            'erasure_code_profile': '',
+            'hit_set_params': {
+                'type': 'none'
+            },
+            'hit_set_period': 0,
+            'hit_set_count': 0,
+            'use_gmt_hitset': True,
+            'min_read_recency_for_promote': 0,
+            'min_write_recency_for_promote': 0,
+            'hit_set_grade_decay_rate': 0,
+            'hit_set_search_last_n': 0,
+            'grade_table': [],
+            'stripe_width': 0,
+            'expected_num_objects': 0,
+            'fast_read': False,
+            'options': {},
+            # 'target_size_ratio' is a key present in the dict above
+            # 'options': {}
+            # see comment in get_pool_details() for more details
+            'target_size_ratio': 0.3,
+            'application_metadata': {
+                'rbd': {}
+            },
+            'application': 'rbd'
+            }
+        self.fake_user_pool_config = {
+            'pool_name': {
+                'value': 'foo2'
+            },
+            'pg_num': {
+                'value': '32',
+                'cli_set_opt': 'pg_num'
+            },
+            'pgp_num': {
+                'value': '0',
+                'cli_set_opt': 'pgp_num'
+            },
+            'pg_autoscale_mode': {
+                'value': 'on',
+                'cli_set_opt': 'pg_autoscale_mode'
+            },
+            'target_size_ratio': {
+                'value': '0.3',
+                'cli_set_opt': 'target_size_ratio'
+            },
+            'application': {
+                'value': 'rbd'
+            },
+            'type': {
+                'value': 'replicated'
+            },
+            'erasure_profile': {
+                'value': 'default'
+            },
+            'crush_rule': {
+                'value': 'replicated_rule',
+                'cli_set_opt': 'crush_rule'
+            },
+            'expected_num_objects': {
+                'value': '0'
+            },
+            'size': {
+                'value': '2',
+                'cli_set_opt': 'size'
+            },
+            'min_size': {
+                'value': '0',
+                'cli_set_opt': 'min_size'
+            },
+            'pg_placement_num': {
+                'value': '32',
+                'cli_set_opt': 'pgp_num'
+            }}
+
+    def test_check_pool_exist(self):
+        expected_command_list = [
+            'podman',
+            'run',
+            '--rm',
+            '--net=host',
+            '-v',
+            '/etc/ceph:/etc/ceph:z',
+            '-v',
+            '/var/lib/ceph/:/var/lib/ceph/:z',
+            '-v',
+            '/var/log/ceph/:/var/log/ceph/:z',
+            '--entrypoint=ceph',
+            fake_container_image_name,
+            '-n',
+            fake_user,
+            '-k',
+            fake_user_key,
+            '--cluster',
+            'ceph',
+            'osd',
+            'pool',
+            'stats',
+            self.fake_user_pool_config['pool_name']['value'],
+            '-f',
+            'json'
+            ]
+
+        cmd = ceph_pool.check_pool_exist(fake_cluster_name,
+                                         self.fake_user_pool_config['pool_name']['value'],
+                                         fake_user, fake_user_key, output_format='json',
+                                         container_image=fake_container_image_name)
+        assert cmd == expected_command_list
+
+    def test_get_default_running_config(self):
+        params = ['osd_pool_default_size',
+                  'osd_pool_default_min_size',
+                  'osd_pool_default_pg_num',
+                  'osd_pool_default_pgp_num']
+
+        expected_command_list = []
+        cmd_list = []
+
+        for param in params:
+            expected_command_list.append([
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'config',
+                'get',
+                'mon.*',
+                param
+            ])
+            cmd_list.append(ceph_pool.generate_get_config_cmd(param,
+                                                              fake_cluster_name,
+                                                              fake_user, fake_user_key,
+                                                              container_image=fake_container_image_name))
+        assert cmd_list == expected_command_list
+
+    def test_get_application_pool(self):
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'application',
+                'get',
+                self.fake_user_pool_config['pool_name']['value'],
+                '-f',
+                'json'
+        ]
+
+        cmd = ceph_pool.get_application_pool(fake_cluster_name,
+                                             self.fake_user_pool_config['pool_name']['value'],
+                                             fake_user, fake_user_key, 'json',
+                                             container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    def test_get_crush_rule_pool(self):
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'get',
+                self.fake_user_pool_config['pool_name']['value'],
+                'crush_rule',
+                '-f',
+                'json'
+        ]
+
+        cmd = ceph_pool.get_crush_rule_pool(fake_cluster_name,
+                                            self.fake_user_pool_config['pool_name']['value'],
+                                            fake_user, fake_user_key, 'json',
+                                            container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    def test_enable_application_pool(self):
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'application',
+                'enable',
+                self.fake_user_pool_config['pool_name']['value'],
+                'rbd'
+        ]
+
+        cmd = ceph_pool.enable_application_pool(fake_cluster_name,
+                                                self.fake_user_pool_config['pool_name']['value'],
+                                                'rbd', fake_user, fake_user_key,
+                                                container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    @pytest.mark.parametrize("container_image", [None, fake_container_image_name])
+    def test_init_rbd_pool(self, container_image):
+        if container_image:
+            expected_command = [
+                    'podman',
+                    'run',
+                    '--rm',
+                    '--net=host',
+                    '-v',
+                    '/etc/ceph:/etc/ceph:z',
+                    '-v',
+                    '/var/lib/ceph/:/var/lib/ceph/:z',
+                    '-v',
+                    '/var/log/ceph/:/var/log/ceph/:z',
+                    '--entrypoint=rbd',
+                    fake_container_image_name,
+                    '-n',
+                    fake_user,
+                    '-k',
+                    fake_user_key,
+                    '--cluster',
+                    fake_cluster_name,
+                    'pool',
+                    'init',
+                    self.fake_user_pool_config['pool_name']['value']
+            ]
+        else:
+            expected_command = [
+                    'rbd',
+                    '-n',
+                    fake_user,
+                    '-k',
+                    fake_user_key,
+                    '--cluster',
+                    fake_cluster_name,
+                    'pool',
+                    'init',
+                    self.fake_user_pool_config['pool_name']['value']
+            ]
+
+        cmd = ceph_pool.init_rbd_pool(fake_cluster_name,
+                                      self.fake_user_pool_config['pool_name']['value'],
+                                      fake_user, fake_user_key,
+                                      container_image)
+
+        assert cmd == expected_command
+
+    def test_disable_application_pool(self):
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'application',
+                'disable',
+                self.fake_user_pool_config['pool_name']['value'],
+                'rbd',
+                '--yes-i-really-mean-it'
+        ]
+
+        cmd = ceph_pool.disable_application_pool(fake_cluster_name,
+                                                 self.fake_user_pool_config['pool_name']['value'],
+                                                 'rbd', fake_user, fake_user_key,
+                                                 container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    def test_compare_pool_config_no_diff(self):
+        delta = ceph_pool.compare_pool_config(self.fake_user_pool_config, self.fake_running_pool_details)
+
+        assert delta == {}
+
+    def test_compare_pool_config_std_diff(self):
+        self.fake_user_pool_config['size']['value'] = '3'
+        delta = ceph_pool.compare_pool_config(self.fake_user_pool_config, self.fake_running_pool_details)
+
+        assert delta == {'size': {'cli_set_opt': 'size', 'value': '3'}}
+
+    def test_compare_pool_config_target_size_ratio_diff(self):
+        self.fake_user_pool_config['target_size_ratio']['value'] = '0.5'
+        delta = ceph_pool.compare_pool_config(self.fake_user_pool_config, self.fake_running_pool_details)
+
+        assert delta == {'target_size_ratio': {'cli_set_opt': 'target_size_ratio', 'value': '0.5'}}
+
+    def test_compare_pool_config_application_diff(self):
+        self.fake_user_pool_config['application']['value'] = 'foo'
+        delta = ceph_pool.compare_pool_config(self.fake_user_pool_config, self.fake_running_pool_details)
+
+        assert delta == {'application': {'new_application': 'foo', 'old_application': 'rbd', 'value': 'foo'}}
+
+    def test_list_pools_details(self):
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'ls',
+                'detail',
+                '-f',
+                'json'
+        ]
+
+        cmd = ceph_pool.list_pools(fake_cluster_name, fake_user, fake_user_key, True, 'json', container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    def test_list_pools_nodetails(self):
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'ls',
+                '-f',
+                'json'
+        ]
+
+        cmd = ceph_pool.list_pools(fake_cluster_name, fake_user, fake_user_key, False, 'json', container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    def test_create_replicated_pool_pg_autoscaler_enabled(self):
+        self.fake_user_pool_config['type']['value'] = 'replicated'
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'create',
+                self.fake_user_pool_config['pool_name']['value'],
+                self.fake_user_pool_config['type']['value'],
+                '--target_size_ratio',
+                self.fake_user_pool_config['target_size_ratio']['value'],
+                self.fake_user_pool_config['crush_rule']['value'],
+                '--expected_num_objects',
+                self.fake_user_pool_config['expected_num_objects']['value'],
+                '--autoscale-mode',
+                self.fake_user_pool_config['pg_autoscale_mode']['value'],
+                '--size',
+                self.fake_user_pool_config['size']['value']
+        ]
+
+        cmd = ceph_pool.create_pool(fake_cluster_name,
+                                    fake_user, fake_user_key, self.fake_user_pool_config,
+                                    container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    def test_create_replicated_pool_pg_autoscaler_disabled(self):
+        self.fake_user_pool_config['type']['value'] = 'replicated'
+        self.fake_user_pool_config['pg_autoscale_mode']['value'] = 'off'
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'create',
+                self.fake_user_pool_config['pool_name']['value'],
+                self.fake_user_pool_config['type']['value'],
+                '--pg_num',
+                self.fake_user_pool_config['pg_num']['value'],
+                '--pgp_num',
+                self.fake_user_pool_config['pgp_num']['value'],
+                self.fake_user_pool_config['crush_rule']['value'],
+                '--expected_num_objects',
+                self.fake_user_pool_config['expected_num_objects']['value'],
+                '--autoscale-mode',
+                self.fake_user_pool_config['pg_autoscale_mode']['value'],
+                '--size',
+                self.fake_user_pool_config['size']['value']
+        ]
+
+        cmd = ceph_pool.create_pool(fake_cluster_name,
+                                    fake_user, fake_user_key,
+                                    self.fake_user_pool_config,
+                                    container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    def test_create_erasure_pool_pg_autoscaler_enabled(self):
+        self.fake_user_pool_config['type']['value'] = 'erasure'
+        self.fake_user_pool_config['erasure_profile']['value'] = 'erasure-default'
+        self.fake_user_pool_config['crush_rule']['value'] = 'erasure_rule'
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'create',
+                self.fake_user_pool_config['pool_name']['value'],
+                self.fake_user_pool_config['type']['value'],
+                '--target_size_ratio',
+                self.fake_user_pool_config['target_size_ratio']['value'],
+                self.fake_user_pool_config['erasure_profile']['value'],
+                self.fake_user_pool_config['crush_rule']['value'],
+                '--expected_num_objects',
+                self.fake_user_pool_config['expected_num_objects']['value'],
+                '--autoscale-mode',
+                self.fake_user_pool_config['pg_autoscale_mode']['value']
+        ]
+
+        cmd = ceph_pool.create_pool(fake_cluster_name,
+                                    fake_user, fake_user_key, self.fake_user_pool_config,
+                                    container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    def test_create_erasure_pool_pg_autoscaler_disabled(self):
+        self.fake_user_pool_config['type']['value'] = 'erasure'
+        self.fake_user_pool_config['erasure_profile']['value'] = 'erasure-default'
+        self.fake_user_pool_config['crush_rule']['value'] = 'erasure_rule'
+        self.fake_user_pool_config['pg_autoscale_mode']['value'] = 'off'
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'create',
+                self.fake_user_pool_config['pool_name']['value'],
+                self.fake_user_pool_config['type']['value'],
+                '--pg_num',
+                self.fake_user_pool_config['pg_num']['value'],
+                '--pgp_num',
+                self.fake_user_pool_config['pgp_num']['value'],
+                self.fake_user_pool_config['erasure_profile']['value'],
+                self.fake_user_pool_config['crush_rule']['value'],
+                '--expected_num_objects',
+                self.fake_user_pool_config['expected_num_objects']['value'],
+                '--autoscale-mode',
+                self.fake_user_pool_config['pg_autoscale_mode']['value']
+        ]
+
+        cmd = ceph_pool.create_pool(fake_cluster_name,
+                                    fake_user, fake_user_key, self.fake_user_pool_config,
+                                    container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    @pytest.mark.parametrize("target_size_ratio", ['', '0.3'])
+    @pytest.mark.parametrize("pg_num", ['0', '32'])
+    @pytest.mark.parametrize("pg_autoscale_mode", ["on", "off", "warn"])
+    def test_create_pool_autoscale_pgnum_targetsize(self, pg_autoscale_mode, pg_num, target_size_ratio):
+        self.fake_user_pool_config['type']['value'] = 'erasure'
+        self.fake_user_pool_config['erasure_profile']['value'] = 'erasure-default'
+        self.fake_user_pool_config['crush_rule']['value'] = 'erasure_rule'
+        self.fake_user_pool_config['pg_autoscale_mode']['value'] = pg_autoscale_mode
+        self.fake_user_pool_config['pg_num']['value'] = pg_num
+        self.fake_user_pool_config['pgp_num']['value'] = pg_num
+        self.fake_user_pool_config['target_size_ratio']['value'] = target_size_ratio
+
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                fake_user,
+                '-k',
+                fake_user_key,
+                '--cluster',
+                fake_cluster_name,
+                'osd',
+                'pool',
+                'create',
+                self.fake_user_pool_config['pool_name']['value'],
+                self.fake_user_pool_config['type']['value'],
+        ]
+
+        if pg_autoscale_mode in ['off', 'warn']:
+            expected_command.extend(['--pg_num', pg_num])
+            expected_command.extend(['--pgp_num', pg_num])
+
+        if pg_autoscale_mode in ['on', 'warn'] and target_size_ratio:
+            expected_command.extend(['--target_size_ratio', target_size_ratio])
+
+        expected_command.extend([
+            self.fake_user_pool_config['erasure_profile']['value'],
+            self.fake_user_pool_config['crush_rule']['value'],
+            '--expected_num_objects',
+            self.fake_user_pool_config['expected_num_objects']['value'],
+            '--autoscale-mode',
+            self.fake_user_pool_config['pg_autoscale_mode']['value']
+        ])
+
+        cmd = ceph_pool.create_pool(fake_cluster_name,
+                                    fake_user, fake_user_key, self.fake_user_pool_config,
+                                    container_image=fake_container_image_name)
+
+        assert cmd == expected_command
+
+    def test_remove_pool(self):
+        expected_command = [
+                'podman',
+                'run',
+                '--rm',
+                '--net=host',
+                '-v',
+                '/etc/ceph:/etc/ceph:z',
+                '-v',
+                '/var/lib/ceph/:/var/lib/ceph/:z',
+                '-v',
+                '/var/log/ceph/:/var/log/ceph/:z',
+                '--entrypoint=ceph',
+                fake_container_image_name,
+                '-n',
+                'client.admin',
+                '-k',
+                '/etc/ceph/ceph.client.admin.keyring',
+                '--cluster',
+                'ceph',
+                'osd',
+                'pool',
+                'rm',
+                self.fake_user_pool_config['pool_name']['value'],
+                self.fake_user_pool_config['pool_name']['value'],
+                '--yes-i-really-really-mean-it'
+        ]
+
+        cmd = ceph_pool.remove_pool(fake_cluster_name, self.fake_user_pool_config['pool_name']['value'],
+                                    fake_user, fake_user_key, container_image=fake_container_image_name)
+
+        assert cmd == expected_command

tests/library/test_ceph_volume.py

@@ -0,0 +1,480 @@
+import sys
+import mock
+import os
+import pytest
+import ca_test_common
+sys.path.append('./library')
+import ceph_volume  # noqa: E402
+
+
+# Python 3
+try:
+    from unittest.mock import MagicMock, patch
+except ImportError:
+    # Python 2
+    try:
+        from mock import MagicMock, patch
+    except ImportError:
+        print('You need the mock library installed on python2.x to run tests')
+
+
+def get_mounts(mounts=None):
+    volumes = {}
+    volumes['/run/lock/lvm'] = '/run/lock/lvm:z'
+    volumes['/var/run/udev'] = '/var/run/udev:z'
+    volumes['/dev'] = '/dev'
+    volumes['/etc/ceph'] = '/etc/ceph:z'
+    volumes['/run/lvm'] = '/run/lvm'
+    volumes['/var/lib/ceph'] = '/var/lib/ceph:z'
+    volumes['/var/log/ceph'] = '/var/log/ceph:z'
+    if mounts is not None:
+        volumes.update(mounts)
+
+    return sum([['-v', '{}:{}'.format(src_dir, dst_dir)] for src_dir, dst_dir in volumes.items()], [])
+
+
+def get_container_cmd(mounts=None):
+
+    return ['docker', 'run', '--rm', '--privileged',
+            '--net=host', '--ipc=host'] + \
+            get_mounts(mounts) + ['--entrypoint=ceph-volume']
+
+
+@mock.patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': 'docker'})
+class TestCephVolumeModule(object):
+
+    def test_data_no_vg(self):
+        result = ceph_volume.get_data("/dev/sda", None)
+        assert result == "/dev/sda"
+
+    def test_data_with_vg(self):
+        result = ceph_volume.get_data("data-lv", "data-vg")
+        assert result == "data-vg/data-lv"
+
+    def test_journal_no_vg(self):
+        result = ceph_volume.get_journal("/dev/sda1", None)
+        assert result == "/dev/sda1"
+
+    def test_journal_with_vg(self):
+        result = ceph_volume.get_journal("journal-lv", "journal-vg")
+        assert result == "journal-vg/journal-lv"
+
+    def test_db_no_vg(self):
+        result = ceph_volume.get_db("/dev/sda1", None)
+        assert result == "/dev/sda1"
+
+    def test_db_with_vg(self):
+        result = ceph_volume.get_db("db-lv", "db-vg")
+        assert result == "db-vg/db-lv"
+
+    def test_wal_no_vg(self):
+        result = ceph_volume.get_wal("/dev/sda1", None)
+        assert result == "/dev/sda1"
+
+    def test_wal_with_vg(self):
+        result = ceph_volume.get_wal("wal-lv", "wal-vg")
+        assert result == "wal-vg/wal-lv"
+
+    def test_container_exec(self):
+        fake_binary = "ceph-volume"
+        fake_container_image = "quay.io/ceph/daemon:latest"
+        expected_command_list = get_container_cmd() + [fake_container_image]
+        result = ceph_volume.container_exec(fake_binary, fake_container_image)
+        assert result == expected_command_list
+
+    def test_zap_osd_container(self):
+        fake_module = MagicMock()
+        fake_module.params = {'data': '/dev/sda'}
+        fake_container_image = "quay.io/ceph/daemon:latest"
+        expected_command_list = get_container_cmd() + \
+            [fake_container_image,
+                '--cluster',
+                'ceph',
+                'lvm',
+                'zap',
+                '--destroy',
+                '/dev/sda']
+        result = ceph_volume.zap_devices(fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    def test_zap_osd(self):
+        fake_module = MagicMock()
+        fake_module.params = {'data': '/dev/sda'}
+        fake_container_image = None
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'lvm',
+                                 'zap',
+                                 '--destroy',
+                                 '/dev/sda']
+        result = ceph_volume.zap_devices(fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    def test_zap_osd_fsid(self):
+        fake_module = MagicMock()
+        fake_module.params = {'osd_fsid': 'a_uuid'}
+        fake_container_image = None
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'lvm',
+                                 'zap',
+                                 '--destroy',
+                                 '--osd-fsid',
+                                 'a_uuid']
+        result = ceph_volume.zap_devices(fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    def test_zap_osd_id(self):
+        fake_module = MagicMock()
+        fake_module.params = {'osd_id': '123'}
+        fake_container_image = None
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'lvm',
+                                 'zap',
+                                 '--destroy',
+                                 '--osd-id',
+                                 '123']
+        result = ceph_volume.zap_devices(fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    def test_activate_osd(self):
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'lvm',
+                                 'activate',
+                                 '--all']
+        result = ceph_volume.activate_osd()
+        assert result == expected_command_list
+
+    def test_list_osd(self):
+        fake_module = MagicMock()
+        fake_module.params = {'cluster': 'ceph', 'data': '/dev/sda'}
+        fake_container_image = None
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'lvm',
+                                 'list',
+                                 '/dev/sda',
+                                 '--format=json']
+        result = ceph_volume.list_osd(fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    def test_list_osd_container(self):
+        fake_module = MagicMock()
+        fake_module.params = {'cluster': 'ceph', 'data': '/dev/sda'}
+        fake_container_image = "quay.io/ceph/daemon:latest"
+        expected_command_list = get_container_cmd(
+                                {
+                                    '/var/lib/ceph': '/var/lib/ceph:ro'
+                                }) + \
+            [fake_container_image,
+                '--cluster',
+                'ceph',
+                'lvm',
+                'list',
+                '/dev/sda',
+                '--format=json']
+        result = ceph_volume.list_osd(fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    def test_list_storage_inventory(self):
+        fake_module = MagicMock()
+        fake_container_image = None
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'inventory',
+                                 '--format=json',
+                                 ]
+        result = ceph_volume.list_storage_inventory(fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    def test_list_storage_inventory_container(self):
+        fake_module = MagicMock()
+        fake_container_image = "quay.io/ceph/daemon:latest"
+        expected_command_list = get_container_cmd() + \
+            [fake_container_image,
+                '--cluster',
+                'ceph',
+                'inventory',
+                '--format=json']
+        result = ceph_volume.list_storage_inventory(fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    @pytest.mark.parametrize('objectstore', ['bluestore'])
+    def test_create_osd_container(self, objectstore):
+        fake_module = MagicMock()
+        fake_module.params = {'data': '/dev/sda',
+                              'objectstore': objectstore,
+                              'cluster': 'ceph', }
+
+        fake_action = "create"
+        fake_container_image = "quay.io/ceph/daemon:latest"
+        expected_command_list = get_container_cmd() + \
+            [fake_container_image,
+                '--cluster',
+                'ceph',
+                'lvm',
+                'create',
+                '--%s' % objectstore,
+                '--data',
+                '/dev/sda']
+        result = ceph_volume.prepare_or_create_osd(
+            fake_module, fake_action, fake_container_image)
+        assert result == expected_command_list
+
+    @pytest.mark.parametrize('objectstore', ['bluestore'])
+    def test_create_osd(self, objectstore):
+        fake_module = MagicMock()
+        fake_module.params = {'data': '/dev/sda',
+                              'objectstore': objectstore,
+                              'cluster': 'ceph', }
+
+        fake_container_image = None
+        fake_action = "create"
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'lvm',
+                                 'create',
+                                 '--%s' % objectstore,
+                                 '--data',
+                                 '/dev/sda']
+        result = ceph_volume.prepare_or_create_osd(
+            fake_module, fake_action, fake_container_image)
+        assert result == expected_command_list
+
+    @pytest.mark.parametrize('objectstore', ['bluestore'])
+    def test_prepare_osd_container(self, objectstore):
+        fake_module = MagicMock()
+        fake_module.params = {'data': '/dev/sda',
+                              'objectstore': objectstore,
+                              'cluster': 'ceph', }
+
+        fake_action = "prepare"
+        fake_container_image = "quay.io/ceph/daemon:latest"
+        expected_command_list = get_container_cmd() + \
+            [fake_container_image,
+                '--cluster',
+                'ceph',
+                'lvm',
+                'prepare',
+                '--%s' % objectstore,
+                '--data',
+                '/dev/sda']
+        result = ceph_volume.prepare_or_create_osd(
+            fake_module, fake_action, fake_container_image)
+        assert result == expected_command_list
+
+    @pytest.mark.parametrize('objectstore', ['bluestore'])
+    def test_prepare_osd(self, objectstore):
+        fake_module = MagicMock()
+        fake_module.params = {'data': '/dev/sda',
+                              'objectstore': objectstore,
+                              'cluster': 'ceph', }
+
+        fake_container_image = None
+        fake_action = "prepare"
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'lvm',
+                                 'prepare',
+                                 '--%s' % objectstore,
+                                 '--data',
+                                 '/dev/sda']
+        result = ceph_volume.prepare_or_create_osd(
+            fake_module, fake_action, fake_container_image)
+        assert result == expected_command_list
+
+    @pytest.mark.parametrize('objectstore', ['bluestore'])
+    def test_batch_osd_container(self, objectstore):
+        fake_module = MagicMock()
+        fake_module.params = {'data': '/dev/sda',
+                              'objectstore': objectstore,
+                              'block_db_size': '4096',
+                              'journal_size': '4096',
+                              'cluster': 'ceph',
+                              'batch_devices': ["/dev/sda", "/dev/sdb"]}
+
+        fake_container_image = "quay.io/ceph/daemon:latest"
+        expected_command_list = get_container_cmd() + \
+            [fake_container_image,
+                '--cluster',
+                'ceph',
+                'lvm',
+                'batch',
+                '--%s' % objectstore,
+                '--yes',
+                '--prepare',
+                '--block-db-size',
+                '4096',
+                '/dev/sda',
+                '/dev/sdb']
+        result = ceph_volume.batch(
+            fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    @pytest.mark.parametrize('objectstore', ['bluestore'])
+    def test_batch_osd(self, objectstore):
+        fake_module = MagicMock()
+        fake_module.params = {'data': '/dev/sda',
+                              'objectstore': objectstore,
+                              'block_db_size': '4096',
+                              'journal_size': '4096',
+                              'cluster': 'ceph',
+                              'batch_devices': ["/dev/sda", "/dev/sdb"]}
+
+        fake_container_image = None
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'lvm',
+                                 'batch',
+                                 '--%s' % objectstore,
+                                 '--yes',
+                                 '--block-db-size',
+                                 '4096',
+                                 '/dev/sda',
+                                 '/dev/sdb']
+        result = ceph_volume.batch(
+            fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    def test_batch_bluestore_with_dedicated_db(self):
+        fake_module = MagicMock()
+        fake_module.params = {'objectstore': 'bluestore',
+                              'block_db_size': '-1',
+                              'cluster': 'ceph',
+                              'batch_devices': ["/dev/sda", "/dev/sdb"],
+                              'block_db_devices': ["/dev/sdc", "/dev/sdd"]}
+
+        fake_container_image = None
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'lvm',
+                                 'batch',
+                                 '--bluestore',
+                                 '--yes',
+                                 '/dev/sda',
+                                 '/dev/sdb',
+                                 '--db-devices',
+                                 '/dev/sdc',
+                                 '/dev/sdd']
+        result = ceph_volume.batch(
+            fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    def test_batch_bluestore_with_dedicated_wal(self):
+        fake_module = MagicMock()
+        fake_module.params = {'objectstore': 'bluestore',
+                              'cluster': 'ceph',
+                              'block_db_size': '-1',
+                              'batch_devices': ["/dev/sda", "/dev/sdb"],
+                              'wal_devices': ["/dev/sdc", "/dev/sdd"]}
+
+        fake_container_image = None
+        expected_command_list = ['ceph-volume',
+                                 '--cluster',
+                                 'ceph',
+                                 'lvm',
+                                 'batch',
+                                 '--bluestore',
+                                 '--yes',
+                                 '/dev/sda',
+                                 '/dev/sdb',
+                                 '--wal-devices',
+                                 '/dev/sdc',
+                                 '/dev/sdd']
+        result = ceph_volume.batch(
+            fake_module, fake_container_image)
+        assert result == expected_command_list
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_prepare_no_keyring_in_output(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({'data': '/dev/sda',
+                                        'objectstore': 'bluestore',
+                                        'cluster': 'ceph',
+                                        'action': 'prepare'})
+        keyring = 'AQBqkhNhQDlqEhAAXKxu87L3Mh3mHY+agonKZA=='
+        m_exit_json.side_effect = ca_test_common.exit_json
+        list_rc = 0
+        list_stderr = ''
+        list_stdout = '{}'
+        prepare_rc = 0
+        prepare_stderr = """
+    Running command: /usr/bin/ceph-authtool --gen-print-key
+    Running command: /usr/bin/mount -t tmpfs tmpfs /var/lib/ceph/osd/ceph-0
+    Running command: /usr/bin/chown -h ceph:ceph /dev/test_group/data-lv1
+    Running command: /usr/bin/chown -R ceph:ceph /dev/dm-0
+    Running command: /usr/bin/ln -s /dev/test_group/data-lv1 /var/lib/ceph/osd/ceph-1/block
+     stderr: got monmap epoch 1
+    Running command: /usr/bin/ceph-authtool /var/lib/ceph/osd/ceph-1/keyring --create-keyring --name osd.1 --add-key {}
+     stdout: creating /var/lib/ceph/osd/ceph-1/keyring
+    added entity osd.1 auth(key={})
+""".format(keyring, keyring)
+        prepare_stdout = ''
+        m_run_command.side_effect = [
+            (list_rc, list_stdout, list_stderr),
+            (prepare_rc, prepare_stdout, prepare_stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', 'ceph', 'lvm', 'prepare', '--bluestore', '--data', '/dev/sda']
+        assert result['rc'] == 0
+        assert keyring not in result['stderr']
+        assert '*' * 8 in result['stderr']
+        assert not result['stdout']
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_batch_no_keyring_in_output(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({'batch_devices': ['/dev/sda'],
+                                        'objectstore': 'bluestore',
+                                        'cluster': 'ceph',
+                                        'action': 'batch'})
+        keyring = 'AQBUixJhnDF1NRAAhl2xrnmOHCCI/T+W6FjqmA=='
+        m_exit_json.side_effect = ca_test_common.exit_json
+        report_rc = 0
+        report_stderr = ''
+        report_stdout = '[{"data": "/dev/sda", "data_size": "50.00 GB", "encryption": "None"}]'
+        batch_rc = 0
+        batch_stderr = """
+    Running command: /usr/bin/ceph-authtool --gen-print-key
+    Running command: /usr/bin/mount -t tmpfs tmpfs /var/lib/ceph/osd/ceph-0
+    Running command: /usr/bin/chown -h ceph:ceph /dev/ceph-863337c4-bef9-4b96-aaac-27cde8c42b8f/osd-block-b1d1036f-0d6e-493b-9d1a-6f6b96df64b1
+    Running command: /usr/bin/chown -R ceph:ceph /dev/mapper/ceph--863337c4--bef9--4b96--aaac--27cde8c42b8f-osd--block--b1d1036f--0d6e--493b--9d1a--6f6b96df64b1
+    Running command: /usr/bin/ln -s /dev/ceph-863337c4-bef9-4b96-aaac-27cde8c42b8f/osd-block-b1d1036f-0d6e-493b-9d1a-6f6b96df64b1 /var/lib/ceph/osd/ceph-0/block
+     stderr: got monmap epoch 1
+    Running command: /usr/bin/ceph-authtool /var/lib/ceph/osd/ceph-0/keyring --create-keyring --name osd.0 --add-key {}
+     stdout: creating /var/lib/ceph/osd/ceph-0/keyring
+    added entity osd.0 auth(key={})
+""".format(keyring, keyring)
+        batch_stdout = ''
+        m_run_command.side_effect = [
+            (report_rc, report_stdout, report_stderr),
+            (batch_rc, batch_stdout, batch_stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', 'ceph', 'lvm', 'batch', '--bluestore', '--yes', '/dev/sda']
+        assert result['rc'] == 0
+        assert keyring not in result['stderr']
+        assert '*' * 8 in result['stderr']
+        assert not result['stdout']

tests/library/test_ceph_volume_simple_activate.py

@@ -0,0 +1,174 @@
+from mock.mock import patch
+import os
+import pytest
+import ca_test_common
+import ceph_volume_simple_activate
+
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'quay.io/ceph/daemon:latest'
+fake_id = '42'
+fake_uuid = '0c4a7eca-0c2a-4c12-beff-08a80f064c52'
+fake_path = '/etc/ceph/osd/{}-{}.json'.format(fake_id, fake_uuid)
+
+
+class TestCephVolumeSimpleActivateModule(object):
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    def test_with_check_mode(self, m_exit_json):
+        ca_test_common.set_module_args({
+            'osd_id': fake_id,
+            'osd_fsid': fake_uuid,
+            '_ansible_check_mode': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_activate.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', fake_cluster, 'simple', 'activate', fake_id, fake_uuid]
+        assert result['rc'] == 0
+        assert not result['stdout']
+        assert not result['stderr']
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_failure(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'osd_id': fake_id,
+            'osd_fsid': fake_uuid
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = 'error'
+        rc = 2
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_activate.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', fake_cluster, 'simple', 'activate', fake_id, fake_uuid]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_activate_all_osds(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'osd_all': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_activate.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', fake_cluster, 'simple', 'activate', '--all']
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch.object(os.path, 'exists', return_value=True)
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_activate_path_exists(self, m_run_command, m_exit_json, m_os_path):
+        ca_test_common.set_module_args({
+            'path': fake_path
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_activate.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', fake_cluster, 'simple', 'activate', '--file', fake_path]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch.object(os.path, 'exists', return_value=False)
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_activate_path_not_exists(self, m_fail_json, m_os_path):
+        ca_test_common.set_module_args({
+            'path': fake_path
+        })
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_volume_simple_activate.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == '{} does not exist'.format(fake_path)
+        assert result['rc'] == 1
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_activate_without_systemd(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'osd_id': fake_id,
+            'osd_fsid': fake_uuid,
+            'systemd': False
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_activate.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', fake_cluster, 'simple', 'activate', fake_id, fake_uuid, '--no-systemd']
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_activate_with_container(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'osd_id': fake_id,
+            'osd_fsid': fake_uuid,
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_activate.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == [fake_container_binary,
+                                 'run', '--rm', '--privileged',
+                                 '--ipc=host', '--net=host',
+                                 '-v', '/etc/ceph:/etc/ceph:z',
+                                 '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                 '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                 '-v', '/run/lvm/:/run/lvm/',
+                                 '-v', '/run/lock/lvm/:/run/lock/lvm/',
+                                 '--entrypoint=ceph-volume', fake_container_image,
+                                 '--cluster', fake_cluster, 'simple', 'activate', fake_id, fake_uuid]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout

tests/library/test_ceph_volume_simple_scan.py

@@ -0,0 +1,166 @@
+from mock.mock import patch
+import os
+import pytest
+import ca_test_common
+import ceph_volume_simple_scan
+
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'quay.io/ceph/daemon:latest'
+fake_path = '/var/lib/ceph/osd/ceph-0'
+
+
+class TestCephVolumeSimpleScanModule(object):
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    def test_with_check_mode(self, m_exit_json):
+        ca_test_common.set_module_args({
+            '_ansible_check_mode': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_scan.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', fake_cluster, 'simple', 'scan']
+        assert result['rc'] == 0
+        assert not result['stdout']
+        assert not result['stderr']
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_failure(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = 'error'
+        rc = 2
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_scan.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', fake_cluster, 'simple', 'scan']
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_scan_all_osds(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_scan.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', fake_cluster, 'simple', 'scan']
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch.object(os.path, 'exists', return_value=True)
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_scan_path_exists(self, m_run_command, m_exit_json, m_os_path):
+        ca_test_common.set_module_args({
+            'path': fake_path
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_scan.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', fake_cluster, 'simple', 'scan', fake_path]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch.object(os.path, 'exists', return_value=False)
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_scan_path_not_exists(self, m_fail_json, m_os_path):
+        ca_test_common.set_module_args({
+            'path': fake_path
+        })
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            ceph_volume_simple_scan.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == '{} does not exist'.format(fake_path)
+        assert result['rc'] == 1
+
+    @patch.object(os.path, 'exists', return_value=True)
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_scan_path_stdout_force(self, m_run_command, m_exit_json, m_os_path):
+        ca_test_common.set_module_args({
+            'path': fake_path,
+            'force': True,
+            'stdout': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_scan.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['ceph-volume', '--cluster', fake_cluster, 'simple', 'scan', '--force', '--stdout', fake_path]
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_scan_with_container(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            ceph_volume_simple_scan.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == [fake_container_binary,
+                                 'run', '--rm', '--privileged',
+                                 '--ipc=host', '--net=host',
+                                 '-v', '/etc/ceph:/etc/ceph:z',
+                                 '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+                                 '-v', '/var/log/ceph/:/var/log/ceph/:z',
+                                 '-v', '/run/lvm/:/run/lvm/',
+                                 '-v', '/run/lock/lvm/:/run/lock/lvm/',
+                                 '--entrypoint=ceph-volume', fake_container_image,
+                                 '--cluster', fake_cluster, 'simple', 'scan']
+        assert result['rc'] == rc
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout

tests/library/test_cephadm_adopt.py

@@ -0,0 +1,208 @@
+from mock.mock import patch
+import pytest
+import ca_test_common
+import cephadm_adopt
+
+fake_cluster = 'ceph'
+fake_image = 'quay.io/ceph/daemon-base:latest'
+fake_name = 'mon.foo01'
+
+
+class TestCephadmAdoptModule(object):
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_without_parameters(self, m_fail_json):
+        ca_test_common.set_module_args({})
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            cephadm_adopt.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == 'missing required arguments: name'
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    def test_with_check_mode(self, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            '_ansible_check_mode': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_adopt.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['cephadm', 'ls', '--no-detail']
+        assert result['rc'] == 0
+        assert not result['stdout']
+        assert not result['stderr']
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_failure(self, m_run_command, m_fail_json):
+        ca_test_common.set_module_args({
+            'name': fake_name
+        })
+        m_fail_json.side_effect = ca_test_common.fail_json
+        stdout = ''
+        stderr = 'ERROR: cephadm should be run as root'
+        rc = 1
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            cephadm_adopt.main()
+
+        result = result.value.args[0]
+        assert result['rc'] == 1
+        assert result['msg'] == 'ERROR: cephadm should be run as root'
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_default_values(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = 'Stopping old systemd unit ceph-mon@{}...\n' \
+                 'Disabling old systemd unit ceph-mon@{}...\n' \
+                 'Moving data...\n' \
+                 'Chowning content...\n' \
+                 'Moving logs...\n' \
+                 'Creating new units...\n' \
+                 'firewalld ready'.format(fake_name, fake_name)
+        stderr = ''
+        rc = 0
+        m_run_command.side_effect = [
+            (0, '[{{"style":"legacy","name":"{}"}}]'.format(fake_name), ''),
+            (rc, stdout, stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_adopt.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'adopt', '--cluster', fake_cluster, '--name', fake_name, '--style', 'legacy']
+        assert result['rc'] == 0
+        assert result['stderr'] == stderr
+        assert result['stdout'] == stdout
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_already_adopted(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stderr = ''
+        stdout = '[{{"style":"cephadm:v1","name":"{}"}}]'.format(fake_name)
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_adopt.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['cephadm', 'ls', '--no-detail']
+        assert result['rc'] == 0
+        assert result['stderr'] == stderr
+        assert result['stdout'] == '{} is already adopted'.format(fake_name)
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_docker(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'docker': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.side_effect = [
+            (0, '[{{"style":"legacy","name":"{}"}}]'.format(fake_name), ''),
+            (rc, stdout, stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_adopt.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', '--docker', 'adopt', '--cluster', fake_cluster, '--name', fake_name, '--style', 'legacy']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_custom_image(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'image': fake_image
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.side_effect = [
+            (0, '[{{"style":"legacy","name":"{}"}}]'.format(fake_name), ''),
+            (rc, stdout, stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_adopt.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', '--image', fake_image, 'adopt', '--cluster', fake_cluster, '--name', fake_name, '--style', 'legacy']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_without_pull(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'pull': False
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.side_effect = [
+            (0, '[{{"style":"legacy","name":"{}"}}]'.format(fake_name), ''),
+            (rc, stdout, stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_adopt.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'adopt', '--cluster', fake_cluster, '--name', fake_name, '--style', 'legacy', '--skip-pull']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_without_firewalld(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'name': fake_name,
+            'firewalld': False
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.side_effect = [
+            (0, '[{{"style":"legacy","name":"{}"}}]'.format(fake_name), ''),
+            (rc, stdout, stderr)
+        ]
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_adopt.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'adopt', '--cluster', fake_cluster, '--name', fake_name, '--style', 'legacy', '--skip-firewalld']
+        assert result['rc'] == 0

tests/library/test_cephadm_bootstrap.py

@@ -0,0 +1,304 @@
+from mock.mock import patch
+import pytest
+import ca_test_common
+import cephadm_bootstrap
+
+fake_fsid = '0f1e0605-db0b-485c-b366-bd8abaa83f3b'
+fake_image = 'quay.io/ceph/ceph:v19'
+fake_ip = '192.168.42.1'
+fake_registry = 'quay.io'
+fake_registry_user = 'foo'
+fake_registry_pass = 'bar'
+fake_registry_json = 'registry.json'
+
+
+class TestCephadmBootstrapModule(object):
+
+    @patch('ansible.module_utils.basic.AnsibleModule.fail_json')
+    def test_without_parameters(self, m_fail_json):
+        ca_test_common.set_module_args({})
+        m_fail_json.side_effect = ca_test_common.fail_json
+
+        with pytest.raises(ca_test_common.AnsibleFailJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['msg'] == 'missing required arguments: mon_ip'
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    def test_with_check_mode(self, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            '_ansible_check_mode': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert not result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip]
+        assert result['rc'] == 0
+        assert not result['stdout']
+        assert not result['stderr']
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_failure(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = 'ERROR: cephadm should be run as root'
+        rc = 1
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip]
+        assert result['rc'] == 1
+        assert result['stderr'] == 'ERROR: cephadm should be run as root'
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_default_values(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = 'Bootstrap complete.'
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip]
+        assert result['rc'] == 0
+        assert result['stdout'] == 'Bootstrap complete.'
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_docker(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            'docker': True
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', '--docker', 'bootstrap', '--mon-ip', fake_ip]
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_custom_image(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            'image': fake_image
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', '--image', fake_image, 'bootstrap', '--mon-ip', fake_ip]
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_custom_fsid(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            'fsid': fake_fsid
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip, '--fsid', fake_fsid]
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_without_pull(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            'pull': False
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip, '--skip-pull']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_dashboard_user_password(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            'dashboard': True,
+            'dashboard_user': 'foo',
+            'dashboard_password': 'bar'
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip, '--initial-dashboard-user', 'foo', '--initial-dashboard-password', 'bar']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_without_dashboard(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            'dashboard': False
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip, '--skip-dashboard']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_without_monitoring(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            'monitoring': False
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip, '--skip-monitoring-stack']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_without_firewalld(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            'firewalld': False
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip, '--skip-firewalld']
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_registry_credentials(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            'registry_url': fake_registry,
+            'registry_username': fake_registry_user,
+            'registry_password': fake_registry_pass
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip,
+                                 '--registry-url', fake_registry,
+                                 '--registry-username', fake_registry_user,
+                                 '--registry-password', fake_registry_pass]
+        assert result['rc'] == 0
+
+    @patch('ansible.module_utils.basic.AnsibleModule.exit_json')
+    @patch('ansible.module_utils.basic.AnsibleModule.run_command')
+    def test_with_registry_json_file(self, m_run_command, m_exit_json):
+        ca_test_common.set_module_args({
+            'mon_ip': fake_ip,
+            'registry_json': fake_registry_json
+        })
+        m_exit_json.side_effect = ca_test_common.exit_json
+        stdout = ''
+        stderr = ''
+        rc = 0
+        m_run_command.return_value = rc, stdout, stderr
+
+        with pytest.raises(ca_test_common.AnsibleExitJson) as result:
+            cephadm_bootstrap.main()
+
+        result = result.value.args[0]
+        assert result['changed']
+        assert result['cmd'] == ['cephadm', 'bootstrap', '--mon-ip', fake_ip,
+                                 '--registry-json', fake_registry_json]
+        assert result['rc'] == 0

tests/library/test_radosgw_caps.py

@@ -0,0 +1,101 @@
+import os
+import sys
+from mock.mock import patch, MagicMock
+import pytest
+
+sys.path.append("./library")
+import radosgw_caps  # noqa: E402
+
+
+fake_binary = "radosgw-admin"
+fake_cluster = "ceph"
+fake_container_binary = "podman"
+fake_container_image = "docker.io/ceph/daemon:latest"
+fake_container_cmd = [
+    fake_container_binary,
+    "run",
+    "--rm",
+    "--net=host",
+    "-v",
+    "/etc/ceph:/etc/ceph:z",
+    "-v",
+    "/var/lib/ceph/:/var/lib/ceph/:z",
+    "-v",
+    "/var/log/ceph/:/var/log/ceph/:z",
+    "--entrypoint=" + fake_binary,
+    fake_container_image,
+]
+fake_user = "foo"
+fake_caps = ["users=write", "zone=*", "metadata=read,write"]
+fake_params = {
+    "cluster": fake_cluster,
+    "name": fake_user,
+    "caps": fake_caps,
+}
+
+
+class TestRadosgwCapsModule(object):
+    @patch.dict(os.environ, {"CEPH_CONTAINER_BINARY": fake_container_binary})
+    def test_container_exec(self):
+        cmd = radosgw_caps.container_exec(fake_binary, fake_container_image)
+        assert cmd == fake_container_cmd
+
+    def test_not_is_containerized(self):
+        assert radosgw_caps.is_containerized() is None
+
+    @patch.dict(os.environ, {"CEPH_CONTAINER_IMAGE": fake_container_image})
+    def test_is_containerized(self):
+        assert radosgw_caps.is_containerized() == fake_container_image
+
+    @pytest.mark.parametrize("image", [None, fake_container_image])
+    @patch.dict(os.environ, {"CEPH_CONTAINER_BINARY": fake_container_binary})
+    def test_pre_generate_radosgw_cmd(self, image):
+        if image:
+            expected_cmd = fake_container_cmd
+        else:
+            expected_cmd = [fake_binary]
+
+        assert radosgw_caps.pre_generate_radosgw_cmd(image) == expected_cmd
+
+    @pytest.mark.parametrize("image", [None, fake_container_image])
+    @patch.dict(os.environ, {"CEPH_CONTAINER_BINARY": fake_container_binary})
+    def test_generate_radosgw_cmd(self, image):
+        if image:
+            expected_cmd = fake_container_cmd
+        else:
+            expected_cmd = [fake_binary]
+
+        expected_cmd.extend(["--cluster", fake_cluster, "caps"])
+        assert (
+            radosgw_caps.generate_radosgw_cmd(fake_cluster, [], image) == expected_cmd
+        )
+
+    def test_add_caps(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            "--cluster",
+            fake_cluster,
+            "caps",
+            "add",
+            "--uid=" + fake_user,
+            "--caps=" + ";".join(fake_caps),
+        ]
+
+        assert radosgw_caps.add_caps(fake_module) == expected_cmd
+
+    def test_remove_caps(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            "--cluster",
+            fake_cluster,
+            "caps",
+            "rm",
+            "--uid=" + fake_user,
+            "--caps=" + ";".join(fake_caps),
+        ]
+
+        assert radosgw_caps.remove_caps(fake_module) == expected_cmd

tests/library/test_radosgw_realm.py

@@ -0,0 +1,125 @@
+import os
+import sys
+from mock.mock import patch, MagicMock
+import pytest
+sys.path.append('./library')
+import radosgw_realm  # noqa: E402
+
+
+fake_binary = 'radosgw-admin'
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'docker.io/ceph/daemon:latest'
+fake_container_cmd = [
+    fake_container_binary,
+    'run',
+    '--rm',
+    '--net=host',
+    '-v', '/etc/ceph:/etc/ceph:z',
+    '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+    '-v', '/var/log/ceph/:/var/log/ceph/:z',
+    '--entrypoint=' + fake_binary,
+    fake_container_image
+]
+fake_realm = 'foo'
+fake_params = {'cluster': fake_cluster,
+               'name': fake_realm,
+               'default': True}
+fake_url = 'http://192.168.42.100:8080'
+fake_access_key = '8XQHmFxixz7LCM2AdM2p'
+fake_secret_key = 'XC8IhEPJprL6SrpaJDmolVs7jbOvoe2E3AaWKGRx'
+
+
+class TestRadosgwRealmModule(object):
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_container_exec(self):
+        cmd = radosgw_realm.container_exec(fake_binary, fake_container_image)
+        assert cmd == fake_container_cmd
+
+    def test_not_is_containerized(self):
+        assert radosgw_realm.is_containerized() is None
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    def test_is_containerized(self):
+        assert radosgw_realm.is_containerized() == fake_container_image
+
+    @pytest.mark.parametrize('image', [None, fake_container_image])
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_pre_generate_radosgw_cmd(self, image):
+        if image:
+            expected_cmd = fake_container_cmd
+        else:
+            expected_cmd = [fake_binary]
+
+        assert radosgw_realm.pre_generate_radosgw_cmd(image) == expected_cmd
+
+    @pytest.mark.parametrize('image', [None, fake_container_image])
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_generate_radosgw_cmd(self, image):
+        if image:
+            expected_cmd = fake_container_cmd
+        else:
+            expected_cmd = [fake_binary]
+
+        expected_cmd.extend([
+            '--cluster',
+            fake_cluster,
+            'realm'
+        ])
+        assert radosgw_realm.generate_radosgw_cmd(fake_cluster, [], image) == expected_cmd
+
+    def test_create_realm(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'realm', 'create',
+            '--rgw-realm=' + fake_realm,
+            '--default'
+        ]
+
+        assert radosgw_realm.create_realm(fake_module) == expected_cmd
+
+    def test_get_realm(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'realm', 'get',
+            '--rgw-realm=' + fake_realm,
+            '--format=json'
+        ]
+
+        assert radosgw_realm.get_realm(fake_module) == expected_cmd
+
+    def test_remove_realm(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'realm', 'delete',
+            '--rgw-realm=' + fake_realm
+        ]
+
+        assert radosgw_realm.remove_realm(fake_module) == expected_cmd
+
+    def test_pull_realm(self):
+        fake_module = MagicMock()
+        fake_params.update({'url': fake_url, 'access_key': fake_access_key, 'secret_key': fake_secret_key})
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'realm', 'pull',
+            '--rgw-realm=' + fake_realm,
+            '--url=' + fake_url,
+            '--access-key=' + fake_access_key,
+            '--secret=' + fake_secret_key,
+            '--default'
+        ]
+
+        assert radosgw_realm.pull_realm(fake_module) == expected_cmd

tests/library/test_radosgw_user.py

@@ -0,0 +1,205 @@
+import os
+import sys
+from mock.mock import patch, MagicMock
+import pytest
+sys.path.append('./library')
+import radosgw_user  # noqa: E402
+
+
+fake_binary = 'radosgw-admin'
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'docker.io/ceph/daemon:latest'
+fake_container_cmd = [
+    fake_container_binary,
+    'run',
+    '--rm',
+    '--net=host',
+    '-v', '/etc/ceph:/etc/ceph:z',
+    '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+    '-v', '/var/log/ceph/:/var/log/ceph/:z',
+    '--entrypoint=' + fake_binary,
+    fake_container_image
+]
+fake_user = 'foo'
+fake_realm = 'canada'
+fake_zonegroup = 'quebec'
+fake_zone = 'montreal'
+fake_params = {'cluster': fake_cluster,
+               'name': fake_user,
+               'display_name': fake_user,
+               'email': fake_user,
+               'access_key': 'PC7NPg87QWhOzXTkXIhX',
+               'secret_key': 'jV64v39lVTjEx1ZJN6ocopnhvwMp1mXCD4kzBiPz',
+               'realm': fake_realm,
+               'zonegroup': fake_zonegroup,
+               'zone': fake_zone,
+               'system': True,
+               'admin': True}
+
+
+class TestRadosgwUserModule(object):
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_container_exec(self):
+        cmd = radosgw_user.container_exec(fake_binary, fake_container_image)
+        assert cmd == fake_container_cmd
+
+    def test_not_is_containerized(self):
+        assert radosgw_user.is_containerized() is None
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    def test_is_containerized(self):
+        assert radosgw_user.is_containerized() == fake_container_image
+
+    @pytest.mark.parametrize('image', [None, fake_container_image])
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_pre_generate_radosgw_cmd(self, image):
+        if image:
+            expected_cmd = fake_container_cmd
+        else:
+            expected_cmd = [fake_binary]
+
+        assert radosgw_user.pre_generate_radosgw_cmd(image) == expected_cmd
+
+    @pytest.mark.parametrize('image', [None, fake_container_image])
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_generate_radosgw_cmd(self, image):
+        if image:
+            expected_cmd = fake_container_cmd
+        else:
+            expected_cmd = [fake_binary]
+
+        expected_cmd.extend([
+            '--cluster',
+            fake_cluster,
+            'user'
+        ])
+        assert radosgw_user.generate_radosgw_cmd(fake_cluster, [], image) == expected_cmd
+
+    def test_create_user(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'user', 'create',
+            '--uid=' + fake_user,
+            '--display_name=' + fake_user,
+            '--email=' + fake_user,
+            '--access-key=PC7NPg87QWhOzXTkXIhX',
+            '--secret-key=jV64v39lVTjEx1ZJN6ocopnhvwMp1mXCD4kzBiPz',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--rgw-zone=' + fake_zone,
+            '--system',
+            '--admin'
+        ]
+
+        assert radosgw_user.create_user(fake_module) == expected_cmd
+
+    def test_modify_user(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'user', 'modify',
+            '--uid=' + fake_user,
+            '--display_name=' + fake_user,
+            '--email=' + fake_user,
+            '--access-key=PC7NPg87QWhOzXTkXIhX',
+            '--secret-key=jV64v39lVTjEx1ZJN6ocopnhvwMp1mXCD4kzBiPz',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--rgw-zone=' + fake_zone,
+            '--system',
+            '--admin'
+        ]
+
+        assert radosgw_user.modify_user(fake_module) == expected_cmd
+
+    def test_get_user(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'user', 'info',
+            '--uid=' + fake_user,
+            '--format=json',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--rgw-zone=' + fake_zone
+        ]
+
+        assert radosgw_user.get_user(fake_module) == expected_cmd
+
+    def test_remove_user(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'user', 'rm',
+            '--uid=' + fake_user,
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--rgw-zone=' + fake_zone
+        ]
+
+        assert radosgw_user.remove_user(fake_module) == expected_cmd
+
+    def test_caps_add(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'caps', 'add',
+            '--uid=' + fake_user,
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--rgw-zone=' + fake_zone,
+            '--caps=metadata=read;buckets=read'
+        ]
+
+        caps = [
+            {
+                'type': 'metadata',
+                'perm': 'read',
+            },
+            {
+                'type': 'buckets',
+                'perm': 'read',
+            },
+        ]
+
+        assert radosgw_user.caps_add(fake_module, caps) == expected_cmd
+
+    def test_caps_rm(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'caps', 'rm',
+            '--uid=' + fake_user,
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--rgw-zone=' + fake_zone,
+            '--caps=metadata=read;buckets=read'
+        ]
+
+        caps = [
+            {
+                'type': 'metadata',
+                'perm': 'read',
+            },
+            {
+                'type': 'buckets',
+                'perm': 'read',
+            },
+        ]
+
+        assert radosgw_user.caps_rm(fake_module, caps) == expected_cmd

tests/library/test_radosgw_zone.py

@@ -0,0 +1,213 @@
+import os
+import sys
+from mock.mock import patch, MagicMock
+import pytest
+sys.path.append('./library')
+import radosgw_zone  # noqa: E402
+
+
+fake_binary = 'radosgw-admin'
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'docker.io/ceph/daemon:latest'
+fake_container_cmd = [
+    fake_container_binary,
+    'run',
+    '--rm',
+    '--net=host',
+    '-v', '/etc/ceph:/etc/ceph:z',
+    '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+    '-v', '/var/log/ceph/:/var/log/ceph/:z',
+    '--entrypoint=' + fake_binary,
+    fake_container_image
+]
+fake_realm = 'foo'
+fake_zonegroup = 'bar'
+fake_zone = 'z1'
+fake_endpoints = ['http://192.168.1.10:8080', 'http://192.168.1.11:8080']
+fake_params = {'cluster': fake_cluster,
+               'name': fake_zone,
+               'realm': fake_realm,
+               'zonegroup': fake_zonegroup,
+               'endpoints': fake_endpoints,
+               'default': True,
+               'master': True}
+
+
+class TestRadosgwZoneModule(object):
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_container_exec(self):
+        cmd = radosgw_zone.container_exec(fake_binary, fake_container_image)
+        assert cmd == fake_container_cmd
+
+    def test_not_is_containerized(self):
+        assert radosgw_zone.is_containerized() is None
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    def test_is_containerized(self):
+        assert radosgw_zone.is_containerized() == fake_container_image
+
+    @pytest.mark.parametrize('image', [None, fake_container_image])
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_pre_generate_radosgw_cmd(self, image):
+        if image:
+            expected_cmd = fake_container_cmd
+        else:
+            expected_cmd = [fake_binary]
+
+        assert radosgw_zone.pre_generate_radosgw_cmd(image) == expected_cmd
+
+    @pytest.mark.parametrize('image', [None, fake_container_image])
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_generate_radosgw_cmd(self, image):
+        if image:
+            expected_cmd = fake_container_cmd
+        else:
+            expected_cmd = [fake_binary]
+
+        expected_cmd.extend([
+            '--cluster',
+            fake_cluster,
+            'zone'
+        ])
+        assert radosgw_zone.generate_radosgw_cmd(fake_cluster, [], image) == expected_cmd
+
+    @pytest.mark.parametrize('image', [fake_container_image])
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_generate_radosgw_cmd_container_args(self, image):
+        container_args = [
+            '-v', '/test:/test:ro',
+        ]
+        expected_cmd = [
+            fake_container_binary,
+            'run',
+            '--rm',
+            '--net=host',
+            '-v', '/test:/test:ro',
+            '-v', '/etc/ceph:/etc/ceph:z',
+            '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+            '-v', '/var/log/ceph/:/var/log/ceph/:z',
+            '--entrypoint=' + fake_binary,
+            fake_container_image
+        ]
+
+        expected_cmd.extend([
+            '--cluster',
+            fake_cluster,
+            'zone'
+        ])
+        assert radosgw_zone.generate_radosgw_cmd(fake_cluster, [], image, container_args) == expected_cmd
+
+    def test_create_zone(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'zone', 'create',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--rgw-zone=' + fake_zone,
+            '--endpoints=' + ','.join(fake_endpoints),
+            '--default',
+            '--master'
+        ]
+
+        assert radosgw_zone.create_zone(fake_module) == expected_cmd
+
+    def test_modify_zone(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'zone', 'modify',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--rgw-zone=' + fake_zone,
+            '--endpoints=' + ','.join(fake_endpoints),
+            '--default',
+            '--master'
+        ]
+
+        assert radosgw_zone.modify_zone(fake_module) == expected_cmd
+
+    def test_get_zone(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'zone', 'get',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--rgw-zone=' + fake_zone,
+            '--format=json'
+        ]
+
+        assert radosgw_zone.get_zone(fake_module) == expected_cmd
+
+    def test_get_zonegroup(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'zonegroup', 'get',
+            '--rgw-zone=' + fake_zone,
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--format=json'
+        ]
+
+        assert radosgw_zone.get_zonegroup(fake_module) == expected_cmd
+
+    def test_get_realm(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'realm', 'get',
+            '--rgw-realm=' + fake_realm,
+            '--format=json'
+        ]
+
+        assert radosgw_zone.get_realm(fake_module) == expected_cmd
+
+    def test_remove_zone(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'zone', 'delete',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--rgw-zone=' + fake_zone
+        ]
+
+        assert radosgw_zone.remove_zone(fake_module) == expected_cmd
+
+    def test_set_zone(self):
+        fake_module = MagicMock()
+        fake_module.params = {
+            'cluster': fake_cluster,
+            'name': fake_zone,
+            'realm': fake_realm,
+            'zonegroup': fake_zonegroup,
+            'zone_doc': {'id': 'fake_id'},
+        }
+
+        zonefile = fake_module.tmpdir + '/zone.json'
+
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'zone', 'set',
+            '--rgw-realm=' + fake_realm,
+            '--infile=' + zonefile,
+        ]
+
+        assert radosgw_zone.set_zone(fake_module) == expected_cmd

tests/library/test_radosgw_zonegroup.py

@@ -0,0 +1,144 @@
+import os
+import sys
+from mock.mock import patch, MagicMock
+import pytest
+sys.path.append('./library')
+import radosgw_zonegroup  # noqa: E402
+
+
+fake_binary = 'radosgw-admin'
+fake_cluster = 'ceph'
+fake_container_binary = 'podman'
+fake_container_image = 'docker.io/ceph/daemon:latest'
+fake_container_cmd = [
+    fake_container_binary,
+    'run',
+    '--rm',
+    '--net=host',
+    '-v', '/etc/ceph:/etc/ceph:z',
+    '-v', '/var/lib/ceph/:/var/lib/ceph/:z',
+    '-v', '/var/log/ceph/:/var/log/ceph/:z',
+    '--entrypoint=' + fake_binary,
+    fake_container_image
+]
+fake_realm = 'foo'
+fake_zonegroup = 'bar'
+fake_endpoints = ['http://192.168.1.10:8080', 'http://192.168.1.11:8080']
+fake_params = {'cluster': fake_cluster,
+               'name': fake_zonegroup,
+               'realm': fake_realm,
+               'endpoints': fake_endpoints,
+               'default': True,
+               'master': True}
+
+
+class TestRadosgwZonegroupModule(object):
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_container_exec(self):
+        cmd = radosgw_zonegroup.container_exec(fake_binary, fake_container_image)
+        assert cmd == fake_container_cmd
+
+    def test_not_is_containerized(self):
+        assert radosgw_zonegroup.is_containerized() is None
+
+    @patch.dict(os.environ, {'CEPH_CONTAINER_IMAGE': fake_container_image})
+    def test_is_containerized(self):
+        assert radosgw_zonegroup.is_containerized() == fake_container_image
+
+    @pytest.mark.parametrize('image', [None, fake_container_image])
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_pre_generate_radosgw_cmd(self, image):
+        if image:
+            expected_cmd = fake_container_cmd
+        else:
+            expected_cmd = [fake_binary]
+
+        assert radosgw_zonegroup.pre_generate_radosgw_cmd(image) == expected_cmd
+
+    @pytest.mark.parametrize('image', [None, fake_container_image])
+    @patch.dict(os.environ, {'CEPH_CONTAINER_BINARY': fake_container_binary})
+    def test_generate_radosgw_cmd(self, image):
+        if image:
+            expected_cmd = fake_container_cmd
+        else:
+            expected_cmd = [fake_binary]
+
+        expected_cmd.extend([
+            '--cluster',
+            fake_cluster,
+            'zonegroup'
+        ])
+        assert radosgw_zonegroup.generate_radosgw_cmd(fake_cluster, [], image) == expected_cmd
+
+    def test_create_zonegroup(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'zonegroup', 'create',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--endpoints=' + ','.join(fake_endpoints),
+            '--default',
+            '--master'
+        ]
+
+        assert radosgw_zonegroup.create_zonegroup(fake_module) == expected_cmd
+
+    def test_modify_zonegroup(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'zonegroup', 'modify',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--endpoints=' + ','.join(fake_endpoints),
+            '--default',
+            '--master'
+        ]
+
+        assert radosgw_zonegroup.modify_zonegroup(fake_module) == expected_cmd
+
+    def test_get_zonegroup(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'zonegroup', 'get',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup,
+            '--format=json'
+        ]
+
+        assert radosgw_zonegroup.get_zonegroup(fake_module) == expected_cmd
+
+    def test_get_realm(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'realm', 'get',
+            '--rgw-realm=' + fake_realm,
+            '--format=json'
+        ]
+
+        assert radosgw_zonegroup.get_realm(fake_module) == expected_cmd
+
+    def test_remove_zonegroup(self):
+        fake_module = MagicMock()
+        fake_module.params = fake_params
+        expected_cmd = [
+            fake_binary,
+            '--cluster', fake_cluster,
+            'zonegroup', 'delete',
+            '--rgw-realm=' + fake_realm,
+            '--rgw-zonegroup=' + fake_zonegroup
+        ]
+
+        assert radosgw_zonegroup.remove_zonegroup(fake_module) == expected_cmd