From a6f867630fa8bec660edaed37ee4686731fab8a8 Mon Sep 17 00:00:00 2001 From: Jayesh Kariya Date: Mon, 16 Mar 2015 10:28:13 +0530 Subject: [PATCH] adding rabbitmq unit test --- tests/unit/modules/rabbitmq_test.py | 365 ++++++++++++++++++++++++++++ 1 file changed, 365 insertions(+) create mode 100644 tests/unit/modules/rabbitmq_test.py diff --git a/tests/unit/modules/rabbitmq_test.py b/tests/unit/modules/rabbitmq_test.py new file mode 100644 index 0000000000..22ed78544e --- /dev/null +++ b/tests/unit/modules/rabbitmq_test.py @@ -0,0 +1,365 @@ +# -*- coding: utf-8 -*- +''' + :codeauthor: :email:`Jayesh Kariya ` +''' + +# Import Python Libs +from __future__ import absolute_import + +# Import Salt Testing Libs +from salttesting import TestCase, skipIf +from salttesting.mock import ( + MagicMock, + patch, + NO_MOCK, + NO_MOCK_REASON +) + +from salttesting.helpers import ensure_in_syspath + +ensure_in_syspath('../../') + +# Import Salt Libs +from salt.modules import rabbitmq + +# Globals +rabbitmq.__salt__ = {} + + +@skipIf(NO_MOCK, NO_MOCK_REASON) +class RabbitmqTestCase(TestCase): + ''' + Test cases for salt.modules.rabbitmq + ''' + # 'list_users' function tests: 1 + + def test_list_users(self): + ''' + Test if it return a list of users based off of rabbitmqctl user_list. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.list_users(), {}) + + # 'list_vhosts' function tests: 1 + + def test_list_vhosts(self): + ''' + Test if it return a list of vhost based on rabbitmqctl list_vhosts. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertListEqual(rabbitmq.list_vhosts(), ['saltstack']) + + # 'user_exists' function tests: 1 + + def test_user_exists(self): + ''' + Test if it return whether the user exists based + on rabbitmqctl list_users. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertFalse(rabbitmq.user_exists('rabbit_user')) + + # 'vhost_exists' function tests: 1 + + def test_vhost_exists(self): + ''' + Test if it return whether the vhost exists based + on rabbitmqctl list_vhosts. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertTrue(rabbitmq.vhost_exists('saltstack')) + + # 'add_user' function tests: 1 + + def test_add_user(self): + ''' + Test if it add a rabbitMQ user via rabbitmqctl + user_add + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.add_user('saltstack'), + {'Added': 'saltstack'}) + + mock_run = MagicMock(return_value='Error') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + with patch.object(rabbitmq, 'clear_password', + return_value={'Error': 'Error', 'retcode': 1}): + self.assertDictEqual(rabbitmq.add_user('saltstack'), + {'Error': {'Error': 'Error', + 'retcode': 1}}) + + # 'delete_user' function tests: 1 + + def test_delete_user(self): + ''' + Test if it deletes a user via rabbitmqctl delete_user. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.delete_user('saltstack'), + {'Deleted': 'saltstack'}) + + # 'change_password' function tests: 1 + + def test_change_password(self): + ''' + Test if it changes a user's password. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.change_password('saltstack', + 'salt@123'), + {'Password Changed': 'saltstack'}) + + # 'clear_password' function tests: 1 + + def test_clear_password(self): + ''' + Test if it removes a user's password. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.clear_password('saltstack'), + {'Password Cleared': 'saltstack'}) + + # 'add_vhost' function tests: 1 + + def test_add_vhost(self): + ''' + Test if it adds a vhost via rabbitmqctl add_vhost. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.add_vhost('saltstack'), + {'Added': 'saltstack'}) + + # 'delete_vhost' function tests: 1 + + def test_delete_vhost(self): + ''' + Test if it deletes a vhost rabbitmqctl delete_vhost. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.delete_vhost('saltstack'), + {'Deleted': 'saltstack'}) + + # 'set_permissions' function tests: 1 + + def test_set_permissions(self): + ''' + Test if it sets permissions for vhost via rabbitmqctl set_permissions. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.set_permissions('myvhost', 'myuser'), + {'Permissions Set': 'saltstack'}) + + # 'list_user_permissions' function tests: 1 + + def test_list_user_permissions(self): + ''' + Test if it list permissions for a user + via rabbitmqctl list_user_permissions. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertListEqual(rabbitmq.list_user_permissions('myuser'), + [['saltstack']]) + + # 'set_user_tags' function tests: 1 + + def test_set_user_tags(self): + ''' + Test if it add user tags via rabbitmqctl set_user_tags. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.set_user_tags('myadmin', 'admin'), + {'Tag(s) set': 'saltstack'}) + + # 'status' function tests: 1 + + def test_status(self): + ''' + Test if it return rabbitmq status. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertEqual(rabbitmq.status(), 'saltstack') + + # 'cluster_status' function tests: 1 + + def test_cluster_status(self): + ''' + Test if it return rabbitmq cluster_status. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertEqual(rabbitmq.cluster_status(), 'saltstack') + + # 'join_cluster' function tests: 1 + + def test_join_cluster(self): + ''' + Test if it join a rabbit cluster. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.join_cluster('rabbit.example.com'), + {'Join': 'saltstack'}) + + # 'stop_app' function tests: 1 + + def test_stop_app(self): + ''' + Test if it stops the RabbitMQ application, + leaving the Erlang node running. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertEqual(rabbitmq.stop_app(), 'saltstack') + + # 'start_app' function tests: 1 + + def test_start_app(self): + ''' + Test if it start the RabbitMQ application. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertEqual(rabbitmq.start_app(), 'saltstack') + + # 'reset' function tests: 1 + + def test_reset(self): + ''' + Test if it return a RabbitMQ node to its virgin state + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertEqual(rabbitmq.reset(), 'saltstack') + + # 'force_reset' function tests: 1 + + def test_force_reset(self): + ''' + Test if it forcefully Return a RabbitMQ node to its virgin state + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertEqual(rabbitmq.force_reset(), 'saltstack') + + # 'list_queues' function tests: 1 + + def test_list_queues(self): + ''' + Test if it returns queue details of the / virtual host + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertEqual(rabbitmq.list_queues(), 'saltstack') + + # 'list_queues_vhost' function tests: 1 + + def test_list_queues_vhost(self): + ''' + Test if it returns queue details of specified virtual host. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertEqual(rabbitmq.list_queues_vhost('consumers'), + 'saltstack') + + # 'list_policies' function tests: 1 + + def test_list_policies(self): + ''' + Test if it return a dictionary of policies nested by vhost + and name based on the data returned from rabbitmqctl list_policies. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.list_policies(), {}) + + # 'set_policy' function tests: 1 + + def test_set_policy(self): + ''' + Test if it set a policy based on rabbitmqctl set_policy. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.set_policy('/', 'HA', '.*', + '{"ha-mode": "all"}'), + {'Set': 'saltstack'}) + + # 'delete_policy' function tests: 1 + + def test_delete_policy(self): + ''' + Test if it delete a policy based on rabbitmqctl clear_policy. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertDictEqual(rabbitmq.delete_policy('/', 'HA'), + {'Deleted': 'saltstack'}) + + # 'policy_exists' function tests: 1 + + def test_policy_exists(self): + ''' + Test if it return whether the policy exists + based on rabbitmqctl list_policies. + ''' + mock_run = MagicMock(return_value='saltstack') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run}): + self.assertFalse(rabbitmq.policy_exists('/', 'HA')) + + # 'plugin_is_enabled' function tests: 1 + + def test_plugin_is_enabled(self): + ''' + Test if it return whether the plugin is enabled. + ''' + mock_run = MagicMock(return_value='saltstack') + mock_pkg = MagicMock(return_value='') + with patch.dict(rabbitmq.__salt__, {'cmd.run': mock_run, + 'pkg.version': mock_pkg}): + self.assertTrue(rabbitmq.plugin_is_enabled('salt')) + + # 'enable_plugin' function tests: 1 + + def test_enable_plugin(self): + ''' + Test if it enable a RabbitMQ plugin via the rabbitmq-plugins command. + ''' + mock_run = MagicMock(return_value='saltstack') + mock_pkg = MagicMock(return_value='') + with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run, + 'pkg.version': mock_pkg}): + self.assertDictEqual(rabbitmq.enable_plugin('salt'), + {'Enabled': 'saltstack'}) + + # 'disable_plugin' function tests: 1 + + def test_disable_plugin(self): + ''' + Test if it disable a RabbitMQ plugin via the rabbitmq-plugins command. + ''' + mock_run = MagicMock(return_value='saltstack') + mock_pkg = MagicMock(return_value='') + with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run, + 'pkg.version': mock_pkg}): + self.assertDictEqual(rabbitmq.disable_plugin('salt'), + {'Disabled': 'saltstack'}) + + +if __name__ == '__main__': + from integration import run_tests + run_tests(RabbitmqTestCase, needs_daemon=False)