ansible-collections/community.general
1
0
Fork 0
mirror of https://github.com/ansible-collections/community.general.git synced 2025-07-22 04:40:22 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Refactors and deprecation removals (#34830)

Browse source 
This patch is primarily a refactor to make the validate-modules arg-spec
no longer generate a traceback. It additionally includes removal of deprecated
code in the virtual server module.
This commit is contained in:
Tim Rupp 2018-01-12 23:03:41 -08:00 • committed by GitHub
commit c548ab0f18
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
26 changed files with 1612 additions and 2099 deletions
Download patch file Download diff file Expand all files Collapse all files

15
test/units/modules/network/f5/fixtures/load_vlan_interfaces.json Normal file
View file

@ -0,0 +1,15 @@
{
"kind": "tm:net:vlan:interfaces:interfacescollectionstate",
"selfLink": "https://localhost/mgmt/tm/net/vlan/~Common~vlan1/interfaces?ver=13.0.0",
"items": [
{
"kind": "tm:net:vlan:interfaces:interfacesstate",
"name": "1.2",
"fullPath": "1.2",
"generation": 105,
"selfLink": "https://localhost/mgmt/tm/net/vlan/~Common~vlan1/interfaces/1.2?ver=13.0.0",
"tagMode": "none",
"tagged": true
}
]
}

21
test/units/modules/network/f5/test_bigip_sys_db.py
View file

@ -17,20 +17,22 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigip_sys_db import Parameters
from library.bigip_sys_db import ModuleManager
from library.bigip_sys_db import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
from ansible.modules.network.f5.bigip_sys_db import Parameters
from ansible.modules.network.f5.bigip_sys_db import ModuleManager
from ansible.modules.network.f5.bigip_sys_db import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -66,7 +68,7 @@ class TestParameters(unittest.TestCase):
server='localhost',
user='admin'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.key == 'foo'
assert p.value == 'bar'
@ -80,13 +82,11 @@ class TestParameters(unittest.TestCase):
user='admin'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.key == 'foo'
assert p.value == 'bar'
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
@ -118,12 +118,11 @@ class TestManager(unittest.TestCase):
)
)
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
mm = ModuleManager(client)
mm = ModuleManager(module=module)
# Override methods to force specific logic in the module to happen
mm.exists = Mock(return_value=False)

23
test/units/modules/network/f5/test_bigip_sys_global.py
View file

@ -17,14 +17,15 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigip_sys_global import ApiParameters
from library.bigip_sys_global import ModuleParameters
from library.bigip_sys_global import ModuleManager
from library.bigip_sys_global import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
@ -32,7 +33,8 @@ except ImportError:
from ansible.modules.network.f5.bigip_sys_global import ModuleParameters
from ansible.modules.network.f5.bigip_sys_global import ModuleManager
from ansible.modules.network.f5.bigip_sys_global import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -71,7 +73,7 @@ class TestParameters(unittest.TestCase):
quiet_boot='yes',
security_banner='yes',
)
p = ModuleParameters(args)
p = ModuleParameters(params=args)
assert p.banner_text == 'this is a banner'
assert p.console_timeout == 100
assert p.gui_setup == 'enabled'
@ -83,7 +85,7 @@ class TestParameters(unittest.TestCase):
def test_api_parameters(self):
args = load_fixture('load_sys_global_settings.json')
p = ApiParameters(args)
p = ApiParameters(params=args)
assert 'Welcome to the BIG-IP Configuration Utility' in p.banner_text
assert p.console_timeout == 0
assert p.gui_setup == 'disabled'
@ -94,8 +96,6 @@ class TestParameters(unittest.TestCase):
assert p.security_banner == 'enabled'
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
@ -113,14 +113,13 @@ class TestManager(unittest.TestCase):
# Configure the parameters that would be returned by querying the
# remote device
current = ApiParameters(load_fixture('load_sys_global_settings.json'))
current = ApiParameters(params=load_fixture('load_sys_global_settings.json'))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
mm = ModuleManager(client)
mm = ModuleManager(module=module)
# Override methods to force specific logic in the module to happen
mm.exists = Mock(return_value=False)

20
test/units/modules/network/f5/test_bigip_traffic_group.py
View file

@ -18,21 +18,22 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.f5_utils import F5ModuleError
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigip_traffic_group import Parameters
from library.bigip_traffic_group import ModuleManager
from library.bigip_traffic_group import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
from ansible.modules.network.f5.bigip_traffic_group import Parameters
from ansible.modules.network.f5.bigip_traffic_group import ModuleManager
from ansible.modules.network.f5.bigip_traffic_group import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -65,12 +66,10 @@ class TestParameters(unittest.TestCase):
name='foo'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.name == 'foo'
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
@ -84,13 +83,12 @@ class TestManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)

107
test/units/modules/network/f5/test_bigip_ucs.py
View file

