Move modules and module_utils unit tests to correct place (#81)

* Move modules and module_utils unit tests to correct place.

* Update ignore.txt

* Fix imports.

* Fix typos.

* Fix more typos.

tests/unit/plugins/modules/network/netscaler/netscaler_module.py

@@ -0,0 +1,44 @@
+import sys
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import AnsibleExitJson, AnsibleFailJson, ModuleTestCase
+
+base_modules_mock = Mock()
+nitro_service_mock = Mock()
+nitro_exception_mock = Mock()
+
+
+base_modules_to_mock = {
+    'nssrc': base_modules_mock,
+    'nssrc.com': base_modules_mock,
+    'nssrc.com.citrix': base_modules_mock,
+    'nssrc.com.citrix.netscaler': base_modules_mock,
+    'nssrc.com.citrix.netscaler.nitro': base_modules_mock,
+    'nssrc.com.citrix.netscaler.nitro.resource': base_modules_mock,
+    'nssrc.com.citrix.netscaler.nitro.resource.config': base_modules_mock,
+    'nssrc.com.citrix.netscaler.nitro.exception': base_modules_mock,
+    'nssrc.com.citrix.netscaler.nitro.exception.nitro_exception': base_modules_mock,
+    'nssrc.com.citrix.netscaler.nitro.exception.nitro_exception.nitro_exception': nitro_exception_mock,
+    'nssrc.com.citrix.netscaler.nitro.service': base_modules_mock,
+    'nssrc.com.citrix.netscaler.nitro.service.nitro_service': base_modules_mock,
+    'nssrc.com.citrix.netscaler.nitro.service.nitro_service.nitro_service': nitro_service_mock,
+}
+
+nitro_base_patcher = patch.dict(sys.modules, base_modules_to_mock)
+
+
+class TestModule(ModuleTestCase):
+    def failed(self):
+        with self.assertRaises(AnsibleFailJson) as exc:
+            self.module.main()
+
+        result = exc.exception.args[0]
+        self.assertTrue(result['failed'], result)
+        return result
+
+    def exited(self, changed=False):
+        with self.assertRaises(AnsibleExitJson) as exc:
+            self.module.main()
+
+        result = exc.exception.args[0]
+        return result

tests/unit/plugins/modules/network/netscaler/test_netscaler_cs_action.py

@@ -0,0 +1,636 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+class TestNetscalerCSActionModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+        m = MagicMock()
+        cls.cs_action_mock = MagicMock()
+        cls.cs_action_mock.__class__ = MagicMock(add=Mock())
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csaction': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csaction.csaction': cls.cs_action_mock,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def setUp(self):
+        super(TestNetscalerCSActionModule, self).setUp()
+
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerCSActionModule, self).tearDown()
+
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+        self.module = netscaler_cs_action
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action.nitro_exception', MockException):
+                self.module = netscaler_cs_action
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_cs_action
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_cs_action
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_save_config_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        cs_action_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            action_exists=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            diff_list=Mock(return_value={}),
+            ConfigProxy=Mock(return_value=cs_action_proxy_mock),
+        ):
+            self.module = netscaler_cs_action
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        cs_action_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            action_exists=Mock(side_effect=[True, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=Mock(return_value=cs_action_proxy_mock),
+        ):
+            self.module = netscaler_cs_action
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        cs_action_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            action_exists=Mock(side_effect=[False, True]),
+            diff_list=Mock(return_value={}),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=Mock(return_value=cs_action_proxy_mock),
+        ):
+            self.module = netscaler_cs_action
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        cs_action_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            action_exists=Mock(side_effect=[True, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=Mock(return_value=cs_action_proxy_mock),
+        ):
+            self.module = netscaler_cs_action
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_new_cs_action_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_action_proxy_mock = Mock()
+        cs_action_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_action_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            action_exists=Mock(side_effect=[False, True]),
+            action_identical=Mock(side_effect=[True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_action
+            self.exited()
+            cs_action_proxy_mock.assert_has_calls([call.add()])
+
+    def test_modified_cs_action_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_action_proxy_mock = Mock()
+        cs_action_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_action_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            action_exists=Mock(side_effect=[True, True]),
+            action_identical=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_action
+            self.exited()
+            cs_action_proxy_mock.assert_has_calls([call.update()])
+
+    def test_absent_cs_action_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_action_proxy_mock = Mock()
+        cs_action_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_action_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            action_exists=Mock(side_effect=[True, False]),
+            action_identical=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_action
+            self.exited()
+            cs_action_proxy_mock.assert_has_calls([call.delete()])
+
+    def test_present_cs_action_identical_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_action_proxy_mock = Mock()
+        cs_action_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_action_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            action_exists=Mock(side_effect=[True, True]),
+            action_identical=Mock(side_effect=[True, True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_action
+            self.exited()
+            cs_action_proxy_mock.assert_not_called()
+
+    def test_absent_cs_action_noop_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_action_proxy_mock = Mock()
+        cs_action_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_action_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            action_exists=Mock(side_effect=[False, False]),
+            action_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_action
+            self.exited()
+            cs_action_proxy_mock.assert_not_called()
+
+    def test_present_cs_action_failed_update(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_action_proxy_mock = Mock()
+        cs_action_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_action_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            action_exists=Mock(side_effect=[True, True]),
+            action_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_action
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Content switching action differs from configured')
+            self.assertTrue(result['failed'])
+
+    def test_present_cs_action_failed_create(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_action_proxy_mock = Mock()
+        cs_action_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_action_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            action_exists=Mock(side_effect=[False, False]),
+            action_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_action
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Content switching action does not exist')
+            self.assertTrue(result['failed'])
+
+    def test_present_cs_action_update_immutable_attribute(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_action_proxy_mock = Mock()
+        cs_action_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_action_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=['domain']),
+            action_exists=Mock(side_effect=[True, True]),
+            action_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_action
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Cannot update immutable attributes [\'domain\']')
+            self.assertTrue(result['failed'])
+
+    def test_absent_cs_action_failed_delete(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_action_proxy_mock = Mock()
+        cs_action_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_action_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            action_exists=Mock(side_effect=[True, True]),
+            action_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_action
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Content switching action still exists')
+            self.assertTrue(result['failed'])
+
+    def test_graceful_nitro_exception_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            action_exists=m,
+            ensure_feature_is_enabled=Mock(return_value=True),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_cs_action
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )
+
+    def test_graceful_nitro_exception_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_action
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_action',
+            action_exists=m,
+            ensure_feature_is_enabled=Mock(return_value=True),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_cs_action
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )

tests/unit/plugins/modules/network/netscaler/test_netscaler_cs_policy.py

@@ -0,0 +1,329 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+
+class TestNetscalerCSPolicyModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+        cls.MockException = MockException
+        m = MagicMock()
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs.cspolicy': m,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def set_module_state(self, state):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state=state,
+        ))
+
+    def setUp(self):
+        super(TestNetscalerCSPolicyModule, self).setUp()
+
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+    def tearDown(self):
+        super(TestNetscalerCSPolicyModule, self).tearDown()
+
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        self.set_module_state('present')
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+        self.module = netscaler_cs_policy
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy.nitro_exception', MockException):
+                self.module = netscaler_cs_policy
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy',
+            get_nitro_client=m,
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_cs_policy
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_cs_policy
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_create_non_existing_cs_policy(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+        cs_policy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_policy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=cs_policy_mock)
+        policy_exists_mock = Mock(side_effect=[False, True])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy',
+            ConfigProxy=m,
+            policy_exists=policy_exists_mock,
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+        ):
+            self.module = netscaler_cs_policy
+            result = self.exited()
+            cs_policy_mock.assert_has_calls([call.add()])
+            self.assertTrue(result['changed'], msg='Change not recorded')
+
+    def test_update_cs_policy_when_cs_policy_differs(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+        cs_policy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_policy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=cs_policy_mock)
+        policy_exists_mock = Mock(side_effect=[True, True])
+        policy_identical_mock = Mock(side_effect=[False, True])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy',
+            ConfigProxy=m,
+            policy_exists=policy_exists_mock,
+            policy_identical=policy_identical_mock,
+            ensure_feature_is_enabled=Mock(),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_cs_policy
+            result = self.exited()
+            cs_policy_mock.assert_has_calls([call.update()])
+            self.assertTrue(result['changed'], msg='Change not recorded')
+
+    def test_no_change_to_module_when_all_identical(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+        cs_policy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_policy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=cs_policy_mock)
+        policy_exists_mock = Mock(side_effect=[True, True])
+        policy_identical_mock = Mock(side_effect=[True, True])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy',
+            ConfigProxy=m,
+            policy_exists=policy_exists_mock,
+            policy_identical=policy_identical_mock,
+            ensure_feature_is_enabled=Mock(),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_cs_policy
+            result = self.exited()
+            self.assertFalse(result['changed'], msg='Erroneous changed status update')
+
+    def test_absent_operation(self):
+        self.set_module_state('absent')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+        cs_policy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_policy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=cs_policy_mock)
+        policy_exists_mock = Mock(side_effect=[True, False])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy',
+            ConfigProxy=m,
+            policy_exists=policy_exists_mock,
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+
+        ):
+            self.module = netscaler_cs_policy
+            result = self.exited()
+            cs_policy_mock.assert_has_calls([call.delete()])
+            self.assertTrue(result['changed'], msg='Changed status not set correctly')
+
+    def test_absent_operation_no_change(self):
+        self.set_module_state('absent')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+        cs_policy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_policy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=cs_policy_mock)
+        policy_exists_mock = Mock(side_effect=[False, False])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy',
+            ConfigProxy=m,
+            policy_exists=policy_exists_mock,
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+
+        ):
+            self.module = netscaler_cs_policy
+            result = self.exited()
+            cs_policy_mock.assert_not_called()
+            self.assertFalse(result['changed'], msg='Changed status not set correctly')
+
+    def test_graceful_nitro_exception_operation_present(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy',
+            policy_exists=m,
+            ensure_feature_is_enabled=Mock(),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_cs_policy
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation present'
+            )
+
+    def test_graceful_nitro_exception_operation_absent(self):
+        self.set_module_state('absent')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy',
+            policy_exists=m,
+            nitro_exception=MockException,
+            ensure_feature_is_enabled=Mock(),
+        ):
+            self.module = netscaler_cs_policy
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )
+
+    def test_ensure_feature_is_enabled_called(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_policy
+
+        client_mock = Mock()
+        ensure_feature_is_enabled_mock = Mock()
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_policy',
+            get_nitro_client=Mock(return_value=client_mock),
+            policy_exists=Mock(side_effect=[True, True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=ensure_feature_is_enabled_mock,
+        ):
+            self.module = netscaler_cs_policy
+            result = self.exited()
+            ensure_feature_is_enabled_mock.assert_has_calls([call(client_mock, 'CS')])

tests/unit/plugins/modules/network/netscaler/test_netscaler_cs_vserver.py

@@ -0,0 +1,765 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+class TestNetscalerCSVserverModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+        m = MagicMock()
+        cls.cs_vserver_mock = MagicMock()
+        cls.cs_vserver_mock.__class__ = MagicMock(add=Mock())
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver.csvserver': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver_cspolicy_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver_cspolicy_binding.csvserver_cspolicy_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver_lbvserver_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver_lbvserver_binding.csvserver_lbvserver_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.ssl': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.ssl.sslvserver_sslcertkey_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.ssl.sslvserver_sslcertkey_binding.sslvserver_sslcertkey_binding': m,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def setUp(self):
+        super(TestNetscalerCSVserverModule, self).setUp()
+
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerCSVserverModule, self).tearDown()
+
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+        self.module = netscaler_cs_vserver
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver.nitro_exception', MockException):
+                self.module = netscaler_cs_vserver
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_cs_vserver
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_cs_vserver
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_save_config_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        cs_vserver_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            cs_vserver_exists=Mock(side_effect=[False, True]),
+            cs_vserver_identical=Mock(side_effect=[True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            diff_list=Mock(return_value={}),
+            nitro_exception=self.MockException,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ConfigProxy=Mock(return_value=cs_vserver_proxy_mock),
+        ):
+            self.module = netscaler_cs_vserver
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        cs_vserver_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            cs_vserver_exists=Mock(side_effect=[True, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=Mock(return_value=cs_vserver_proxy_mock),
+        ):
+            self.module = netscaler_cs_vserver
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        cs_vserver_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            cs_vserver_exists=Mock(side_effect=[False, True]),
+            cs_vserver_identical=Mock(side_effect=[True]),
+            diff_list=Mock(return_value={}),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            nitro_exception=self.MockException,
+            ConfigProxy=Mock(return_value=cs_vserver_proxy_mock),
+        ):
+            self.module = netscaler_cs_vserver
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        cs_vserver_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            cs_vserver_exists=Mock(side_effect=[True, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=Mock(return_value=cs_vserver_proxy_mock),
+        ):
+            self.module = netscaler_cs_vserver
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_new_cs_vserver_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            cs_vserver_exists=Mock(side_effect=[False, True]),
+            cs_vserver_identical=Mock(side_effect=[True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+            nitro_exception=self.MockException,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_cs_vserver
+            self.exited()
+            cs_vserver_proxy_mock.assert_has_calls([call.add()])
+
+    def test_modified_cs_vserver_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            cs_vserver_exists=Mock(side_effect=[True, True]),
+            cs_vserver_identical=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            nitro_exception=self.MockException,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            self.exited()
+            cs_vserver_proxy_mock.assert_has_calls([call.update()])
+
+    def test_absent_cs_vserver_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            cs_vserver_exists=Mock(side_effect=[True, False]),
+            cs_vserver_identical=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            self.exited()
+            cs_vserver_proxy_mock.assert_has_calls([call.delete()])
+
+    def test_present_cs_vserver_identical_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            cs_vserver_exists=Mock(side_effect=[True, True]),
+            cs_vserver_identical=Mock(side_effect=[True, True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            self.exited()
+            cs_vserver_proxy_mock.assert_not_called()
+
+    def test_absent_cs_vserver_noop_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            cs_vserver_exists=Mock(side_effect=[False, False]),
+            cs_vserver_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            self.exited()
+            cs_vserver_proxy_mock.assert_not_called()
+
+    def test_present_cs_vserver_failed_update(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            cs_vserver_exists=Mock(side_effect=[True, True]),
+            cs_vserver_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'CS vserver differs from configured')
+            self.assertTrue(result['failed'])
+
+    def test_present_cs_vserver_failed_create(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            cs_vserver_exists=Mock(side_effect=[False, False]),
+            cs_vserver_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'CS vserver does not exist')
+            self.assertTrue(result['failed'])
+
+    def test_present_cs_vserver_update_immutable_attribute(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=['domain']),
+            cs_vserver_exists=Mock(side_effect=[True, True]),
+            cs_vserver_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Cannot update immutable attributes [\'domain\']')
+            self.assertTrue(result['failed'])
+
+    def test_absent_cs_vserver_failed_delete(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            cs_vserver_exists=Mock(side_effect=[True, True]),
+            cs_vserver_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'CS vserver still exists')
+            self.assertTrue(result['failed'])
+
+    def test_graceful_nitro_exception_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            cs_vserver_exists=m,
+            ensure_feature_is_enabled=Mock(return_value=True),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_cs_vserver
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )
+
+    def test_graceful_nitro_exception_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            cs_vserver_exists=m,
+            ensure_feature_is_enabled=Mock(return_value=True),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_cs_vserver
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )
+
+    def test_disabled_state_change_called(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        cs_vserver_proxy_mock = Mock()
+
+        do_state_change_mock = Mock(return_value=Mock(errorcode=0))
+        client_mock = Mock()
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            ConfigProxy=Mock(return_value=cs_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            cs_vserver_exists=Mock(side_effect=[True, True]),
+            cs_vserver_identical=Mock(side_effect=[True, True]),
+            nitro_exception=self.MockException,
+            do_state_change=do_state_change_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            self.exited()
+            self.assertTrue(len(do_state_change_mock.mock_calls) > 0, msg='Did not call state change')
+
+    def test_cs_vserver_ssl_called(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            servicetype='SSL',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+        ssl_certkey_bindings_sync_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            cs_vserver_exists=Mock(side_effect=[True, True]),
+            cs_vserver_identical=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ssl_certkey_bindings_identical=Mock(side_effect=[False, True]),
+            ssl_certkey_bindings_sync=ssl_certkey_bindings_sync_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            result = self.exited()
+            self.assertTrue(result['changed'])
+            self.assertTrue(ssl_certkey_bindings_sync_mock.called)
+
+    def test_cs_vserver_ssl_not_called(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_cs_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        cs_vserver_proxy_mock = Mock()
+        cs_vserver_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=cs_vserver_proxy_mock)
+        ssl_certkey_bindings_sync_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_cs_vserver',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            cs_vserver_exists=Mock(side_effect=[True, True]),
+            cs_vserver_identical=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            ssl_certkey_bindings_identical=Mock(side_effect=[False, True]),
+            ssl_certkey_bindings_sync=ssl_certkey_bindings_sync_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_cs_vserver
+            result = self.exited()
+            self.assertTrue(result['changed'])
+            self.assertFalse(ssl_certkey_bindings_sync_mock.called)

tests/unit/plugins/modules/network/netscaler/test_netscaler_gslb_service.py

@@ -0,0 +1,735 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+class TestNetscalerGSLBSiteModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+        m = MagicMock()
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbservice': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbservice.gslbservice': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbservice_lbmonitor_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbservice_lbmonitor_binding.gslbservice_lbmonitor_binding': m,
+
+            # The following are needed because of monkey_patch_nitro_api()
+            'nssrc.com.citrix.netscaler.nitro.resource.base': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.base.Json': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.base.Json.Json': m,
+            'nssrc.com.citrix.netscaler.nitro.util': m,
+            'nssrc.com.citrix.netscaler.nitro.util.nitro_util': m,
+            'nssrc.com.citrix.netscaler.nitro.util.nitro_util.nitro_util': m,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def setUp(self):
+        super(TestNetscalerGSLBSiteModule, self).setUp()
+
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerGSLBSiteModule, self).tearDown()
+
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+        self.module = netscaler_gslb_service
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service.nitro_exception', MockException):
+                self.module = netscaler_gslb_service
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_gslb_service
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            monkey_patch_nitro_api=Mock(),
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_gslb_service
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_ensure_feature_is_enabled_called(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        gslb_service_proxy_mock = Mock()
+        ensure_feature_is_enabled_mock = Mock()
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=Mock(return_value=client_mock),
+            gslb_service_exists=Mock(side_effect=[False, True]),
+            gslb_service_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=ensure_feature_is_enabled_mock,
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=Mock(return_value=gslb_service_proxy_mock),
+        ):
+            self.module = netscaler_gslb_service
+            self.exited()
+            ensure_feature_is_enabled_mock.assert_called_with(client_mock, 'GSLB')
+
+    def test_save_config_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_service_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            gslb_service_exists=Mock(side_effect=[False, True]),
+            gslb_service_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=Mock(return_value=gslb_service_proxy_mock),
+        ):
+            self.module = netscaler_gslb_service
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_service_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            gslb_service_exists=Mock(side_effect=[True, False]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=Mock(return_value=gslb_service_proxy_mock),
+        ):
+            self.module = netscaler_gslb_service
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_service_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            gslb_service_exists=Mock(side_effect=[False, True]),
+            gslb_service_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=Mock(return_value=gslb_service_proxy_mock),
+        ):
+            self.module = netscaler_gslb_service
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_service_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            gslb_service_exists=Mock(side_effect=[True, False]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=Mock(return_value=gslb_service_proxy_mock),
+        ):
+            self.module = netscaler_gslb_service
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_new_gslb_site_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            gslb_service_exists=Mock(side_effect=[False, True]),
+            gslb_service_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_service
+            self.exited()
+            gslb_service_proxy_mock.assert_has_calls([call.add()])
+
+    def test_modified_gslb_site_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_service_exists=Mock(side_effect=[True, True]),
+            gslb_service_identical=Mock(side_effect=[False, False, True]),
+            monitor_bindings_identical=Mock(side_effect=[True, True, True]),
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            nitro_exception=self.MockException,
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_service
+            self.exited()
+            gslb_service_proxy_mock.assert_has_calls([call.update()])
+
+    def test_absent_gslb_site_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_service_exists=Mock(side_effect=[True, False]),
+            gslb_service_identical=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_service
+            self.exited()
+            gslb_service_proxy_mock.assert_has_calls([call.delete()])
+
+    def test_present_gslb_service_identical_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_service_exists=Mock(side_effect=[True, True]),
+            gslb_service_identical=Mock(side_effect=[True, True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_service
+            self.exited()
+            gslb_service_proxy_mock.assert_not_called()
+
+    def test_absent_gslb_site_noop_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_service_exists=Mock(side_effect=[False, False]),
+            gslb_service_identical=Mock(side_effect=[False, False]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_service
+            self.exited()
+            gslb_service_proxy_mock.assert_not_called()
+
+    def test_present_gslb_site_failed_update(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_service_exists=Mock(side_effect=[True, True]),
+            gslb_service_identical=Mock(side_effect=[False, False, False]),
+            monitor_bindings_identical=Mock(side_effect=[True, True, True]),
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_service
+            result = self.failed()
+            self.assertEqual(result['msg'], 'GSLB service differs from configured')
+            self.assertTrue(result['failed'])
+
+    def test_present_gslb_site_failed_monitor_bindings_update(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_service_exists=Mock(side_effect=[True, True]),
+            gslb_service_identical=Mock(side_effect=[False, False, True]),
+            monitor_bindings_identical=Mock(side_effect=[False, False, False]),
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_service
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Monitor bindings differ from configured')
+            self.assertTrue(result['failed'])
+
+    def test_present_gslb_site_failed_create(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_service_exists=Mock(side_effect=[False, False]),
+            gslb_service_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_service
+            result = self.failed()
+            self.assertEqual(result['msg'], 'GSLB service does not exist')
+            self.assertTrue(result['failed'])
+
+    def test_present_gslb_site_update_immutable_attribute(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=['domain']),
+            gslb_service_exists=Mock(side_effect=[True, True]),
+            gslb_service_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_service
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Cannot update immutable attributes [\'domain\']')
+            self.assertTrue(result['failed'])
+
+    def test_absent_gslb_site_failed_delete(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_service_exists=Mock(side_effect=[True, True]),
+            gslb_service_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_service
+            result = self.failed()
+            self.assertEqual(result['msg'], 'GSLB service still exists')
+            self.assertTrue(result['failed'])
+
+    def test_graceful_nitro_exception_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            gslb_service_exists=m,
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_gslb_service
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )
+
+    def test_graceful_nitro_exception_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_service
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_service',
+            gslb_service_exists=m,
+            ensure_feature_is_enabled=Mock(),
+            monkey_patch_nitro_api=Mock(),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_gslb_service
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )

tests/unit/plugins/modules/network/netscaler/test_netscaler_gslb_site.py

@@ -0,0 +1,668 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+class TestNetscalerGSLBSiteModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+        m = MagicMock()
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbsite': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbsite.gslbsite': m,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def setUp(self):
+        super(TestNetscalerGSLBSiteModule, self).setUp()
+
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerGSLBSiteModule, self).tearDown()
+
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+        self.module = netscaler_gslb_site
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site.nitro_exception', MockException):
+                self.module = netscaler_gslb_site
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_gslb_site
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_gslb_site
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_ensure_feature_is_enabled_called(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        gslb_site_proxy_mock = Mock()
+        ensure_feature_is_enabled_mock = Mock()
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=Mock(return_value=client_mock),
+            gslb_site_exists=Mock(side_effect=[False, True]),
+            gslb_site_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=ensure_feature_is_enabled_mock,
+            ConfigProxy=Mock(return_value=gslb_site_proxy_mock),
+        ):
+            self.module = netscaler_gslb_site
+            self.exited()
+            ensure_feature_is_enabled_mock.assert_called_with(client_mock, 'GSLB')
+
+    def test_save_config_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_site_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            gslb_site_exists=Mock(side_effect=[False, True]),
+            gslb_site_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=Mock(return_value=gslb_site_proxy_mock),
+        ):
+            self.module = netscaler_gslb_site
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_site_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            gslb_site_exists=Mock(side_effect=[True, False]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=Mock(return_value=gslb_site_proxy_mock),
+        ):
+            self.module = netscaler_gslb_site
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_site_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            gslb_site_exists=Mock(side_effect=[False, True]),
+            gslb_site_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=Mock(return_value=gslb_site_proxy_mock),
+        ):
+            self.module = netscaler_gslb_site
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_site_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            gslb_site_exists=Mock(side_effect=[True, False]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=Mock(return_value=gslb_site_proxy_mock),
+        ):
+            self.module = netscaler_gslb_site
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_new_gslb_site_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_site_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_site_proxy_mock = Mock()
+        gslb_site_proxy_mock.configure_mock(**glsb_site_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_site_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            gslb_site_exists=Mock(side_effect=[False, True]),
+            gslb_site_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_site
+            self.exited()
+            gslb_site_proxy_mock.assert_has_calls([call.add()])
+
+    def test_modified_gslb_site_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_site_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_site_proxy_mock = Mock()
+        gslb_site_proxy_mock.configure_mock(**glsb_site_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_site_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_site_exists=Mock(side_effect=[True, True]),
+            gslb_site_identical=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(),
+            nitro_exception=self.MockException,
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_site
+            self.exited()
+            gslb_site_proxy_mock.assert_has_calls([call.update()])
+
+    def test_absent_gslb_site_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_site_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_site_proxy_mock = Mock()
+        gslb_site_proxy_mock.configure_mock(**glsb_site_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_site_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_site_exists=Mock(side_effect=[True, False]),
+            gslb_site_identical=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_site
+            self.exited()
+            gslb_site_proxy_mock.assert_has_calls([call.delete()])
+
+    def test_present_gslb_site_identical_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_site_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_site_proxy_mock = Mock()
+        gslb_site_proxy_mock.configure_mock(**glsb_site_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_site_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_site_exists=Mock(side_effect=[True, True]),
+            gslb_site_identical=Mock(side_effect=[True, True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_site
+            self.exited()
+            gslb_site_proxy_mock.assert_not_called()
+
+    def test_absent_gslb_site_noop_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_site_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_site_proxy_mock = Mock()
+        gslb_site_proxy_mock.configure_mock(**glsb_site_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_site_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_site_exists=Mock(side_effect=[False, False]),
+            gslb_site_identical=Mock(side_effect=[False, False]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_site
+            self.exited()
+            gslb_site_proxy_mock.assert_not_called()
+
+    def test_present_gslb_site_failed_update(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_site_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_site_proxy_mock = Mock()
+        gslb_site_proxy_mock.configure_mock(**glsb_site_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_site_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_site_exists=Mock(side_effect=[True, True]),
+            gslb_site_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_site
+            result = self.failed()
+            self.assertEqual(result['msg'], 'GSLB site differs from configured')
+            self.assertTrue(result['failed'])
+
+    def test_present_gslb_site_failed_create(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_site_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_site_proxy_mock = Mock()
+        gslb_site_proxy_mock.configure_mock(**glsb_site_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_site_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_site_exists=Mock(side_effect=[False, False]),
+            gslb_site_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_site
+            result = self.failed()
+            self.assertEqual(result['msg'], 'GSLB site does not exist')
+            self.assertTrue(result['failed'])
+
+    def test_present_gslb_site_update_immutable_attribute(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_site_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_site_proxy_mock = Mock()
+        gslb_site_proxy_mock.configure_mock(**glsb_site_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_site_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=['domain']),
+            gslb_site_exists=Mock(side_effect=[True, True]),
+            gslb_site_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_site
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Cannot update immutable attributes [\'domain\']')
+            self.assertTrue(result['failed'])
+
+    def test_absent_gslb_site_failed_delete(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_site_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_site_proxy_mock = Mock()
+        gslb_site_proxy_mock.configure_mock(**glsb_site_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_site_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_site_exists=Mock(side_effect=[True, True]),
+            gslb_site_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_site
+            result = self.failed()
+            self.assertEqual(result['msg'], 'GSLB site still exists')
+            self.assertTrue(result['failed'])
+
+    def test_graceful_nitro_exception_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            gslb_site_exists=m,
+            ensure_feature_is_enabled=Mock(),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_gslb_site
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )
+
+    def test_graceful_nitro_exception_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_site
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_site',
+            gslb_site_exists=m,
+            ensure_feature_is_enabled=Mock(),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_gslb_site
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )

tests/unit/plugins/modules/network/netscaler/test_netscaler_gslb_vserver.py

@@ -0,0 +1,758 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+class TestNetscalerGSLBVserverModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+        m = MagicMock()
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbvserver': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbvserver.gslbvserver': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbvserver_gslbservice_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbvserver_gslbservice_binding.gslbvserver_gslbservice_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbvserver_domain_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.gslb.gslbvserver_domain_binding.gslbvserver_domain_binding': m,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def setUp(self):
+        super(TestNetscalerGSLBVserverModule, self).setUp()
+
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerGSLBVserverModule, self).tearDown()
+
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+        self.module = netscaler_gslb_vserver
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver.nitro_exception', MockException):
+                self.module = netscaler_gslb_vserver
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_gslb_vserver
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_gslb_vserver
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_ensure_feature_is_enabled_called(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        gslb_service_proxy_mock = Mock()
+        ensure_feature_is_enabled_mock = Mock()
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            gslb_vserver_exists=Mock(side_effect=[False, True]),
+            gslb_vserver_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=ensure_feature_is_enabled_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ConfigProxy=Mock(return_value=gslb_service_proxy_mock),
+        ):
+            self.module = netscaler_gslb_vserver
+            self.exited()
+            ensure_feature_is_enabled_mock.assert_called_with(client_mock, 'GSLB')
+
+    def test_save_config_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_service_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            gslb_vserver_exists=Mock(side_effect=[False, True]),
+            gslb_vserver_identical=Mock(side_effect=[True]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=Mock(return_value=gslb_service_proxy_mock),
+        ):
+            self.module = netscaler_gslb_vserver
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_service_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            gslb_vserver_exists=Mock(side_effect=[True, False]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=Mock(return_value=gslb_service_proxy_mock),
+        ):
+            self.module = netscaler_gslb_vserver
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_service_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            gslb_vserver_exists=Mock(side_effect=[False, True]),
+            gslb_vserver_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=Mock(return_value=gslb_service_proxy_mock),
+        ):
+            self.module = netscaler_gslb_vserver
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        gslb_service_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            gslb_vserver_exists=Mock(side_effect=[True, False]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=Mock(return_value=gslb_service_proxy_mock),
+        ):
+            self.module = netscaler_gslb_vserver
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_new_gslb_vserver_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            gslb_vserver_exists=Mock(side_effect=[False, True]),
+            gslb_vserver_identical=Mock(side_effect=[True]),
+            nitro_exception=self.MockException,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            self.exited()
+            gslb_service_proxy_mock.assert_has_calls([call.add()])
+
+    def test_modified_gslb_vserver_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_vserver_exists=Mock(side_effect=[True, True]),
+            gslb_vserver_identical=Mock(side_effect=[False, False, True]),
+            ensure_feature_is_enabled=Mock(),
+            domain_bindings_identical=Mock(side_effect=[True, True, True]),
+            service_bindings_identical=Mock(side_effect=[True, True, True]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            nitro_exception=self.MockException,
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            self.exited()
+            gslb_service_proxy_mock.assert_has_calls([call.update()])
+
+    def test_absent_gslb_vserver_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_vserver_exists=Mock(side_effect=[True, False]),
+            gslb_vserver_identical=Mock(side_effect=[False, True]),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            self.exited()
+            gslb_service_proxy_mock.assert_has_calls([call.delete()])
+
+    def test_present_gslb_vserver_identical_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_vserver_exists=Mock(side_effect=[True, True]),
+            gslb_vserver_identical=Mock(side_effect=[True, True]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            self.exited()
+            gslb_service_proxy_mock.assert_not_called()
+
+    def test_present_gslb_vserver_domain_bindings_error_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_vserver_exists=Mock(side_effect=[True, True]),
+            gslb_vserver_identical=Mock(side_effect=[True, True, True]),
+            domain_bindings_identical=Mock(side_effect=[False, False, False]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Domain bindings differ from configured')
+            self.assertTrue(result['failed'])
+
+    def test_present_gslb_vserver_service_bindings_error_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_vserver_exists=Mock(side_effect=[True, True]),
+            gslb_vserver_identical=Mock(side_effect=[True, True, True]),
+            service_bindings_identical=Mock(side_effect=[False, False, False]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Service bindings differ from configured')
+            self.assertTrue(result['failed'])
+
+    def test_absent_gslb_vserver_noop_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_vserver_exists=Mock(side_effect=[False, False]),
+            gslb_vserver_identical=Mock(side_effect=[False, False]),
+            nitro_exception=self.MockException,
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            self.exited()
+            gslb_service_proxy_mock.assert_not_called()
+
+    def test_present_gslb_vserver_failed_update(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_vserver_exists=Mock(side_effect=[True, True]),
+            gslb_vserver_identical=Mock(side_effect=[False, False, False]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'GSLB Vserver differs from configured')
+            self.assertTrue(result['failed'])
+
+    def test_present_gslb_vserver_failed_create(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            gslb_vserver_exists=Mock(side_effect=[False, False]),
+            gslb_vserver_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'GSLB Vserver does not exist')
+            self.assertTrue(result['failed'])
+
+    def test_present_gslb_vserver_update_immutable_attribute(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=['domain']),
+            gslb_vserver_exists=Mock(side_effect=[True, True]),
+            gslb_vserver_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Cannot update immutable attributes [\'domain\']')
+            self.assertTrue(result['failed'])
+
+    def test_absent_gslb_vserver_failed_delete(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        glsb_service_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        gslb_service_proxy_mock = Mock()
+        gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
+        config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            gslb_vserver_exists=Mock(side_effect=[True, True]),
+            gslb_vserver_identical=Mock(side_effect=[False, False]),
+            ensure_feature_is_enabled=Mock(),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_gslb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'GSLB Vserver still exists')
+            self.assertTrue(result['failed'])
+
+    def test_graceful_nitro_exception_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            gslb_vserver_exists=m,
+            ensure_feature_is_enabled=Mock(),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_gslb_vserver
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )
+
+    def test_graceful_nitro_exception_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_gslb_vserver
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_gslb_vserver',
+            gslb_vserver_exists=m,
+            ensure_feature_is_enabled=Mock(),
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_gslb_vserver
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )

tests/unit/plugins/modules/network/netscaler/test_netscaler_lb_monitor.py

@@ -0,0 +1,518 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+class TestNetscalerLBVServerModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+        m = MagicMock()
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbmonitor': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbmonitor.lbvmonitor': m,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def setUp(self):
+        super(TestNetscalerLBVServerModule, self).setUp()
+
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerLBVServerModule, self).tearDown()
+
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+        self.module = netscaler_lb_monitor
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=m,
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=m,
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_save_config_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=m,
+            lbmonitor_exists=Mock(side_effect=[False, True]),
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+        ):
+            self.module = netscaler_lb_monitor
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=m,
+            lbmonitor_exists=Mock(side_effect=[True, False]),
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+        ):
+            self.module = netscaler_lb_monitor
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=m,
+            lbmonitor_exists=Mock(side_effect=[False, True]),
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+        ):
+            self.module = netscaler_lb_monitor
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=m,
+            lbmonitor_exists=Mock(side_effect=[True, False]),
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+        ):
+            self.module = netscaler_lb_monitor
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_ensure_feature_is_enabled_called(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        client_mock = Mock()
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+        feature_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=Mock(return_value=client_mock),
+            lbmonitor_exists=Mock(side_effect=[True, True]),
+            lbmonitor_identical=Mock(side_effect=[True, True]),
+
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=feature_mock,
+        ):
+            self.module = netscaler_lb_monitor
+            self.exited()
+            feature_mock.assert_called_with(client_mock, 'LB')
+
+    def test_ensure_feature_is_enabled_nitro_exception_caught(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        client_mock = Mock()
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+        errorcode = 10
+        message = 'mock error'
+
+        class MockException(Exception):
+            def __init__(self):
+                self.errorcode = errorcode
+                self.message = message
+
+        feature_mock = Mock(side_effect=MockException)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=Mock(return_value=client_mock),
+            lbmonitor_exists=Mock(side_effect=[True, True]),
+            lbmonitor_identical=Mock(side_effect=[True, True]),
+
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=feature_mock,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.failed()
+            expected_msg = 'nitro exception errorcode=%s, message=%s' % (errorcode, message)
+            self.assertEqual(result['msg'], expected_msg, 'Failed to handle nitro exception')
+
+    def test_create_new_lb_monitor_workflow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=Mock(return_value=Mock()),
+            lbmonitor_exists=Mock(side_effect=[False, True]),
+            lbmonitor_identical=Mock(side_effect=[True]),
+
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.exited()
+            lb_monitor_proxy_mock.assert_has_calls([call.add()])
+            self.assertTrue(result['changed'])
+
+    def test_update_lb_monitor_workflow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=Mock(return_value=Mock()),
+            lbmonitor_exists=Mock(side_effect=[True, True]),
+            lbmonitor_identical=Mock(side_effect=[False, True]),
+
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            get_immutables_intersection=Mock(return_value=[]),
+            diff_list=Mock(return_value={}),
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.exited()
+            lb_monitor_proxy_mock.assert_has_calls([call.update()])
+            self.assertTrue(result['changed'])
+
+    def test_lb_monitor_exists_sanity_check(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=Mock(return_value=client_mock),
+            lbmonitor_exists=Mock(side_effect=[False, False]),
+            lbmonitor_identical=Mock(side_effect=[False, True]),
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.failed()
+            self.assertEqual(result['msg'], 'lb monitor does not exist')
+
+    def test_lb_monitor_identical_sanity_check(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=Mock(return_value=client_mock),
+            lbmonitor_exists=Mock(side_effect=[True, True]),
+            lbmonitor_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            get_immutables_intersection=(Mock(return_value=[])),
+            nitro_exception=self.MockException,
+            diff_list=Mock(return_value={}),
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.failed()
+            self.assertEqual(result['msg'], 'lb monitor is not configured correctly')
+
+    def test_absent_state_workflow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        client_mock = Mock()
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=Mock(return_value=client_mock),
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            lbmonitor_exists=Mock(side_effect=[True, False]),
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.exited()
+            lb_monitor_proxy_mock.assert_has_calls([call.delete()])
+            self.assertTrue(result['changed'])
+
+    def test_absent_state_sanity_check(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        client_mock = Mock()
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=Mock(return_value=client_mock),
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            lbmonitor_exists=Mock(side_effect=[True, True]),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.failed()
+            lb_monitor_proxy_mock.assert_has_calls([call.delete()])
+            self.assertEqual(result['msg'], 'lb monitor still exists')
+
+    def test_get_immutables_failure(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_monitor
+
+        lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
+
+        client_mock = Mock()
+        m = Mock(return_value=['some'])
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_monitor',
+            get_nitro_client=Mock(return_value=client_mock),
+            ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
+            ensure_feature_is_enabled=Mock(),
+            lbmonitor_exists=Mock(side_effect=[True, True]),
+            lbmonitor_identical=Mock(side_effect=[False, True]),
+            get_immutables_intersection=m,
+            diff_list=Mock(return_value={}),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_monitor
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('Cannot update immutable attributes'),
+                msg='Did not handle immutables error correctly',
+            )

tests/unit/plugins/modules/network/netscaler/test_netscaler_lb_vserver.py

@@ -0,0 +1,840 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+class TestNetscalerLBVServerModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+        m = MagicMock()
+        cls.server_mock = MagicMock()
+        cls.server_mock.__class__ = MagicMock(add=Mock())
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver.lbvserver': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver_service_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver_service_binding.lbvserver_service_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver_servicegroup_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver_servicegroup_binding.lbvserver_servicegroup_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.ssl': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.ssl.sslvserver_sslcertkey_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.ssl.sslvserver_sslcertkey_binding.sslvserver_sslcertkey_binding': m,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def setUp(self):
+        super(TestNetscalerLBVServerModule, self).setUp()
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerLBVServerModule, self).tearDown()
+
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+        self.module = netscaler_lb_vserver
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver.nitro_exception', MockException):
+                self.module = netscaler_lb_vserver
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=m,
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=m,
+            nitro_exception=self.MockException,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_save_config_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        lb_vserver_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=m,
+            lb_vserver_exists=Mock(side_effect=[False, True]),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_lb_vserver
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        lb_vserver_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=m,
+            lb_vserver_exists=Mock(side_effect=[True, False]),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_lb_vserver
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        lb_vserver_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=m,
+            lb_vserver_exists=Mock(side_effect=[False, True]),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_lb_vserver
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        lb_vserver_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=m,
+            lb_vserver_exists=Mock(side_effect=[True, False]),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_lb_vserver
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_ensure_feature_is_enabled_called(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        client_mock = Mock()
+
+        lb_vserver_proxy_mock = Mock()
+        feature_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[True, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[True, True]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=feature_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_lb_vserver
+            self.exited()
+            feature_mock.assert_called_with(client_mock, 'LB')
+
+    def test_ensure_feature_is_enabled_nitro_exception_caught(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        client_mock = Mock()
+
+        lb_vserver_proxy_mock = Mock()
+        errorcode = 10
+        message = 'mock error'
+
+        class MockException(Exception):
+            def __init__(self):
+                self.errorcode = errorcode
+                self.message = message
+
+        feature_mock = Mock(side_effect=MockException)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[True, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[True, True]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=feature_mock,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.failed()
+            expected_msg = 'nitro exception errorcode=%s, message=%s' % (errorcode, message)
+            self.assertEqual(result['msg'], expected_msg, 'Failed to handle nitro exception')
+
+    def test_create_new_lb_vserver_workflow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=Mock()),
+            lb_vserver_exists=Mock(side_effect=[False, True]),
+            lb_vserver_identical=Mock(side_effect=[True]),
+            servicegroup_bindings_identical=Mock(side_effect=[True, True]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.exited()
+            lb_vserver_proxy_mock.assert_has_calls([call.add()])
+            self.assertTrue(result['changed'])
+
+    def test_update_lb_vserver_workflow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=Mock()),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[False, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[True, True]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            get_immutables_intersection=Mock(return_value=[]),
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.exited()
+            lb_vserver_proxy_mock.assert_has_calls([call.update()])
+            self.assertTrue(result['changed'])
+
+    def test_service_bindings_handling(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+        configured_dict = {
+            'first': Mock(),
+            'second': Mock(has_equal_attributes=Mock(return_value=False)),
+        }
+
+        actual_dict = {
+            'second': Mock(),
+            'third': Mock(),
+        }
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[False, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[True, True]),
+            service_bindings_identical=Mock(side_effect=[False, True]),
+            get_configured_service_bindings=Mock(return_value=configured_dict),
+            get_actual_service_bindings=Mock(return_value=actual_dict),
+
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            get_immutables_intersection=(Mock(return_value=[])),
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.exited()
+            configured_dict['first'].assert_has_calls([call.add()])
+
+            configured_dict['second'].assert_has_calls([call.has_equal_attributes(actual_dict['second']), call.add()])
+
+            actual_dict['second'].assert_has_calls([call.delete(client_mock, actual_dict['second'])])
+
+            actual_dict['third'].assert_has_calls([call.delete(client_mock, actual_dict['third'])])
+
+            self.assertTrue(result['changed'])
+
+    def test_servicegroup_bindings_handling(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+        configured_dict = {
+            'first': Mock(),
+            'second': Mock(has_equal_attributes=Mock(return_value=False)),
+        }
+
+        actual_dict = {
+            'second': Mock(),
+            'third': Mock(),
+        }
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[False, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[False, True]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+            get_configured_servicegroup_bindings=Mock(return_value=configured_dict),
+            get_actual_servicegroup_bindings=Mock(return_value=actual_dict),
+
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            get_immutables_intersection=(Mock(return_value=[])),
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.exited()
+            configured_dict['first'].assert_has_calls([call.add()])
+
+            configured_dict['second'].assert_has_calls([call.has_equal_attributes(actual_dict['second']), call.add()])
+
+            actual_dict['second'].assert_has_calls([call.delete(client_mock, actual_dict['second'])])
+
+            actual_dict['third'].assert_has_calls([call.delete(client_mock, actual_dict['third'])])
+
+            self.assertTrue(result['changed'])
+
+    def test_ssl_bindings_handling(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+            servicetype='SSL',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+        ssl_sync_mock = Mock()
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[False, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[True, True]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+            ssl_certkey_bindings_identical=Mock(side_effect=[False, True]),
+            ssl_certkey_bindings_sync=ssl_sync_mock,
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            get_immutables_intersection=(Mock(return_value=[])),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.exited()
+            self.assertTrue(len(ssl_sync_mock.mock_calls) > 0, msg='ssl cert_key bindings not called')
+            self.assertTrue(result['changed'])
+
+    def test_ssl_bindings_not_called_for_non_ssl_service(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+            servicetype='HTTP',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+        ssl_sync_mock = Mock()
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[False, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[True, True]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+            ssl_certkey_bindings_identical=Mock(side_effect=[False, True]),
+            ssl_certkey_bindings_sync=ssl_sync_mock,
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            get_immutables_intersection=(Mock(return_value=[])),
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.exited()
+            ssl_sync_mock.assert_not_called()
+            self.assertTrue(result['changed'])
+
+    def test_server_exists_sanity_check(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+        ssl_sync_mock = Mock()
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[False, False]),
+            lb_vserver_identical=Mock(side_effect=[False, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[True, True]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+            ssl_certkey_bindings_identical=Mock(side_effect=[False, True]),
+            ssl_certkey_bindings_sync=ssl_sync_mock,
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Did not create lb vserver')
+
+    def test_server_identical_sanity_check(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+        ssl_sync_mock = Mock()
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[False, False]),
+            servicegroup_bindings_identical=Mock(side_effect=[True, True]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+            ssl_certkey_bindings_identical=Mock(side_effect=[False, True]),
+            ssl_certkey_bindings_sync=ssl_sync_mock,
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            get_immutables_intersection=(Mock(return_value=[])),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'lb vserver is not configured correctly')
+
+    def test_service_bindings_sanity_check(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[False, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[True, True]),
+            service_bindings_identical=Mock(side_effect=[False, False]),
+            ssl_certkey_bindings_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            get_immutables_intersection=(Mock(return_value=[])),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'service bindings are not identical')
+
+    def test_servicegroup_bindings_sanity_check(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[False, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[False, False]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+            ssl_certkey_bindings_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            get_immutables_intersection=(Mock(return_value=[])),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'servicegroup bindings are not identical')
+
+    def test_server_servicegroup_bindings_sanity_check(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[False, True]),
+            servicegroup_bindings_identical=Mock(side_effect=[False, False]),
+            service_bindings_identical=Mock(side_effect=[True, True]),
+            ssl_certkey_bindings_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            get_immutables_intersection=(Mock(return_value=[])),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.failed()
+            self.assertEqual(result['msg'], 'servicegroup bindings are not identical')
+
+    def test_absent_state_workflow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+
+        client_mock = Mock()
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            lb_vserver_exists=Mock(side_effect=[True, False]),
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.exited()
+            lb_vserver_proxy_mock.assert_has_calls([call.delete()])
+            self.assertTrue(result['changed'])
+
+    def test_absent_state_sanity_check(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+
+        client_mock = Mock()
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.failed()
+            lb_vserver_proxy_mock.assert_has_calls([call.delete()])
+            self.assertEqual(result['msg'], 'lb vserver still exists')
+
+    def test_disabled_state_change_called(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+
+        do_state_change_mock = Mock(return_value=Mock(errorcode=0))
+        client_mock = Mock()
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(return_value=True),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            nitro_exception=self.MockException,
+            do_state_change=do_state_change_mock,
+        ):
+            self.module = netscaler_lb_vserver
+            self.exited()
+            self.assertTrue(len(do_state_change_mock.mock_calls) > 0, msg='Did not call state change')
+
+    def test_get_immutables_failure(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_lb_vserver
+
+        lb_vserver_proxy_mock = Mock()
+
+        client_mock = Mock()
+        m = Mock(return_value=['some'])
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_lb_vserver',
+            get_nitro_client=Mock(return_value=client_mock),
+            ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
+            ensure_feature_is_enabled=Mock(),
+            lb_vserver_exists=Mock(side_effect=[True, True]),
+            lb_vserver_identical=Mock(side_effect=[False]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            get_immutables_intersection=m,
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_lb_vserver
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('Cannot update immutable attributes'),
+                msg='Did not handle immutables error correctly',
+            )

tests/unit/plugins/modules/network/netscaler/test_netscaler_nitro_request.py

@@ -0,0 +1,344 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, call
+from .netscaler_module import TestModule
+import copy
+import tempfile
+import json
+import codecs
+
+from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_nitro_request
+
+module_arguments = dict(
+    nsip=None,
+    nitro_user=None,
+    nitro_pass=None,
+    nitro_protocol=None,
+    validate_certs=None,
+    nitro_auth_token=None,
+    resource=None,
+    name=None,
+    attributes=None,
+    args=None,
+    filter=None,
+    operation=None,
+    expected_nitro_errorcode=None,
+    action=None,
+    instance_ip=None,
+    instance_name=None,
+    instance_id=None,
+)
+
+
+class TestNetscalerNitroRequestModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+    # This has code in a parent class
+    def setUp(self):
+        pass
+
+    def test_fail_on_conflicting_authentication_methods(self):
+        args = copy.deepcopy(module_arguments)
+        args.update(dict(
+            nitro_user='nsroot',
+            nitro_pass='nsroot',
+            nitro_auth_token='##DDASKLFDJ',
+        ))
+        mock_module_instance = Mock(params=args)
+        expected_calls = [
+            call.fail_json(
+                changed=False,
+                failed=True,
+                msg='Cannot define both authentication token and username/password'
+            )
+        ]
+        module_mock = Mock(return_value=mock_module_instance)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule', module_mock):
+            netscaler_nitro_request.NitroAPICaller()
+            mock_module_instance.assert_has_calls(expected_calls)
+
+    def test_nitro_user_pass_credentials(self):
+        args = copy.deepcopy(module_arguments)
+        args.update(dict(
+            nitro_user='nsroot',
+            nitro_pass='nsroot',
+        ))
+        mock_module_instance = Mock(params=args)
+        expected_headers = {
+            'Content-Type': 'application/json',
+            'X-NITRO-USER': 'nsroot',
+            'X-NITRO-PASS': 'nsroot',
+        }
+        module_mock = Mock(return_value=mock_module_instance)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule', module_mock):
+            instance = netscaler_nitro_request.NitroAPICaller()
+            self.assertDictEqual(instance._headers, expected_headers)
+
+    def test_mas_login_headers(self):
+        args = copy.deepcopy(module_arguments)
+        args.update(dict(
+            nitro_user='nsroot',
+            nitro_pass='nsroot',
+            operation='mas_login',
+        ))
+        mock_module_instance = Mock(params=args)
+        expected_headers = {
+            'Content-Type': 'application/json',
+        }
+        module_mock = Mock(return_value=mock_module_instance)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule', module_mock):
+            instance = netscaler_nitro_request.NitroAPICaller()
+            self.assertDictEqual(instance._headers, expected_headers)
+
+    def test_mas_proxy_call_headers_instance_ip(self):
+        args = copy.deepcopy(module_arguments)
+        args.update(dict(
+            nitro_auth_token='##ABDB',
+            operation='add',
+            instance_ip='192.168.1.1',
+        ))
+        mock_module_instance = Mock(params=args)
+        expected_headers = {
+            'Content-Type': 'application/json',
+            '_MPS_API_PROXY_MANAGED_INSTANCE_IP': args['instance_ip'],
+            'Cookie': 'NITRO_AUTH_TOKEN=%s' % args['nitro_auth_token'],
+        }
+        module_mock = Mock(return_value=mock_module_instance)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule', module_mock):
+            instance = netscaler_nitro_request.NitroAPICaller()
+            self.assertDictEqual(instance._headers, expected_headers)
+
+    def test_mas_proxy_call_headers_instance_id(self):
+        args = copy.deepcopy(module_arguments)
+        args.update(dict(
+            nitro_auth_token='##ABDB',
+            operation='add',
+            instance_id='myid',
+        ))
+        mock_module_instance = Mock(params=args)
+        expected_headers = {
+            'Content-Type': 'application/json',
+            '_MPS_API_PROXY_MANAGED_INSTANCE_ID': args['instance_id'],
+            'Cookie': 'NITRO_AUTH_TOKEN=%s' % args['nitro_auth_token'],
+        }
+        module_mock = Mock(return_value=mock_module_instance)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule', module_mock):
+            instance = netscaler_nitro_request.NitroAPICaller()
+            self.assertDictEqual(instance._headers, expected_headers)
+
+    def test_mas_proxy_call_headers_instance_name(self):
+        args = copy.deepcopy(module_arguments)
+        args.update(dict(
+            nitro_auth_token='##ABDB',
+            operation='add',
+            instance_name='myname',
+        ))
+        mock_module_instance = Mock(params=args)
+        expected_headers = {
+            'Content-Type': 'application/json',
+            '_MPS_API_PROXY_MANAGED_INSTANCE_NAME': args['instance_name'],
+            'Cookie': 'NITRO_AUTH_TOKEN=%s' % args['nitro_auth_token'],
+        }
+        module_mock = Mock(return_value=mock_module_instance)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule', module_mock):
+            instance = netscaler_nitro_request.NitroAPICaller()
+            self.assertDictEqual(instance._headers, expected_headers)
+
+    def test_edit_response_data_no_body_success_status(self):
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule'):
+            instance = netscaler_nitro_request.NitroAPICaller()
+            r = None
+            info = {
+                'status': 200,
+            }
+            result = {}
+            success_status = 200
+
+            expected_result = {
+                'nitro_errorcode': 0,
+                'nitro_message': 'Success',
+                'nitro_severity': 'NONE',
+                'http_response_body': '',
+                'http_response_data': info,
+            }
+            instance.edit_response_data(r, info, result, success_status)
+            self.assertDictEqual(result, expected_result)
+
+    def test_edit_response_data_no_body_fail_status(self):
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule'):
+            instance = netscaler_nitro_request.NitroAPICaller()
+            r = None
+            info = {
+                'status': 201,
+            }
+            result = {}
+            success_status = 200
+
+            expected_result = {
+                'nitro_errorcode': -1,
+                'nitro_message': 'HTTP status %s' % info['status'],
+                'nitro_severity': 'ERROR',
+                'http_response_body': '',
+                'http_response_data': info,
+            }
+            instance.edit_response_data(r, info, result, success_status)
+            self.assertDictEqual(result, expected_result)
+
+    def test_edit_response_data_actual_body_data(self):
+        args = copy.deepcopy(module_arguments)
+        args.update(dict(
+            nitro_user='nsroot',
+            nitro_pass='nsroot',
+            nitro_auth_token='##DDASKLFDJ',
+        ))
+        module_mock = Mock(params=args, from_json=json.loads)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule',
+                   Mock(return_value=module_mock)):
+            with tempfile.TemporaryFile() as r:
+                actual_body = {
+                    'errorcode': 258,
+                    'message': 'Some error',
+                    'severity': 'ERROR',
+                }
+                r.write(codecs.encode(json.dumps(actual_body), 'utf-8'))
+                r.seek(0)
+
+                instance = netscaler_nitro_request.NitroAPICaller()
+                info = {
+                    'status': 200,
+                }
+                result = {}
+                success_status = 200
+
+                expected_result = {
+                    'http_response_body': json.dumps(actual_body),
+                    'http_response_data': info,
+                }
+                nitro_data = {}
+                for key, value in actual_body.items():
+                    nitro_data['nitro_%s' % key] = value
+                expected_result.update(nitro_data)
+
+                instance.edit_response_data(r, info, result, success_status)
+                self.assertDictEqual(result, expected_result)
+
+    def test_edit_response_data_actual_body_data_irrelevant(self):
+        args = copy.deepcopy(module_arguments)
+        args.update(dict(
+            nitro_user='nsroot',
+            nitro_pass='nsroot',
+            nitro_auth_token='##DDASKLFDJ',
+        ))
+        module_mock = Mock(params=args, from_json=json.loads)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule',
+                   Mock(return_value=module_mock)):
+            with tempfile.TemporaryFile() as r:
+                actual_body = {}
+                r.write(codecs.encode(json.dumps(actual_body), 'utf-8'))
+                r.seek(0)
+
+                instance = netscaler_nitro_request.NitroAPICaller()
+                info = {
+                    'status': 200,
+                }
+                result = {}
+                success_status = 200
+
+                expected_result = {
+                    'http_response_body': json.dumps(actual_body),
+                    'http_response_data': info,
+                    'nitro_errorcode': 0,
+                    'nitro_message': 'Success',
+                    'nitro_severity': 'NONE',
+                }
+
+                instance.edit_response_data(r, info, result, success_status)
+                self.assertDictEqual(result, expected_result)
+
+    def test_edit_response_data_body_in_info(self):
+        args = copy.deepcopy(module_arguments)
+        args.update(dict(
+            nitro_user='nsroot',
+            nitro_pass='nsroot',
+        ))
+        module_mock = Mock(params=args, from_json=json.loads)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule',
+                   Mock(return_value=module_mock)):
+            body = {
+                'errorcode': 258,
+                'message': 'Numerical error 258',
+                'severity': 'ERROR'
+            }
+            instance = netscaler_nitro_request.NitroAPICaller()
+            r = None
+            info = {
+                'status': 200,
+                'body': codecs.encode(json.dumps(body), 'utf-8'),
+            }
+            result = {}
+            success_status = 200
+
+            expected_result = {
+                'http_response_body': json.dumps(body),
+                'http_response_data': info,
+            }
+
+            nitro_data = {}
+            for key, value in body.items():
+                nitro_data['nitro_%s' % key] = value
+
+            expected_result.update(nitro_data)
+            instance.edit_response_data(r, info, result, success_status)
+            self.assertDictEqual(result, expected_result)
+
+    def test_handle_get_return_object(self):
+        resource = 'lbvserver'
+        args = copy.deepcopy(module_arguments)
+        args.update(dict(
+            nitro_user='nsroot',
+            nitro_pass='nsroot',
+            resource=resource,
+        ))
+        resource_data = {
+            'property1': 'value1',
+            'property2': 'value2',
+        }
+        module_mock = Mock(params=args, from_json=json.loads)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_nitro_request.AnsibleModule',
+                   Mock(return_value=module_mock)):
+            instance = netscaler_nitro_request.NitroAPICaller()
+
+            data = {resource: resource_data}
+            result = {
+                'nitro_errorcode': 0,
+                'http_response_body': json.dumps(data),
+            }
+            expected_result = {
+                'nitro_object': resource_data
+            }
+            expected_result.update(result)
+            instance.handle_get_return_object(result)
+            self.assertDictEqual(result, expected_result)

tests/unit/plugins/modules/network/netscaler/test_netscaler_save_config.py

@@ -0,0 +1,148 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, call
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+class TestNetscalerSaveConfigModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+
+    def setUp(self):
+        super(TestNetscalerSaveConfigModule, self).setUp()
+        self.nitro_base_patcher.start()
+
+    def tearDown(self):
+        super(TestNetscalerSaveConfigModule, self).tearDown()
+        self.nitro_base_patcher.stop()
+
+    def test_graceful_nitro_error_on_login(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_save_config
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_save_config.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_save_config.nitro_exception', MockException):
+                self.module = netscaler_save_config
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_save_config
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_save_config',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_save_config
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_save_config
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_save_config',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_save_config
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_save_config_called(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+        ))
+
+        class MockException(Exception):
+            pass
+
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_save_config
+        client_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_save_config',
+            get_nitro_client=Mock(return_value=client_mock),
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_save_config
+            self.exited()
+            call_sequence = [call.login(), call.save_config(), call.logout()]
+            client_mock.assert_has_calls(call_sequence)

tests/unit/plugins/modules/network/netscaler/test_netscaler_server.py

@@ -0,0 +1,696 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+class TestNetscalerServerModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+        m = MagicMock()
+        cls.server_mock = MagicMock()
+        cls.server_mock.__class__ = MagicMock(add=Mock())
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.server': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.server.server': cls.server_mock,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def setUp(self):
+        super(TestNetscalerServerModule, self).setUp()
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerServerModule, self).tearDown()
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+        self.module = netscaler_server
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server.nitro_exception', MockException):
+                self.module = netscaler_server
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_server
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_server
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_save_config_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            server_exists=Mock(side_effect=[False, True]),
+            ConfigProxy=Mock(return_value=server_proxy_mock),
+            diff_list=Mock(return_value={}),
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            server_exists=Mock(side_effect=[True, False]),
+            ConfigProxy=Mock(return_value=server_proxy_mock),
+            diff_list=Mock(return_value={}),
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            server_exists=Mock(side_effect=[False, True]),
+            ConfigProxy=Mock(return_value=server_proxy_mock),
+            diff_list=Mock(return_value={}),
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            server_exists=Mock(side_effect=[True, False]),
+            ConfigProxy=Mock(return_value=server_proxy_mock),
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_do_state_change_fail(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            server_exists=Mock(side_effect=[True, False]),
+            ConfigProxy=Mock(return_value=server_proxy_mock),
+            diff_list=Mock(return_value={}),
+            do_state_change=Mock(return_value=Mock(errorcode=1, message='Failed on purpose'))
+        ):
+            self.module = netscaler_server
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Error when setting disabled state. errorcode: 1 message: Failed on purpose')
+
+    def test_disable_server_graceful(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            disabled=True,
+            graceful=True
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_mock = Mock()
+
+        d = {
+            'graceful': True,
+            'delay': 20,
+        }
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value=d),
+            get_immutables_intersection=Mock(return_value=[]),
+            server_exists=Mock(side_effect=[True, True]),
+            ConfigProxy=Mock(return_value=server_proxy_mock),
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            result = self.exited()
+            self.assertEqual(d, {}, 'Graceful disable options were not discarded from the diff_list with the actual object')
+
+    def test_new_server_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        server_proxy_mock = Mock()
+        server_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=server_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            server_exists=Mock(side_effect=[False, True]),
+            server_identical=Mock(side_effect=[True]),
+            ConfigProxy=config_proxy_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            self.exited()
+            server_proxy_mock.assert_has_calls([call.add()])
+
+    def test_modified_server_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        server_proxy_mock = Mock()
+        server_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=server_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            server_exists=Mock(side_effect=[True, True]),
+            server_identical=Mock(side_effect=[False, True]),
+            ConfigProxy=config_proxy_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            self.exited()
+            server_proxy_mock.assert_has_calls([call.update()])
+
+    def test_absent_server_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        server_proxy_mock = Mock()
+        server_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=server_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            server_exists=Mock(side_effect=[True, False]),
+            server_identical=Mock(side_effect=[False, True]),
+            ConfigProxy=config_proxy_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            self.exited()
+            server_proxy_mock.assert_has_calls([call.delete()])
+
+    def test_present_server_identical_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        server_proxy_mock = Mock()
+        server_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=server_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            server_exists=Mock(side_effect=[True, True]),
+            server_identical=Mock(side_effect=[True, True]),
+            ConfigProxy=config_proxy_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            self.exited()
+            server_proxy_mock.assert_not_called()
+
+    def test_absent_server_noop_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        server_proxy_mock = Mock()
+        server_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=server_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            server_exists=Mock(side_effect=[False, False]),
+            server_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=config_proxy_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            self.exited()
+            server_proxy_mock.assert_not_called()
+
+    def test_present_server_failed_update(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        server_proxy_mock = Mock()
+        server_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=server_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            server_exists=Mock(side_effect=[True, True]),
+            server_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=config_proxy_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Server is not configured according to parameters given')
+            self.assertTrue(result['failed'])
+
+    def test_present_server_failed_create(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        server_proxy_mock = Mock()
+        server_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=server_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            server_exists=Mock(side_effect=[False, False]),
+            server_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=config_proxy_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Server does not seem to exist')
+            self.assertTrue(result['failed'])
+
+    def test_present_server_update_immutable_attribute(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        server_proxy_mock = Mock()
+        server_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=server_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=['domain']),
+            server_exists=Mock(side_effect=[True, True]),
+            server_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=config_proxy_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Cannot update immutable attributes [\'domain\']')
+            self.assertTrue(result['failed'])
+
+    def test_absent_server_failed_delete(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        server_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        server_proxy_mock = Mock()
+        server_proxy_mock.configure_mock(**server_proxy_attrs)
+        config_proxy_mock = Mock(return_value=server_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            server_exists=Mock(side_effect=[True, True]),
+            server_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=config_proxy_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0))
+        ):
+            self.module = netscaler_server
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Server seems to be present')
+            self.assertTrue(result['failed'])
+
+    def test_graceful_nitro_exception_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            server_exists=m,
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_server
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )
+
+    def test_graceful_nitro_exception_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_server
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_server',
+            server_exists=m,
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_server
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )

tests/unit/plugins/modules/network/netscaler/test_netscaler_service.py

@@ -0,0 +1,350 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+
+class TestNetscalerServiceModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        m = MagicMock()
+        cls.service_mock = MagicMock()
+        cls.service_mock.__class__ = MagicMock()
+        cls.service_lbmonitor_binding_mock = MagicMock()
+        cls.lbmonitor_service_binding_mock = MagicMock()
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.service': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.service.service': cls.service_mock,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.service_lbmonitor_binding': cls.service_lbmonitor_binding_mock,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.service_lbmonitor_binding.service_lbmonitor_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbmonitor_service_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbmonitor_service_binding.lbmonitor_service_binding': cls.lbmonitor_service_binding_mock,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def set_module_state(self, state):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state=state,
+        ))
+
+    def setUp(self):
+        super(TestNetscalerServiceModule, self).setUp()
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerServiceModule, self).tearDown()
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        self.set_module_state('present')
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+        self.module = netscaler_service
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service.nitro_exception', MockException):
+                self.module = netscaler_service
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_service
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_service
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_create_non_existing_service(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+        service_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        service_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=service_proxy_mock)
+        service_exists_mock = Mock(side_effect=[False, True])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service',
+            ConfigProxy=m,
+            service_exists=service_exists_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_service
+            result = self.exited()
+            service_proxy_mock.assert_has_calls([call.add()])
+            self.assertTrue(result['changed'], msg='Change not recorded')
+
+    def test_update_service_when_service_differs(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+        service_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        service_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=service_proxy_mock)
+        service_exists_mock = Mock(side_effect=[True, True])
+        service_identical_mock = Mock(side_effect=[False, True])
+        monitor_bindings_identical_mock = Mock(side_effect=[True, True])
+        all_identical_mock = Mock(side_effect=[False])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service',
+            ConfigProxy=m,
+            service_exists=service_exists_mock,
+            service_identical=service_identical_mock,
+            monitor_bindings_identical=monitor_bindings_identical_mock,
+            all_identical=all_identical_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_service
+            result = self.exited()
+            service_proxy_mock.assert_has_calls([call.update()])
+            self.assertTrue(result['changed'], msg='Change not recorded')
+
+    def test_update_service_when_monitor_bindings_differ(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+        service_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        service_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=service_proxy_mock)
+        service_exists_mock = Mock(side_effect=[True, True])
+        service_identical_mock = Mock(side_effect=[True, True])
+        monitor_bindings_identical_mock = Mock(side_effect=[False, True])
+        all_identical_mock = Mock(side_effect=[False])
+        sync_monitor_bindings_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service',
+            ConfigProxy=m,
+            service_exists=service_exists_mock,
+            service_identical=service_identical_mock,
+            monitor_bindings_identical=monitor_bindings_identical_mock,
+            all_identical=all_identical_mock,
+            sync_monitor_bindings=sync_monitor_bindings_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_service
+            result = self.exited()
+        # poor man's assert_called_once since python3.5 does not implement that mock method
+        self.assertEqual(len(sync_monitor_bindings_mock.mock_calls), 1, msg='sync monitor bindings not called once')
+        self.assertTrue(result['changed'], msg='Change not recorded')
+
+    def test_no_change_to_module_when_all_identical(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+        service_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        service_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=service_proxy_mock)
+        service_exists_mock = Mock(side_effect=[True, True])
+        service_identical_mock = Mock(side_effect=[True, True])
+        monitor_bindings_identical_mock = Mock(side_effect=[True, True])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service',
+            ConfigProxy=m,
+            service_exists=service_exists_mock,
+            service_identical=service_identical_mock,
+            monitor_bindings_identical=monitor_bindings_identical_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_service
+            result = self.exited()
+            self.assertFalse(result['changed'], msg='Erroneous changed status update')
+
+    def test_absent_operation(self):
+        self.set_module_state('absent')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+        service_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        service_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=service_proxy_mock)
+        service_exists_mock = Mock(side_effect=[True, False])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service',
+            ConfigProxy=m,
+            service_exists=service_exists_mock,
+
+        ):
+            self.module = netscaler_service
+            result = self.exited()
+            service_proxy_mock.assert_has_calls([call.delete()])
+            self.assertTrue(result['changed'], msg='Changed status not set correctly')
+
+    def test_absent_operation_no_change(self):
+        self.set_module_state('absent')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+        service_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        service_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=service_proxy_mock)
+        service_exists_mock = Mock(side_effect=[False, False])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service',
+            ConfigProxy=m,
+            service_exists=service_exists_mock,
+
+        ):
+            self.module = netscaler_service
+            result = self.exited()
+            service_proxy_mock.assert_not_called()
+            self.assertFalse(result['changed'], msg='Changed status not set correctly')
+
+    def test_graceful_nitro_exception_operation_present(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service',
+            service_exists=m,
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_service
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation present'
+            )
+
+    def test_graceful_nitro_exception_operation_absent(self):
+        self.set_module_state('absent')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_service
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_service',
+            service_exists=m,
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_service
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )

tests/unit/plugins/modules/network/netscaler/test_netscaler_servicegroup.py

@@ -0,0 +1,537 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+
+class TestNetscalerServicegroupModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+        cls.MockException = MockException
+        m = MagicMock()
+        cls.servicegroup_mock = MagicMock()
+        cls.servicegroup_mock.__class__ = MagicMock()
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup.servicegroup': cls.servicegroup_mock,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup_servicegroupmember_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup_servicegroupmember_binding.servicegroup_servicegroupmember_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup_lbmonitor_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup_lbmonitor_binding.servicegroup_lbmonitor_binding': m,
+
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbmonitor_servicegroup_binding': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbmonitor_servicegroup_binding.lbmonitor_servicegroup_binding': m
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def set_module_state(self, state):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state=state,
+        ))
+
+    def setUp(self):
+        super(TestNetscalerServicegroupModule, self).setUp()
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerServicegroupModule, self).tearDown()
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        self.set_module_state('present')
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        self.module = netscaler_servicegroup
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup.nitro_exception', MockException):
+                self.module = netscaler_servicegroup
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            get_nitro_client=m,
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_servicegroup
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            get_nitro_client=m,
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_servicegroup
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_create_non_existing_servicegroup(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        servicegroup_exists_mock = Mock(side_effect=[False, True])
+
+        servicegroup_servicegroupmember_binding_mock = Mock(count=Mock(return_value=0))
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=servicegroup_exists_mock,
+            servicemembers_identical=Mock(side_effect=[False, True]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            servicegroup_servicegroupmember_binding=servicegroup_servicegroupmember_binding_mock,
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_servicegroup
+            result = self.exited()
+            servicegroup_proxy_mock.assert_has_calls([call.add()])
+            self.assertTrue(result['changed'], msg='Change not recorded')
+
+    def test_update_servicegroup_when_servicegroup_differs(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        servicegroup_exists_mock = Mock(side_effect=[True, True])
+        servicegroup_identical_mock = Mock(side_effect=[False, True])
+        monitor_bindings_identical_mock = Mock(side_effect=[True, True])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=servicegroup_exists_mock,
+            servicegroup_identical=servicegroup_identical_mock,
+            monitor_bindings_identical=monitor_bindings_identical_mock,
+            servicemembers_identical=Mock(side_effect=[True, True]),
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_servicegroup
+            result = self.exited()
+            servicegroup_proxy_mock.assert_has_calls([call.update()])
+            self.assertTrue(result['changed'], msg='Change not recorded')
+
+    def test_update_servicegroup_when_monitor_bindings_differ(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        servicegroup_exists_mock = Mock(side_effect=[True, True])
+        servicegroup_identical_mock = Mock(side_effect=[True, True])
+        monitor_bindings_identical_mock = Mock(side_effect=[False, True])
+        sync_monitor_bindings_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=servicegroup_exists_mock,
+            servicegroup_identical=servicegroup_identical_mock,
+            monitor_bindings_identical=monitor_bindings_identical_mock,
+            nitro_exception=self.MockException,
+            servicemembers_identical=Mock(side_effect=[True, True]),
+            sync_monitor_bindings=sync_monitor_bindings_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_servicegroup
+            result = self.exited()
+        # poor man's assert_called_once since python3.5 does not implement that mock method
+        self.assertEqual(len(sync_monitor_bindings_mock.mock_calls), 1, msg='sync monitor bindings not called once')
+        self.assertTrue(result['changed'], msg='Change not recorded')
+
+    def test_update_servicegroup_when_service_members_differ(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        sync_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=Mock(side_effect=[True, True]),
+            servicegroup_identical=Mock(side_effect=[True, True]),
+            monitor_bindings_identical=Mock(side_effect=[True, True]),
+            sync_monitor_bindings=Mock(),
+            servicemembers_identical=Mock(side_effect=[False, True]),
+            sync_service_members=sync_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_servicegroup
+            result = self.exited()
+        # poor man's assert_called_once since python3.5 does not implement that mock method
+        self.assertEqual(len(sync_mock.mock_calls), 1, msg='sync monitor bindings not called once')
+        self.assertTrue(result['changed'], msg='Change not recorded')
+
+    def test_immutables_changed(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=Mock(side_effect=[True, True]),
+            servicegroup_identical=Mock(side_effect=[False, True]),
+            get_immutables_intersection=Mock(return_value=['some']),
+            nitro_exception=self.MockException,
+
+        ):
+            self.module = netscaler_servicegroup
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Cannot update immutable attributes'))
+
+    def test_servicegroup_exists_sanity(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        sync_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=Mock(side_effect=[False, False]),
+            servicegroup_identical=Mock(side_effect=[False, False]),
+            monitor_bindings_identical=Mock(side_effect=[True, True]),
+            sync_monitor_bindings=Mock(),
+            servicemembers_identical=Mock(side_effect=[False, True]),
+            nitro_exception=self.MockException,
+            sync_service_members=sync_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_servicegroup
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Service group is not present')
+
+    def test_servicegroup_differ_sanity(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        sync_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=Mock(side_effect=[True, True]),
+            servicegroup_identical=Mock(side_effect=[False, False]),
+            monitor_bindings_identical=Mock(side_effect=[True, True]),
+            sync_monitor_bindings=Mock(),
+            servicemembers_identical=Mock(side_effect=[False, True]),
+            nitro_exception=self.MockException,
+            sync_service_members=sync_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_servicegroup
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Service group is not identical to configuration')
+
+    def test_servicegroup_servicemembers_differ_sanity(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        sync_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=Mock(side_effect=[True, True]),
+            servicegroup_identical=Mock(side_effect=[True, True]),
+            monitor_bindings_identical=Mock(side_effect=[True, True]),
+            sync_monitor_bindings=Mock(),
+            servicemembers_identical=Mock(side_effect=[False, False]),
+            nitro_exception=self.MockException,
+            sync_service_members=sync_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_servicegroup
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Service group members differ from configuration')
+
+    def test_servicegroup_monitor_bindings_sanity(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        sync_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=Mock(side_effect=[True, True]),
+            servicegroup_identical=Mock(side_effect=[True, True]),
+            monitor_bindings_identical=Mock(side_effect=[False, False]),
+            sync_monitor_bindings=Mock(),
+            servicemembers_identical=Mock(side_effect=[True, True]),
+            nitro_exception=self.MockException,
+            sync_service_members=sync_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+        ):
+            self.module = netscaler_servicegroup
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Monitor bindings are not identical')
+
+    def test_no_change_to_module_when_all_identical(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        servicegroup_exists_mock = Mock(side_effect=[True, True])
+        servicegroup_identical_mock = Mock(side_effect=[True, True])
+        monitor_bindings_identical_mock = Mock(side_effect=[True, True])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=servicegroup_exists_mock,
+            servicegroup_identical=servicegroup_identical_mock,
+            servicemembers_identical=Mock(side_effect=[True, True]),
+            monitor_bindings_identical=monitor_bindings_identical_mock,
+            do_state_change=Mock(return_value=Mock(errorcode=0)),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_servicegroup
+            result = self.exited()
+            self.assertFalse(result['changed'], msg='Erroneous changed status update')
+
+    def test_absent_operation(self):
+        self.set_module_state('absent')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        servicegroup_exists_mock = Mock(side_effect=[True, False])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=servicegroup_exists_mock,
+
+        ):
+            self.module = netscaler_servicegroup
+            result = self.exited()
+            servicegroup_proxy_mock.assert_has_calls([call.delete()])
+            self.assertTrue(result['changed'], msg='Changed status not set correctly')
+
+    def test_absent_operation_no_change(self):
+        self.set_module_state('absent')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+        servicegroup_proxy_mock = MagicMock()
+        attrs = {
+            'diff_object.return_value': {},
+        }
+        servicegroup_proxy_mock.configure_mock(**attrs)
+
+        m = MagicMock(return_value=servicegroup_proxy_mock)
+        servicegroup_exists_mock = Mock(side_effect=[False, False])
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=m,
+            servicegroup_exists=servicegroup_exists_mock,
+
+        ):
+            self.module = netscaler_servicegroup
+            result = self.exited()
+            servicegroup_proxy_mock.assert_not_called()
+            self.assertFalse(result['changed'], msg='Changed status not set correctly')
+
+    def test_absent_operation_sanity(self):
+        self.set_module_state('absent')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            ConfigProxy=MagicMock(),
+            servicegroup_exists=Mock(side_effect=[True, True]),
+            nitro_exception=self.MockException,
+
+        ):
+            self.module = netscaler_servicegroup
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Service group is present')
+
+    def test_graceful_nitro_exception_operation_present(self):
+        self.set_module_state('present')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            servicegroup_exists=m,
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_servicegroup
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation present'
+            )
+
+    def test_graceful_nitro_exception_operation_absent(self):
+        self.set_module_state('absent')
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_servicegroup
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_servicegroup',
+            servicegroup_exists=m,
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_servicegroup
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )

tests/unit/plugins/modules/network/netscaler/test_netscaler_ssl_certkey.py

@@ -0,0 +1,621 @@
+
+#  Copyright (c) 2017 Citrix Systems
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from ansible_collections.community.general.tests.unit.compat.mock import patch, Mock, MagicMock, call
+from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args
+from .netscaler_module import TestModule, nitro_base_patcher
+
+import sys
+
+if sys.version_info[:2] != (2, 6):
+    import requests
+
+
+class TestNetscalerSSLCertkeyModule(TestModule):
+
+    @classmethod
+    def setUpClass(cls):
+        class MockException(Exception):
+            pass
+
+        cls.MockException = MockException
+
+        m = MagicMock()
+        cls.server_mock = MagicMock()
+        cls.server_mock.__class__ = MagicMock(add=Mock())
+        nssrc_modules_mock = {
+            'nssrc.com.citrix.netscaler.nitro.resource.config.ssl': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.ssl.sslcertkey': m,
+            'nssrc.com.citrix.netscaler.nitro.resource.config.ssl.sslcertkey.sslcertkey': m,
+        }
+
+        cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
+        cls.nitro_base_patcher = nitro_base_patcher
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.nitro_base_patcher.stop()
+        cls.nitro_specific_patcher.stop()
+
+    def setUp(self):
+        super(TestNetscalerSSLCertkeyModule, self).setUp()
+        self.nitro_base_patcher.start()
+        self.nitro_specific_patcher.start()
+
+        # Setup minimal required arguments to pass AnsibleModule argument parsing
+
+    def tearDown(self):
+        super(TestNetscalerSSLCertkeyModule, self).tearDown()
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+
+    def test_graceful_nitro_api_import_error(self):
+        # Stop nitro api patching to cause ImportError
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        self.nitro_base_patcher.stop()
+        self.nitro_specific_patcher.stop()
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+        self.module = netscaler_ssl_certkey
+        result = self.failed()
+        self.assertEqual(result['msg'], 'Could not load nitro python sdk')
+
+    def test_graceful_nitro_error_on_login(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        client_mock = Mock()
+        client_mock.login = Mock(side_effect=MockException)
+        m = Mock(return_value=client_mock)
+        with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey.get_nitro_client', m):
+            with patch('ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey.nitro_exception', MockException):
+                self.module = netscaler_ssl_certkey
+                result = self.failed()
+                self.assertTrue(result['msg'].startswith('nitro exception'), msg='nitro exception during login not handled properly')
+
+    def test_graceful_no_connection_error(self):
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.ConnectionError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_ssl_certkey
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('Connection error'), msg='Connection error was not handled gracefully')
+
+    def test_graceful_login_error(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        if sys.version_info[:2] == (2, 6):
+            self.skipTest('requests library not available under python2.6')
+
+        class MockException(Exception):
+            pass
+        client_mock = Mock()
+        attrs = {'login.side_effect': requests.exceptions.SSLError}
+        client_mock.configure_mock(**attrs)
+        m = Mock(return_value=client_mock)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            nitro_exception=MockException,
+        ):
+            self.module = netscaler_ssl_certkey
+            result = self.failed()
+            self.assertTrue(result['msg'].startswith('SSL Error'), msg='SSL Error was not handled gracefully')
+
+    def test_save_config_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            key_exists=Mock(side_effect=[False, True]),
+            key_identical=Mock(side_effect=[True]),
+            ConfigProxy=Mock(return_value=ssl_certkey_proxy_mock),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_ssl_certkey
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            key_exists=Mock(side_effect=[True, False]),
+            ConfigProxy=Mock(return_value=ssl_certkey_proxy_mock),
+        ):
+            self.module = netscaler_ssl_certkey
+            self.exited()
+            self.assertIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            key_exists=Mock(side_effect=[False, True]),
+            key_identical=Mock(side_effect=[True]),
+            ConfigProxy=Mock(return_value=ssl_certkey_proxy_mock),
+            nitro_exception=self.MockException,
+        ):
+            self.module = netscaler_ssl_certkey
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_save_config_not_called_on_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+            save_config=False,
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_mock = Mock()
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            key_exists=Mock(side_effect=[True, False]),
+            ConfigProxy=Mock(return_value=ssl_certkey_proxy_mock),
+        ):
+            self.module = netscaler_ssl_certkey
+            self.exited()
+            self.assertNotIn(call.save_config(), client_mock.mock_calls)
+
+    def test_new_ssl_certkey_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        ssl_certkey_proxy_mock = Mock()
+        ssl_certkey_proxy_mock.configure_mock(**ssl_certkey_proxy_attrs)
+        config_proxy_mock = Mock(return_value=ssl_certkey_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            key_exists=Mock(side_effect=[False, True]),
+            key_identical=Mock(side_effect=[True]),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_ssl_certkey
+            self.exited()
+            ssl_certkey_proxy_mock.assert_has_calls([call.add()])
+
+    def test_modified_server_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        ssl_certkey_proxy_mock = Mock()
+        ssl_certkey_proxy_mock.configure_mock(**ssl_certkey_proxy_attrs)
+        config_proxy_mock = Mock(return_value=ssl_certkey_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            key_exists=Mock(side_effect=[True, True]),
+            key_identical=Mock(side_effect=[False, True]),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_ssl_certkey
+            self.exited()
+            ssl_certkey_proxy_mock.assert_has_calls([call.update()])
+
+    def test_absent_server_execution_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        ssl_certkey_proxy_mock = Mock()
+        ssl_certkey_proxy_mock.configure_mock(**ssl_certkey_proxy_attrs)
+        config_proxy_mock = Mock(return_value=ssl_certkey_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            key_exists=Mock(side_effect=[True, False]),
+            key_identical=Mock(side_effect=[False, True]),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_ssl_certkey
+            self.exited()
+            ssl_certkey_proxy_mock.assert_has_calls([call.delete()])
+
+    def test_present_key_identical_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        ssl_certkey_proxy_mock = Mock()
+        ssl_certkey_proxy_mock.configure_mock(**ssl_certkey_proxy_attrs)
+        config_proxy_mock = Mock(return_value=ssl_certkey_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            key_exists=Mock(side_effect=[True, True]),
+            key_identical=Mock(side_effect=[True, True]),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_ssl_certkey
+            self.exited()
+            ssl_certkey_proxy_mock.assert_not_called()
+
+    def test_absent_server_noop_flow(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        ssl_certkey_proxy_mock = Mock()
+        ssl_certkey_proxy_mock.configure_mock(**ssl_certkey_proxy_attrs)
+        config_proxy_mock = Mock(return_value=ssl_certkey_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            key_exists=Mock(side_effect=[False, False]),
+            key_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_ssl_certkey
+            self.exited()
+            ssl_certkey_proxy_mock.assert_not_called()
+
+    def test_present_server_failed_update(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        ssl_certkey_proxy_mock = Mock()
+        ssl_certkey_proxy_mock.configure_mock(**ssl_certkey_proxy_attrs)
+        config_proxy_mock = Mock(return_value=ssl_certkey_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            key_exists=Mock(side_effect=[True, True]),
+            key_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_ssl_certkey
+            result = self.failed()
+            self.assertEqual(result['msg'], 'SSL certkey differs from configured')
+            self.assertTrue(result['failed'])
+
+    def test_present_server_failed_create(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        ssl_certkey_proxy_mock = Mock()
+        ssl_certkey_proxy_mock.configure_mock(**ssl_certkey_proxy_attrs)
+        config_proxy_mock = Mock(return_value=ssl_certkey_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            key_exists=Mock(side_effect=[False, False]),
+            key_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_ssl_certkey
+            result = self.failed()
+            self.assertEqual(result['msg'], 'SSL certkey does not exist')
+            self.assertTrue(result['failed'])
+
+    def test_present_server_update_immutable_attribute(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        ssl_certkey_proxy_mock = Mock()
+        ssl_certkey_proxy_mock.configure_mock(**ssl_certkey_proxy_attrs)
+        config_proxy_mock = Mock(return_value=ssl_certkey_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=['domain']),
+            key_exists=Mock(side_effect=[True, True]),
+            key_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_ssl_certkey
+            result = self.failed()
+            self.assertEqual(result['msg'], 'Cannot update immutable attributes [\'domain\']')
+            self.assertTrue(result['failed'])
+
+    def test_absent_server_failed_delete(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        client_mock = Mock()
+
+        m = Mock(return_value=client_mock)
+
+        ssl_certkey_proxy_attrs = {
+            'diff_object.return_value': {},
+        }
+        ssl_certkey_proxy_mock = Mock()
+        ssl_certkey_proxy_mock.configure_mock(**ssl_certkey_proxy_attrs)
+        config_proxy_mock = Mock(return_value=ssl_certkey_proxy_mock)
+
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            nitro_exception=self.MockException,
+            get_nitro_client=m,
+            diff_list=Mock(return_value={}),
+            get_immutables_intersection=Mock(return_value=[]),
+            key_exists=Mock(side_effect=[True, True]),
+            key_identical=Mock(side_effect=[False, False]),
+            ConfigProxy=config_proxy_mock,
+        ):
+            self.module = netscaler_ssl_certkey
+            result = self.failed()
+            self.assertEqual(result['msg'], 'SSL certkey still exists')
+            self.assertTrue(result['failed'])
+
+    def test_graceful_nitro_exception_state_present(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='present',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            key_exists=m,
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_ssl_certkey
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )
+
+    def test_graceful_nitro_exception_state_absent(self):
+        set_module_args(dict(
+            nitro_user='user',
+            nitro_pass='pass',
+            nsip='192.0.2.1',
+            state='absent',
+        ))
+        from ansible_collections.community.general.plugins.modules.network.netscaler import netscaler_ssl_certkey
+
+        class MockException(Exception):
+            def __init__(self, *args, **kwargs):
+                self.errorcode = 0
+                self.message = ''
+
+        m = Mock(side_effect=MockException)
+        with patch.multiple(
+            'ansible_collections.community.general.plugins.modules.network.netscaler.netscaler_ssl_certkey',
+            key_exists=m,
+            nitro_exception=MockException
+        ):
+            self.module = netscaler_ssl_certkey
+            result = self.failed()
+            self.assertTrue(
+                result['msg'].startswith('nitro exception'),
+                msg='Nitro exception not caught on operation absent'
+            )