@ -18,8 +18,7 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.f5_utils import F5ModuleError
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigip_ucs import Parameters
@ -27,7 +26,8 @@ try:
from library.bigip_ucs import ArgumentSpec
from library.bigip_ucs import V1Manager
from library.bigip_ucs import V2Manager
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
@ -36,7 +36,8 @@ except ImportError:
from ansible.modules.network.f5.bigip_ucs import ArgumentSpec
from ansible.modules.network.f5.bigip_ucs import V1Manager
from ansible.modules.network.f5.bigip_ucs import V2Manager
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -76,7 +77,7 @@ class TestParameters(unittest.TestCase):
state='installed'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.ucs == '/root/bigip.localhost.localdomain.ucs'
assert p.force is True
assert p.include_chassis_level_config is True
@ -98,7 +99,7 @@ class TestParameters(unittest.TestCase):
reset_trust=False
)
p = Parameters(args)
p = Parameters(params=args)
assert p.ucs == '/root/bigip.localhost.localdomain.ucs'
assert p.include_chassis_level_config is False
assert p.no_license is False
@ -107,8 +108,6 @@ class TestParameters(unittest.TestCase):
assert p.install_command == "tmsh load sys ucs /var/local/ucs/bigip.localhost.localdomain.ucs"
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestV1Manager(unittest.TestCase):
def setUp(self):
@ -122,17 +121,16 @@ class TestV1Manager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.is_version_v1 = Mock(return_value=True)
vm = V1Manager(client)
vm = V1Manager(module=module)
vm.create_on_device = Mock(return_value=True)
vm.exists = Mock(side_effect=[False, True])
@ -149,17 +147,16 @@ class TestV1Manager(unittest.TestCase):
state='present'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.is_version_v1 = Mock(return_value=True)
vm = V1Manager(client)
vm = V1Manager(module=module)
vm.create_on_device = Mock(return_value=True)
vm.exists = Mock(side_effect=[False, True])
@ -176,17 +173,16 @@ class TestV1Manager(unittest.TestCase):
state='installed'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.is_version_v1 = Mock(return_value=True)
vm = V1Manager(client)
vm = V1Manager(module=module)
vm.create_on_device = Mock(return_value=True)
vm.exists = Mock(return_value=True)
vm.install_on_device = Mock(return_value=True)
@ -204,17 +200,16 @@ class TestV1Manager(unittest.TestCase):
state='absent'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.is_version_v1 = Mock(return_value=True)
vm = V1Manager(client)
vm = V1Manager(module=module)
vm.remove_from_device = Mock(return_value=True)
vm.exists = Mock(side_effect=[True, False])
@ -231,17 +226,16 @@ class TestV1Manager(unittest.TestCase):
state='absent'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.is_version_v1 = Mock(return_value=True)
vm = V1Manager(client)
vm = V1Manager(module=module)
vm.remove_from_device = Mock(return_value=True)
vm.exists = Mock(side_effect=[True, True])
@ -250,8 +244,6 @@ class TestV1Manager(unittest.TestCase):
assert 'Failed to delete' in str(ex.value)
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestV2Manager(unittest.TestCase):
def setUp(self):
@ -265,17 +257,16 @@ class TestV2Manager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.is_version_v1 = Mock(return_value=False)
vm = V2Manager(client)
vm = V2Manager(module=module)
vm.create_on_device = Mock(return_value=True)
vm.exists = Mock(side_effect=[False, True])
@ -292,17 +283,16 @@ class TestV2Manager(unittest.TestCase):
state='present'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.is_version_v1 = Mock(return_value=False)
vm = V2Manager(client)
vm = V2Manager(module=module)
vm.create_on_device = Mock(return_value=True)
vm.exists = Mock(side_effect=[False, True])
@ -319,17 +309,16 @@ class TestV2Manager(unittest.TestCase):
state='installed'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.is_version_v1 = Mock(return_value=False)
vm = V2Manager(client)
vm = V2Manager(module=module)
vm.create_on_device = Mock(return_value=True)
vm.exists = Mock(return_value=True)
vm.install_on_device = Mock(return_value=True)
@ -347,17 +336,16 @@ class TestV2Manager(unittest.TestCase):
state='absent'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.is_version_v1 = Mock(return_value=False)
vm = V1Manager(client)
vm = V1Manager(module=module)
vm.remove_from_device = Mock(return_value=True)
vm.exists = Mock(side_effect=[True, False])
@ -374,17 +362,16 @@ class TestV2Manager(unittest.TestCase):
state='absent'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.is_version_v1 = Mock(return_value=False)
vm = V1Manager(client)
vm = V1Manager(module=module)
vm.remove_from_device = Mock(return_value=True)
vm.exists = Mock(side_effect=[True, True])

407
test/units/modules/network/f5/test_bigip_user.py
View file

@ -18,8 +18,7 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.f5_utils import F5ModuleError
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigip_user import Parameters
@ -27,7 +26,8 @@ try:
from library.bigip_user import ArgumentSpec
from library.bigip_user import UnparitionedManager
from library.bigip_user import PartitionedManager
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
@ -36,7 +36,8 @@ except ImportError:
from ansible.modules.network.f5.bigip_user import ArgumentSpec
from ansible.modules.network.f5.bigip_user import UnparitionedManager
from ansible.modules.network.f5.bigip_user import PartitionedManager
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -74,7 +75,7 @@ class TestParameters(unittest.TestCase):
update_password='always'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.username_credential == 'someuser'
assert p.password_credential == 'testpass'
assert p.full_name == 'Fake Person'
@ -91,7 +92,7 @@ class TestParameters(unittest.TestCase):
shell='none'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.name == 'someuser'
assert p.password == 'testpass'
assert p.full_name == 'Fake Person'
@ -99,8 +100,6 @@ class TestParameters(unittest.TestCase):
assert p.shell == 'none'
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
@ -118,21 +117,21 @@ class TestManager(unittest.TestCase):
update_password='on_create'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=False)
pm = PartitionedManager(client)
pm = PartitionedManager(module=module, params=module.params)
pm.create_on_device = Mock(return_value=True)
pm.exists = Mock(return_value=False)
results = pm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=False)
mm.get_manager = Mock(return_value=pm)
results = mm.exec_module()
assert results['changed'] is True
assert results['partition_access'] == access
@ -147,21 +146,21 @@ class TestManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=False)
pm = PartitionedManager(client)
pm = PartitionedManager(module=module, params=module.params)
pm.create_on_device = Mock(return_value=True)
pm.exists = Mock(return_value=False)
results = pm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=False)
mm.get_manager = Mock(return_value=pm)
results = mm.exec_module()
assert results['changed'] is True
assert results['partition_access'] == access
@ -177,26 +176,26 @@ class TestManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=False)
pm = PartitionedManager(client)
pm = PartitionedManager(module=module, params=module.params)
pm.create_on_device = Mock(return_value=True)
pm.exists = Mock(return_value=False)
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=False)
mm.get_manager = Mock(return_value=pm)
msg = "The 'update_password' option " \
"needs to be set to 'on_create' when creating " \
"a resource with a password."
with pytest.raises(F5ModuleError) as ex:
pm.exec_module()
mm.exec_module()
assert str(ex.value) == msg
def test_create_user_partition_access_raises(self, *args):
@ -207,25 +206,25 @@ class TestManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=False)
pm = PartitionedManager(client)
pm = PartitionedManager(module=module, params=module.params)
pm.create_on_device = Mock(return_value=True)
pm.exists = Mock(return_value=False)
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=False)
mm.get_manager = Mock(return_value=pm)
msg = "The 'partition_access' option " \
"is required when creating a resource."
with pytest.raises(F5ModuleError) as ex:
pm.exec_module()
mm.exec_module()
assert str(ex.value) == msg
def test_create_user_shell_bash(self, *args):
@ -241,21 +240,21 @@ class TestManager(unittest.TestCase):
shell='bash'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=False)
pm = PartitionedManager(client)
pm = PartitionedManager(module=module, params=module.params)
pm.create_on_device = Mock(return_value=True)
pm.exists = Mock(return_value=False)
results = pm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=False)
mm.get_manager = Mock(return_value=pm)
results = mm.exec_module()
assert results['changed'] is True
assert results['partition_access'] == access
@ -273,25 +272,25 @@ class TestManager(unittest.TestCase):
shell='bash'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=False)
pm = PartitionedManager(client)
pm = PartitionedManager(module=module, params=module.params)
pm.create_on_device = Mock(return_value=True)
pm.exists = Mock(return_value=False)
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=False)
mm.get_manager = Mock(return_value=pm)
msg = "Shell access is only available to 'admin' or " \
"'resource-admin' roles"
with pytest.raises(F5ModuleError) as ex:
pm.exec_module()
mm.exec_module()
assert str(ex.value) == msg
def test_update_user_password_no_pass(self, *args):
@ -303,26 +302,26 @@ class TestManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
# remote device
current = Parameters(load_fixture('load_auth_user_no_pass.json'))
current = Parameters(params=load_fixture('load_auth_user_no_pass.json'))
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=False)
pm = PartitionedManager(client)
pm = PartitionedManager(module=module, params=module.params)
pm.exists = Mock(return_value=True)
pm.update_on_device = Mock(return_value=True)
pm.read_current_from_device = Mock(return_value=current)
results = pm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=False)
mm.get_manager = Mock(return_value=pm)
results = mm.exec_module()
assert results['changed'] is True
@ -335,26 +334,26 @@ class TestManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
# remote device
current = Parameters(load_fixture('load_auth_user_with_pass.json'))
current = Parameters(params=load_fixture('load_auth_user_with_pass.json'))
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=False)
pm = PartitionedManager(client)
pm = PartitionedManager(module=module, params=module.params)
pm.exists = Mock(return_value=True)
pm.update_on_device = Mock(return_value=True)
pm.read_current_from_device = Mock(return_value=current)
results = pm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=False)
mm.get_manager = Mock(return_value=pm)
results = mm.exec_module()
assert results['changed'] is True
@ -367,31 +366,31 @@ class TestManager(unittest.TestCase):
shell='none'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
# remote device
current = Parameters(
dict(
params=dict(
user='admin',
shell='tmsh'
)
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=False)
pm = PartitionedManager(client)
pm = PartitionedManager(module=module, params=module.params)
pm.exists = Mock(return_value=True)
pm.update_on_device = Mock(return_value=True)
pm.read_current_from_device = Mock(return_value=current)
results = pm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=False)
mm.get_manager = Mock(return_value=pm)
results = mm.exec_module()
assert results['changed'] is True
assert results['shell'] == 'none'
@ -405,32 +404,32 @@ class TestManager(unittest.TestCase):
shell='none'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
# remote device
access = [{'name': 'Common', 'role': 'guest'}]
current = Parameters(
dict(
params=dict(
user='admin',
partition_access=access
)
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=False)
pm = PartitionedManager(client)
pm = PartitionedManager(module=module, params=module.params)
pm.exists = Mock(return_value=True)
pm.update_on_device = Mock(return_value=True)
pm.read_current_from_device = Mock(return_value=current)
results = pm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=False)
mm.get_manager = Mock(return_value=pm)
results = mm.exec_module()
assert results['changed'] is False
assert not hasattr(results, 'shell')
@ -444,17 +443,16 @@ class TestManager(unittest.TestCase):
shell='bash'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
# remote device
access = [{'name': 'all', 'role': 'admin'}]
current = Parameters(
dict(
params=dict(
user='admin',
shell='tmsh',
partition_access=access
@ -462,15 +460,16 @@ class TestManager(unittest.TestCase):
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.exists = Mock(return_value=True)
upm.update_on_device = Mock(return_value=True)
upm.read_current_from_device = Mock(return_value=current)
results = upm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
results = mm.exec_module()
assert results['changed'] is True
assert results['shell'] == 'bash'
@ -484,10 +483,9 @@ class TestManager(unittest.TestCase):
shell='bash'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
@ -497,7 +495,7 @@ class TestManager(unittest.TestCase):
{'name': 'all', 'role': 'guest'}
]
current = Parameters(
dict(
params=dict(
user='admin',
shell='tmsh',
partition_access=access
@ -505,24 +503,23 @@ class TestManager(unittest.TestCase):
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.exists = Mock(return_value=True)
upm.update_on_device = Mock(return_value=True)
upm.read_current_from_device = Mock(return_value=current)
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
msg = "Shell access is only available to 'admin' or " \
"'resource-admin' roles"
with pytest.raises(F5ModuleError) as ex:
upm.exec_module()
mm.exec_module()
assert str(ex.value) == msg
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestLegacyManager(unittest.TestCase):
def setUp(self):
@ -540,21 +537,21 @@ class TestLegacyManager(unittest.TestCase):
update_password='on_create'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.create_on_device = Mock(return_value=True)
upm.exists = Mock(return_value=False)
results = upm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
results = mm.exec_module()
assert results['changed'] is True
assert results['partition_access'] == access
@ -569,21 +566,21 @@ class TestLegacyManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.create_on_device = Mock(return_value=True)
upm.exists = Mock(return_value=False)
results = upm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
results = mm.exec_module()
assert results['changed'] is True
assert results['partition_access'] == access
@ -599,26 +596,26 @@ class TestLegacyManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.create_on_device = Mock(return_value=True)
upm.exists = Mock(return_value=False)
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
msg = "The 'update_password' option " \
"needs to be set to 'on_create' when creating " \
"a resource with a password."
with pytest.raises(F5ModuleError) as ex:
upm.exec_module()
mm.exec_module()
assert str(ex.value) == msg
def test_create_user_partition_access_raises(self, *args):
@ -629,25 +626,25 @@ class TestLegacyManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.create_on_device = Mock(return_value=True)
upm.exists = Mock(return_value=False)
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
msg = "The 'partition_access' option " \
"is required when creating a resource."
with pytest.raises(F5ModuleError) as ex:
upm.exec_module()
mm.exec_module()
assert str(ex.value) == msg
def test_create_user_shell_bash(self, *args):
@ -663,21 +660,21 @@ class TestLegacyManager(unittest.TestCase):
shell='bash'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.create_on_device = Mock(return_value=True)
upm.exists = Mock(return_value=False)
results = upm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
results = mm.exec_module()
assert results['changed'] is True
assert results['partition_access'] == access
@ -695,25 +692,25 @@ class TestLegacyManager(unittest.TestCase):
shell='bash'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.create_on_device = Mock(return_value=True)
upm.exists = Mock(return_value=False)
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
msg = "Shell access is only available to 'admin' or " \
"'resource-admin' roles"
with pytest.raises(F5ModuleError) as ex:
upm.exec_module()
mm.exec_module()
assert str(ex.value) == msg
def test_update_user_password(self, *args):
@ -725,32 +722,32 @@ class TestLegacyManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
# remote device
access = [{'name': 'Common', 'role': 'guest'}]
current = Parameters(
dict(
params=dict(
shell='tmsh',
partition_access=access
)
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.exists = Mock(return_value=True)
upm.update_on_device = Mock(return_value=True)
upm.read_current_from_device = Mock(return_value=current)
results = upm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
results = mm.exec_module()
assert results['changed'] is True
@ -763,31 +760,31 @@ class TestLegacyManager(unittest.TestCase):
shell='none'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
# remote device
current = Parameters(
dict(
params=dict(
user='admin',
shell='tmsh'
)
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.exists = Mock(return_value=True)
upm.update_on_device = Mock(return_value=True)
upm.read_current_from_device = Mock(return_value=current)
results = upm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
results = mm.exec_module()
assert results['changed'] is True
assert results['shell'] == 'none'
@ -801,32 +798,32 @@ class TestLegacyManager(unittest.TestCase):
shell='none'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
# remote device
access = [{'name': 'Common', 'role': 'guest'}]
current = Parameters(
dict(
params=dict(
user='admin',
partition_access=access
)
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.exists = Mock(return_value=True)
upm.update_on_device = Mock(return_value=True)
upm.read_current_from_device = Mock(return_value=current)
results = upm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
results = mm.exec_module()
assert results['changed'] is False
assert not hasattr(results, 'shell')
@ -840,17 +837,16 @@ class TestLegacyManager(unittest.TestCase):
shell='bash'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
# remote device
access = [{'name': 'all', 'role': 'admin'}]
current = Parameters(
dict(
params=dict(
user='admin',
shell='tmsh',
partition_access=access
@ -858,15 +854,16 @@ class TestLegacyManager(unittest.TestCase):
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.exists = Mock(return_value=True)
upm.update_on_device = Mock(return_value=True)
upm.read_current_from_device = Mock(return_value=current)
results = upm.exec_module()
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
results = mm.exec_module()
assert results['changed'] is True
assert results['shell'] == 'bash'
@ -880,10 +877,9 @@ class TestLegacyManager(unittest.TestCase):
shell='bash'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Configure the parameters that would be returned by querying the
@ -893,7 +889,7 @@ class TestLegacyManager(unittest.TestCase):
{'name': 'all', 'role': 'guest'}
]
current = Parameters(
dict(
params=dict(
user='admin',
shell='tmsh',
partition_access=access
@ -901,17 +897,18 @@ class TestLegacyManager(unittest.TestCase):
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm.is_version_less_than_13 = Mock(return_value=True)
upm = UnparitionedManager(client)
upm = UnparitionedManager(module=module, params=module.params)
upm.exists = Mock(return_value=True)
upm.update_on_device = Mock(return_value=True)
upm.read_current_from_device = Mock(return_value=current)
mm = ModuleManager(module=module)
mm.is_version_less_than_13 = Mock(return_value=True)
mm.get_manager = Mock(return_value=upm)
msg = "Shell access is only available to 'admin' or " \
"'resource-admin' roles"
with pytest.raises(F5ModuleError) as ex:
upm.exec_module()
mm.exec_module()
assert str(ex.value) == msg

31
test/units/modules/network/f5/test_bigip_vcmp_guest.py
View file

@ -18,20 +18,22 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigip_vcmp_guest import Parameters
from library.bigip_vcmp_guest import ModuleManager
from library.bigip_vcmp_guest import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
from ansible.modules.network.f5.bigip_vcmp_guest import Parameters
from ansible.modules.network.f5.bigip_vcmp_guest import ModuleManager
from ansible.modules.network.f5.bigip_vcmp_guest import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -70,7 +72,7 @@ class TestParameters(unittest.TestCase):
]
)
p = Parameters(args)
p = Parameters(params=args)
assert p.initial_image == 'BIGIP-12.1.0.1.0.1447-HF1.iso'
assert p.mgmt_network == 'bridged'
@ -80,7 +82,7 @@ class TestParameters(unittest.TestCase):
mgmt_address='1.2.3.4'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.mgmt_network == 'bridged'
assert p.mgmt_address == '1.2.3.4/32'
@ -90,7 +92,7 @@ class TestParameters(unittest.TestCase):
mgmt_address='1.2.3.4/24'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.mgmt_network == 'bridged'
assert p.mgmt_address == '1.2.3.4/24'
@ -100,7 +102,7 @@ class TestParameters(unittest.TestCase):
mgmt_address='1.2.3.4/255.255.255.0'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.mgmt_network == 'bridged'
assert p.mgmt_address == '1.2.3.4/24'
@ -109,7 +111,7 @@ class TestParameters(unittest.TestCase):
mgmt_route='1.2.3.4'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.mgmt_route == '1.2.3.4'
def test_module_parameters_vcmp_software_image_facts(self):
@ -120,7 +122,7 @@ class TestParameters(unittest.TestCase):
initial_image='BIGIP-12.1.0.1.0.1447-HF1.iso/1',
)
p = Parameters(args)
p = Parameters(params=args)
assert p.initial_image == 'BIGIP-12.1.0.1.0.1447-HF1.iso/1'
def test_api_parameters(self):
@ -136,7 +138,7 @@ class TestParameters(unittest.TestCase):
]
)
p = Parameters(args)
p = Parameters(params=args)
assert p.initial_image == 'BIGIP-tmos-tier2-13.1.0.0.0.931.iso'
assert p.mgmt_route == '2.2.2.2'
assert p.mgmt_address == '1.1.1.1/24'
@ -144,8 +146,6 @@ class TestParameters(unittest.TestCase):
assert '/Common/vlan2' in p.vlans
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
self.spec = ArgumentSpec()
@ -161,14 +161,13 @@ class TestManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
mm.is_deployed = Mock(side_effect=[False, True, True, True, True])

50
test/units/modules/network/f5/test_bigip_virtual_address.py
View file

@ -17,20 +17,22 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigip_virtual_address import Parameters
from library.bigip_virtual_address import ModuleManager
from library.bigip_virtual_address import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
from ansible.modules.network.f5.bigip_virtual_address import Parameters
from ansible.modules.network.f5.bigip_virtual_address import ModuleManager
from ansible.modules.network.f5.bigip_virtual_address import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -70,7 +72,7 @@ class TestParameters(unittest.TestCase):
advertise_route='always',
use_route_advertisement='yes'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.state == 'present'
assert p.address == '1.1.1.1'
assert p.netmask == '2.2.2.2'
@ -83,7 +85,7 @@ class TestParameters(unittest.TestCase):
def test_api_parameters(self):
args = load_fixture('load_ltm_virtual_address_default.json')
p = Parameters(args)
p = Parameters(params=args)
assert p.name == '1.1.1.1'
assert p.address == '1.1.1.1'
assert p.arp_state == 'enabled'
@ -99,56 +101,56 @@ class TestParameters(unittest.TestCase):
args = dict(
advertise_route='when_all_available'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.advertise_route == 'all'
def test_module_parameters_advertise_route_any(self):
args = dict(
advertise_route='when_any_available'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.advertise_route == 'any'
def test_module_parameters_icmp_echo_disabled(self):
args = dict(
icmp_echo='disabled'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.icmp_echo == 'disabled'
def test_module_parameters_icmp_echo_selective(self):
args = dict(
icmp_echo='selective'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.icmp_echo == 'selective'
def test_module_parameters_auto_delete_disabled(self):
args = dict(
auto_delete='disabled'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.auto_delete is False
def test_module_parameters_arp_state_disabled(self):
args = dict(
arp_state='disabled'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.arp_state == 'disabled'
def test_module_parameters_use_route_advert_disabled(self):
args = dict(
use_route_advertisement='no'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.use_route_advertisement == 'disabled'
def test_module_parameters_state_present(self):
args = dict(
state='present'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.state == 'present'
assert p.enabled == 'yes'
@ -156,14 +158,14 @@ class TestParameters(unittest.TestCase):
args = dict(
state='absent'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.state == 'absent'
def test_module_parameters_state_enabled(self):
args = dict(
state='enabled'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.state == 'enabled'
assert p.enabled == 'yes'
@ -171,13 +173,11 @@ class TestParameters(unittest.TestCase):
args = dict(
state='disabled'
)
p = Parameters(args)
p = Parameters(params=args)
assert p.state == 'disabled'
assert p.enabled == 'no'
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
@ -199,12 +199,11 @@ class TestManager(unittest.TestCase):
user='admin',
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
mm = ModuleManager(client)
mm = ModuleManager(module=module)
# Override methods to force specific logic in the module to happen
mm.exists = Mock(side_effect=[False, True])
@ -222,12 +221,11 @@ class TestManager(unittest.TestCase):
user='admin',
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
mm = ModuleManager(client)
mm = ModuleManager(module=module)
# Override methods to force specific logic in the module to happen
mm.exists = Mock(side_effect=[True, False])

243
test/units/modules/network/f5/test_bigip_virtual_server.py
View file

@ -17,28 +17,24 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigip_virtual_server import VirtualAddressParameters
from library.bigip_virtual_server import VirtualServerModuleParameters
from library.bigip_virtual_server import VirtualServerApiParameters
from library.bigip_virtual_server import ModuleParameters
from library.bigip_virtual_server import ApiParameters
from library.bigip_virtual_server import ModuleManager
from library.bigip_virtual_server import VirtualServerManager
from library.bigip_virtual_server import VirtualAddressManager
from library.bigip_virtual_server import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
from ansible.modules.network.f5.bigip_virtual_server import VirtualAddressParameters
from ansible.modules.network.f5.bigip_virtual_server import VirtualServerApiParameters
from ansible.modules.network.f5.bigip_virtual_server import VirtualServerModuleParameters
from ansible.modules.network.f5.bigip_virtual_server import ApiParameters
from ansible.modules.network.f5.bigip_virtual_server import ModuleParameters
from ansible.modules.network.f5.bigip_virtual_server import ModuleManager
from ansible.modules.network.f5.bigip_virtual_server import VirtualServerManager
from ansible.modules.network.f5.bigip_virtual_server import VirtualAddressManager
from ansible.modules.network.f5.bigip_virtual_server import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -70,14 +66,14 @@ class TestParameters(unittest.TestCase):
args = dict(
destination='1.1.1.1'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '1.1.1.1'
def test_destination_mutex_2(self):
args = dict(
destination='1.1.1.1%2'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '1.1.1.1'
assert p.destination_tuple.route_domain == 2
@ -85,7 +81,7 @@ class TestParameters(unittest.TestCase):
args = dict(
destination='1.1.1.1:80'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '1.1.1.1'
assert p.destination_tuple.port == 80
@ -93,7 +89,7 @@ class TestParameters(unittest.TestCase):
args = dict(
destination='1.1.1.1%2:80'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '1.1.1.1'
assert p.destination_tuple.port == 80
assert p.destination_tuple.route_domain == 2
@ -102,14 +98,14 @@ class TestParameters(unittest.TestCase):
args = dict(
destination='/Common/1.1.1.1'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '1.1.1.1'
def test_api_destination_mutex_6(self):
args = dict(
destination='/Common/1.1.1.1%2'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '1.1.1.1'
assert p.destination_tuple.route_domain == 2
@ -117,7 +113,7 @@ class TestParameters(unittest.TestCase):
args = dict(
destination='/Common/1.1.1.1:80'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '1.1.1.1'
assert p.destination_tuple.port == 80
@ -125,7 +121,7 @@ class TestParameters(unittest.TestCase):
args = dict(
destination='/Common/1.1.1.1%2:80'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '1.1.1.1'
assert p.destination_tuple.port == 80
assert p.destination_tuple.route_domain == 2
@ -134,14 +130,14 @@ class TestParameters(unittest.TestCase):
args = dict(
destination='2700:bc00:1f10:101::6'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '2700:bc00:1f10:101::6'
def test_destination_mutex_10(self):
args = dict(
destination='2700:bc00:1f10:101::6%2'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '2700:bc00:1f10:101::6'
assert p.destination_tuple.route_domain == 2
@ -149,7 +145,7 @@ class TestParameters(unittest.TestCase):
args = dict(
destination='2700:bc00:1f10:101::6.80'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '2700:bc00:1f10:101::6'
assert p.destination_tuple.port == 80
@ -157,26 +153,11 @@ class TestParameters(unittest.TestCase):
args = dict(
destination='2700:bc00:1f10:101::6%2.80'
)
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.destination_tuple.ip == '2700:bc00:1f10:101::6'
assert p.destination_tuple.port == 80
assert p.destination_tuple.route_domain == 2
#
# def test_destination_mutex_6(self):
# args = dict(
# destination='/Common/2700:bc00:1f10:101::6'
# )
# p = VirtualServerParameters(args)
# assert p.destination_tuple.ip == '2700:bc00:1f10:101::6'
#
# def test_destination_mutex_5(self):
# args = dict(
# destination='/Common/2700:bc00:1f10:101::6'
# )
# p = VirtualServerParameters(args)
# assert p.destination_tuple.ip == '2700:bc00:1f10:101::6'
def test_module_no_partition_prefix_parameters(self):
args = dict(
server='localhost',
@ -198,7 +179,7 @@ class TestParameters(unittest.TestCase):
],
enabled_vlans=['vlan2']
)
p = VirtualServerModuleParameters(args)
p = ModuleParameters(params=args)
assert p.name == 'my-virtual-server'
assert p.partition == 'Common'
assert p.port == 443
@ -235,7 +216,7 @@ class TestParameters(unittest.TestCase):
],
enabled_vlans=['/Common/vlan2']
)
p = VirtualServerModuleParameters(args)
p = ModuleParameters(params=args)
assert p.name == 'my-virtual-server'
assert p.partition == 'Common'
assert p.port == 443
@ -342,7 +323,7 @@ class TestParameters(unittest.TestCase):
]
}
}
p = VirtualServerApiParameters(args)
p = ApiParameters(params=args)
assert p.name == 'my-virtual-server'
assert p.partition == 'Common'
assert p.port == 443
@ -358,8 +339,6 @@ class TestParameters(unittest.TestCase):
assert '/Common/net1' in p.vlans
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
@ -388,19 +367,15 @@ class TestManager(unittest.TestCase):
validate_certs="no"
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
vsm = VirtualServerManager(client)
vsm.exists = Mock(return_value=False)
vsm.create_on_device = Mock(return_value=True)
mm = ModuleManager(client)
mm.get_manager = Mock(return_value=vsm)
mm = ModuleManager(module=module)
mm.exists = Mock(return_value=False)
mm.create_on_device = Mock(return_value=True)
results = mm.exec_module()
assert results['changed'] is True
@ -423,18 +398,14 @@ class TestManager(unittest.TestCase):
validate_certs="no"
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
vsm = VirtualServerManager(client)
vsm.exists = Mock(return_value=False)
mm = ModuleManager(client)
mm.get_manager = Mock(return_value=vsm)
mm = ModuleManager(module=module)
mm.exists = Mock(return_value=False)
results = mm.exec_module()
@ -460,26 +431,22 @@ class TestManager(unittest.TestCase):
# Configure the parameters that would be returned by querying the
# remote device
current = VirtualServerApiParameters(
current = ApiParameters(
dict(
agent_status_traps='disabled'
)
)
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
vsm = VirtualServerManager(client)
vsm.exists = Mock(return_value=False)
vsm.update_on_device = Mock(return_value=True)
vsm.read_current_from_device = Mock(return_value=current)
mm = ModuleManager(client)
mm.get_manager = Mock(return_value=vsm)
mm = ModuleManager(module=module)
mm.exists = Mock(return_value=False)
mm.update_on_device = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
results = mm.exec_module()
assert results['changed'] is False
@ -498,22 +465,18 @@ class TestManager(unittest.TestCase):
# Configure the parameters that would be returned by querying the
# remote device
current = VirtualServerApiParameters(load_fixture('load_ltm_virtual_1.json'))
current = ApiParameters(params=load_fixture('load_ltm_virtual_1.json'))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
vsm = VirtualServerManager(client)
vsm.exists = Mock(return_value=True)
vsm.read_current_from_device = Mock(return_value=current)
vsm.update_on_device = Mock(return_value=True)
mm = ModuleManager(client)
mm.get_manager = Mock(return_value=vsm)
mm = ModuleManager(module=module)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
results = mm.exec_module()
assert results['changed'] is True
@ -532,21 +495,17 @@ class TestManager(unittest.TestCase):
# Configure the parameters that would be returned by querying the
# remote device
current = VirtualServerApiParameters(load_fixture('load_ltm_virtual_1.json'))
current = ApiParameters(params=load_fixture('load_ltm_virtual_1.json'))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
vsm = VirtualServerManager(client)
vsm.exists = Mock(return_value=True)
vsm.read_current_from_device = Mock(return_value=current)
mm = ModuleManager(client)
mm.get_manager = Mock(return_value=vsm)
mm = ModuleManager(module=module)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
results = mm.exec_module()
assert results['changed'] is False
@ -567,21 +526,17 @@ class TestManager(unittest.TestCase):
# Configure the parameters that would be returned by querying the
# remote device
current = VirtualServerApiParameters(load_fixture('load_ltm_virtual_2.json'))
current = ApiParameters(params=load_fixture('load_ltm_virtual_2.json'))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
vsm = VirtualServerManager(client)
vsm.exists = Mock(return_value=True)
vsm.read_current_from_device = Mock(return_value=current)
mm = ModuleManager(client)
mm.get_manager = Mock(return_value=vsm)
mm = ModuleManager(module=module)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
results = mm.exec_module()
@ -603,22 +558,18 @@ class TestManager(unittest.TestCase):
# Configure the parameters that would be returned by querying the
# remote device
current = VirtualServerApiParameters(load_fixture('load_ltm_virtual_2.json'))
current = ApiParameters(params=load_fixture('load_ltm_virtual_2.json'))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
vsm = VirtualServerManager(client)
vsm.exists = Mock(return_value=True)
vsm.read_current_from_device = Mock(return_value=current)
vsm.update_on_device = Mock(return_value=True)
mm = ModuleManager(client)
mm.get_manager = Mock(return_value=vsm)
mm = ModuleManager(module=module)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
results = mm.exec_module()
@ -674,22 +625,18 @@ class TestManager(unittest.TestCase):
# Configure the parameters that would be returned by querying the
# remote device
current = VirtualServerApiParameters(load_fixture('load_ltm_virtual_3.json'))
current = ApiParameters(params=load_fixture('load_ltm_virtual_3.json'))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
vsm = VirtualServerManager(client)
vsm.exists = Mock(return_value=True)
vsm.read_current_from_device = Mock(return_value=current)
vsm.update_on_device = Mock(return_value=True)
mm = ModuleManager(client)
mm.get_manager = Mock(return_value=vsm)
mm = ModuleManager(module=module)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
results = mm.exec_module()
@ -727,47 +674,3 @@ class TestManager(unittest.TestCase):
assert 'context' in results['profiles'][1]
assert results['profiles'][1]['name'] == 'clientssl'
assert results['profiles'][1]['context'] == 'clientside'
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestDeprecatedAnsible24Manager(unittest.TestCase):
def setUp(self):
self.spec = ArgumentSpec()
def test_modify_port_idempotent(self, *args):
set_module_args(dict(
destination="10.10.10.10",
name="my-virtual-server",
route_advertisement_state="enabled",
partition="Common",
password="secret",
port="443",
server="localhost",
state="present",
user="admin",
validate_certs="no"
))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
vsm_current = VirtualServerApiParameters(load_fixture('load_ltm_virtual_1.json'))
vam_current = VirtualAddressParameters(load_fixture('load_ltm_virtual_1_address.json'))
vsm = VirtualServerManager(client)
vsm.exists = Mock(return_value=True)
vsm.read_current_from_device = Mock(return_value=vsm_current)
vam = VirtualAddressManager(client)
vam.exists = Mock(return_value=True)
vam.read_current_from_device = Mock(return_value=vam_current)
mm = ModuleManager(client)
mm.get_manager = Mock(side_effect=[vsm, vam])
results = mm.exec_module()
assert results['changed'] is False

316
test/units/modules/network/f5/test_bigip_vlan.py
View file

@ -8,7 +8,6 @@ __metaclass__ = type
import os
import json
import pytest
import sys
from nose.plugins.skip import SkipTest
@ -18,21 +17,24 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.f5_utils import F5ModuleError
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigip_vlan import Parameters
from library.bigip_vlan import ApiParameters
from library.bigip_vlan import ModuleParameters
from library.bigip_vlan import ModuleManager
from library.bigip_vlan import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
from ansible.modules.network.f5.bigip_vlan import Parameters
from ansible.modules.network.f5.bigip_vlan import ApiParameters
from ansible.modules.network.f5.bigip_vlan import ModuleParameters
from ansible.modules.network.f5.bigip_vlan import ModuleManager
from ansible.modules.network.f5.bigip_vlan import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -65,13 +67,6 @@ class BigIpObj(object):
class TestParameters(unittest.TestCase):
def setUp(self):
self.loaded_ifcs = []
ifcs_json = load_fixture('load_net_interfaces.json')
for item in ifcs_json:
self.loaded_ifcs.append(BigIpObj(**item))
def test_module_parameters(self):
args = dict(
name='somevlan',
@ -79,9 +74,7 @@ class TestParameters(unittest.TestCase):
description='fakevlan',
untagged_interfaces=['1.1'],
)
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
p = Parameters(args)
p = ModuleParameters(params=args)
assert p.name == 'somevlan'
assert p.tag == 213
@ -92,38 +85,20 @@ class TestParameters(unittest.TestCase):
args = dict(
name='somevlan',
description='fakevlan',
tag=213,
tagged_interfaces=['1.2']
tag=213
)
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
p = Parameters(args)
p = ApiParameters(params=args)
assert p.name == 'somevlan'
assert p.tag == 213
assert p.interfaces == [{'tagged': True, 'name': '1.2'}]
assert p.description == 'fakevlan'
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
self.spec = ArgumentSpec()
self.loaded_ifcs = []
self.loaded_vlan_ifc_tag = []
self.loaded_vlan_ifc_untag = []
ifcs_tag = load_fixture('load_vlan_tagged_ifcs.json')
ifcs_untag = load_fixture('load_vlan_untag_ifcs.json')
ifcs_json = load_fixture('load_net_interfaces.json')
for item in ifcs_json:
self.loaded_ifcs.append(BigIpObj(**item))
for item in ifcs_tag:
self.loaded_vlan_ifc_tag.append(BigIpObj(**item))
for item in ifcs_untag:
self.loaded_vlan_ifc_untag.append(BigIpObj(**item))
def test_create_vlan(self, *args):
set_module_args(dict(
@ -135,24 +110,19 @@ class TestManager(unittest.TestCase):
partition='Common'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
mm = ModuleManager(module=module)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
mm = ModuleManager(client)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
results = mm.exec_module()
results = mm.exec_module()
assert results['changed'] is True
assert results['name'] == 'somevlan'
assert results['description'] == 'fakevlan'
def test_create_vlan_tagged_interface(self, *args):
@ -166,26 +136,21 @@ class TestManager(unittest.TestCase):
partition='Common'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
mm = ModuleManager(module=module)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
mm = ModuleManager(client)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
results = mm.exec_module()
results = mm.exec_module()
assert results['changed'] is True
assert results['interfaces'] == [{'tagged': True, 'name': '2.1'}]
assert results['tagged_interfaces'] == ['2.1']
assert results['tag'] == 213
assert results['name'] == 'somevlan'
def test_create_vlan_untagged_interface(self, *args):
set_module_args(dict(
@ -197,25 +162,20 @@ class TestManager(unittest.TestCase):
partition='Common'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
mm = ModuleManager(module=module)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
mm = ModuleManager(client)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
results = mm.exec_module()
results = mm.exec_module()
assert results['changed'] is True
assert results['interfaces'] == [{'untagged': True, 'name': '2.1'}]
assert results['name'] == 'somevlan'
assert results['untagged_interfaces'] == ['2.1']
def test_create_vlan_tagged_interfaces(self, *args):
set_module_args(dict(
@ -228,27 +188,21 @@ class TestManager(unittest.TestCase):
partition='Common'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
mm = ModuleManager(module=module)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
mm = ModuleManager(client)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
results = mm.exec_module()
results = mm.exec_module()
assert results['changed'] is True
assert results['interfaces'] == [{'tagged': True, 'name': '2.1'},
{'tagged': True, 'name': '1.1'}]
assert results['tagged_interfaces'] == ['1.1', '2.1']
assert results['tag'] == 213
assert results['name'] == 'somevlan'
def test_create_vlan_untagged_interfaces(self, *args):
set_module_args(dict(
@ -260,26 +214,20 @@ class TestManager(unittest.TestCase):
partition='Common',
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
mm = ModuleManager(module=module)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
mm = ModuleManager(client)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
results = mm.exec_module()
results = mm.exec_module()
assert results['changed'] is True
assert results['interfaces'] == [{'untagged': True, 'name': '2.1'},
{'untagged': True, 'name': '1.1'}]
assert results['name'] == 'somevlan'
assert results['untagged_interfaces'] == ['1.1', '2.1']
def test_update_vlan_untag_interface(self, *args):
set_module_args(dict(
@ -291,32 +239,26 @@ class TestManager(unittest.TestCase):
partition='Common',
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
ifcs = self.loaded_vlan_ifc_untag
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
mm = ModuleManager(client)
mm = ModuleManager(module=module)
current = (
Parameters(
load_fixture('load_vlan.json')
),
ifcs
)
current = ApiParameters(params=load_fixture('load_vlan.json'))
interfaces = load_fixture('load_vlan_interfaces.json')
current.update({'interfaces': interfaces})
mm.update_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
results = mm.exec_module()
results = mm.exec_module()
assert results['changed'] is True
assert results['interfaces'] == [{'untagged': True, 'name': '2.1'}]
assert results['untagged_interfaces'] == ['2.1']
def test_update_vlan_tag_interface(self, *args):
set_module_args(dict(
@ -328,32 +270,24 @@ class TestManager(unittest.TestCase):
partition='Common',
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
ifcs = self.loaded_vlan_ifc_tag
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
mm = ModuleManager(client)
mm = ModuleManager(module=module)
current = (
Parameters(
load_fixture('load_vlan.json')
),
ifcs
)
current = ApiParameters(params=load_fixture('load_vlan.json'))
mm.update_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
results = mm.exec_module()
results = mm.exec_module()
assert results['changed'] is True
assert results['interfaces'] == [{'tagged': True, 'name': '2.1'}]
assert results['tagged_interfaces'] == ['2.1']
def test_update_vlan_description(self, *args):
set_module_args(dict(
@ -365,117 +299,21 @@ class TestManager(unittest.TestCase):
partition='Common',
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
ifcs = self.loaded_vlan_ifc_tag
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
mm = ModuleManager(client)
mm = ModuleManager(module=module)
current = (
Parameters(
load_fixture('update_vlan_description.json')
),
ifcs
)
current = ApiParameters(params=load_fixture('update_vlan_description.json'))
mm.update_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
results = mm.exec_module()
results = mm.exec_module()
assert results['changed'] is True
assert results['description'] == 'changed_that'
def test_untagged_ifc_raises(self, *args):
set_module_args(dict(
name='somevlan',
untagged_interface=['10.2'],
server='localhost',
password='password',
user='admin',
partition='Common'
))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
msg = 'The specified interface "10.2" was not found'
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
mm = ModuleManager(client)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
with pytest.raises(F5ModuleError) as err:
mm.exec_module()
assert str(err.value) == msg
def test_tagged_ifc_raises(self, *args):
set_module_args(dict(
name='somevlan',
tagged_interface=['10.2'],
tag=213,
server='localhost',
password='password',
user='admin',
partition='Common'
))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
msg = 'The specified interface "10.2" was not found'
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = self.loaded_ifcs
mm = ModuleManager(client)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
with pytest.raises(F5ModuleError) as err:
mm.exec_module()
assert str(err.value) == msg
def test_parse_return_ifcs_raises(self, *args):
set_module_args(dict(
name='somevlan',
untagged_interface=['1.2'],
server='localhost',
password='password',
user='admin',
partition='Common'
))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
msg = 'No interfaces were found'
# Override methods to force specific logic in the module to happen
with patch.object(Parameters, '_get_interfaces_from_device') as obj:
obj.return_value = []
mm = ModuleManager(client)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
with pytest.raises(F5ModuleError) as err:
mm.exec_module()
assert str(err.value) == msg

24
test/units/modules/network/f5/test_bigip_wait.py
View file

@ -18,23 +18,22 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.f5_utils import F5ModuleError
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigip_wait import Parameters
from library.bigip_wait import ModuleManager
from library.bigip_wait import ArgumentSpec
from library.bigip_wait import AnsibleF5ClientStub
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
from ansible.modules.network.f5.bigip_wait import Parameters
from ansible.modules.network.f5.bigip_wait import ModuleManager
from ansible.modules.network.f5.bigip_wait import ArgumentSpec
from ansible.modules.network.f5.bigip_wait import AnsibleF5ClientStub
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -70,7 +69,7 @@ class TestParameters(unittest.TestCase):
msg='We timed out during waiting for BIG-IP :-('
)
p = Parameters(args)
p = Parameters(params=args)
assert p.delay == 3
assert p.timeout == 500
assert p.sleep == 10
@ -84,15 +83,13 @@ class TestParameters(unittest.TestCase):
msg='We timed out during waiting for BIG-IP :-('
)
p = Parameters(args)
p = Parameters(params=args)
assert p.delay == 3
assert p.timeout == 500
assert p.sleep == 10
assert p.msg == 'We timed out during waiting for BIG-IP :-('
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
self.spec = ArgumentSpec()
@ -104,14 +101,13 @@ class TestManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5ClientStub(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm._connect_to_device = Mock(return_value=True)
mm._device_is_rebooting = Mock(return_value=False)
mm._is_mprov_running_on_device = Mock(return_value=False)

22
test/units/modules/network/f5/test_bigiq_regkey_license.py
View file

@ -18,15 +18,15 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.f5_utils import F5ModuleError
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigiq_regkey_license import ModuleParameters
from library.bigiq_regkey_license import ApiParameters
from library.bigiq_regkey_license import ModuleManager
from library.bigiq_regkey_license import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
@ -34,7 +34,8 @@ except ImportError:
from ansible.modules.network.f5.bigiq_regkey_license import ApiParameters
from ansible.modules.network.f5.bigiq_regkey_license import ModuleManager
from ansible.modules.network.f5.bigiq_regkey_license import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -70,7 +71,7 @@ class TestParameters(unittest.TestCase):
description='this is a description'
)
p = ModuleParameters(args)
p = ModuleParameters(params=args)
assert p.regkey_pool == 'foo'
assert p.license_key == 'XXXX-XXXX-XXXX-XXXX-XXXX'
assert p.accept_eula is True
@ -79,12 +80,10 @@ class TestParameters(unittest.TestCase):
def test_api_parameters(self):
args = load_fixture('load_regkey_license_key.json')
p = ApiParameters(args)
p = ApiParameters(params=args)
assert p.description == 'foo bar baz'
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
@ -101,12 +100,11 @@ class TestManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
mm = ModuleManager(client)
mm = ModuleManager(module=module)
# Override methods to force specific logic in the module to happen
mm.exists = Mock(side_effect=[False, True])

20
test/units/modules/network/f5/test_bigiq_regkey_pool.py
View file

@ -18,14 +18,15 @@ if sys.version_info < (2, 7):
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.f5_utils import F5ModuleError
from ansible.module_utils.basic import AnsibleModule
try:
from library.bigiq_regkey_pool import ModuleParameters
from library.bigiq_regkey_pool import ApiParameters
from library.bigiq_regkey_pool import ModuleManager
from library.bigiq_regkey_pool import ArgumentSpec
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
@ -33,6 +34,8 @@ except ImportError:
from ansible.modules.network.f5.bigiq_regkey_pool import ApiParameters
from ansible.modules.network.f5.bigiq_regkey_pool import ModuleManager
from ansible.modules.network.f5.bigiq_regkey_pool import ArgumentSpec
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
@ -65,18 +68,16 @@ class TestParameters(unittest.TestCase):
description='this is a description'
)
p = ModuleParameters(args)
p = ModuleParameters(params=args)
assert p.description == 'this is a description'
def test_api_parameters(self):
args = load_fixture('load_regkey_license_pool.json')
p = ApiParameters(args)
p = ApiParameters(params=args)
assert p.description == 'this is a description'
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
@ -91,14 +92,13 @@ class TestManager(unittest.TestCase):
user='admin'
))
client = AnsibleF5Client(
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
supports_check_mode=self.spec.supports_check_mode
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm = ModuleManager(module=module)
mm.exists = Mock(return_value=False)
mm.create_on_device = Mock(return_value=True)