Merge pull request #568 from pjbreaux/bugfix.test_policy_11_5_4

Fixing functional test issues in test/functional/tm/ltm/test_policy.py

Author: zancas

conftest.py

@@ -15,6 +15,7 @@
 
 from f5.bigip import BigIP
 from f5.bigip import ManagementRoot
+from f5.utils.testutils.registrytools import register_device
 import mock
 import pytest
 import requests
@@ -53,41 +54,41 @@ def json(self):
     monkeypatch.setattr('f5.bigip.iControlRESTSession', fakesessionclass)
 
 
-@pytest.fixture
+@pytest.fixture(scope='session')
 def opt_bigip(request):
     return request.config.getoption("--bigip")
 
 
-@pytest.fixture
+@pytest.fixture(scope='session')
 def opt_username(request):
     return request.config.getoption("--username")
 
 
-@pytest.fixture
+@pytest.fixture(scope='session')
 def opt_password(request):
     return request.config.getoption("--password")
 
 
-@pytest.fixture
+@pytest.fixture(scope='session')
 def opt_port(request):
     return request.config.getoption("--port")
 
 
-@pytest.fixture
+@pytest.fixture(scope='session')
 def bigip(opt_bigip, opt_username, opt_password, opt_port, scope="module"):
     '''bigip fixture'''
     b = BigIP(opt_bigip, opt_username, opt_password, port=opt_port)
     return b
 
 
-@pytest.fixture
+@pytest.fixture(scope='module')
 def mgmt_root(opt_bigip, opt_username, opt_password, opt_port, scope="module"):
     '''bigip fixture'''
     m = ManagementRoot(opt_bigip, opt_username, opt_password, port=opt_port)
     return m
 
 
-@pytest.fixture
+@pytest.fixture(scope='session')
 def opt_release(request):
     return request.config.getoption("--release")
 
@@ -153,3 +154,22 @@ def deleter():
         request.addfinalizer(deleter)
         return pool_registry, members_registry
     return _setup_boilerplate
+
+
+@pytest.fixture(scope='module')
+def setup_device_snapshot(request, mgmt_root):
+    '''Snapshot the device to manage objects created by tests.
+
+    Snapshot the device before a test runs and after, then remove objects
+    that persist after suite runs.
+    '''
+
+    before_snapshot = register_device(mgmt_root)
+
+    def teardown():
+        after_snapshot = register_device(mgmt_root)
+        diff = set(after_snapshot) - set(before_snapshot)
+        for item in diff:
+            after_snapshot[item].delete()
+    request.addfinalizer(teardown)
+    return before_snapshot

f5/bigip/resource.py

@@ -568,6 +568,30 @@ def _produce_instance(self, response):
         new_instance._activate_URI(new_instance.selfLink)
         return new_instance
 
+    def _reduce_boolean_pair(self, config_dict, key1, key2):
+        '''Ensure only one key with a boolean value is present in dict.
+
+        :param config_dict: dict -- dictionary of config or kwargs
+        :param key1: string -- first key name
+        :param key2: string -- second key name
+        :raises: BooleansToReduceHaveSameValue
+        '''
+
+        if key1 in config_dict and key2 in config_dict \
+                and config_dict[key1] == config_dict[key2]:
+            msg = 'Boolean pair, %s and %s, have same value: %s. If both ' \
+                'are given to this method, they cannot be the same, as this ' \
+                'method cannot decide which one should be True.' \
+                % (key1, key2, config_dict[key1])
+            raise BooleansToReduceHaveSameValue(msg)
+        elif key1 in config_dict and not config_dict[key1]:
+            config_dict[key2] = True
+            config_dict.pop(key1)
+        elif key2 in config_dict and not config_dict[key2]:
+            config_dict[key1] = True
+            config_dict.pop(key2)
+        return config_dict
+
 
 class OrganizingCollection(ResourceBase):
     """Base class for objects that collect resources under them.
@@ -762,30 +786,6 @@ def _activate_URI(self, selfLinkuri):
                                 'creation_uri_frag': frag,
                                 'allowed_lazy_attributes': attrs})
 
-    def _reduce_boolean_pair(self, config_dict, key1, key2):
-        '''Ensure only one key with a boolean value is present in dict.
-
-        :param config_dict: dict -- dictionary of config or kwargs
-        :param key1: string -- first key name
-        :param key2: string -- second key name
-        :raises: BooleansToReduceHaveSameValue
-        '''
-
-        if key1 in config_dict and key2 in config_dict \
-                and config_dict[key1] == config_dict[key2]:
-            msg = 'Boolean pair, %s and %s, have same value: %s. If both ' \
-                'are given to this method, they cannot be the same, as this ' \
-                'method cannot decide which one should be True.' \
-                % (key1, key2, config_dict[key1])
-            raise BooleansToReduceHaveSameValue(msg)
-        elif key1 in config_dict and not config_dict[key1]:
-            config_dict[key2] = True
-            config_dict.pop(key1)
-        elif key2 in config_dict and not config_dict[key2]:
-            config_dict[key1] = True
-            config_dict.pop(key2)
-        return config_dict
-
     def _create(self, **kwargs):
         """wrapped by `create` override that in subclasses to customize"""
         if 'uri' in self._meta_data:

f5/bigip/tm/sys/failover.py

@@ -28,11 +28,6 @@
 
 from f5.bigip.mixins import CommandExecutionMixin
 from f5.bigip.resource import UnnamedResource
-from f5.sdk_exception import F5SDKError
-
-
-class InvalidParameterValue(F5SDKError):
-    pass
 
 
 class Failover(UnnamedResource, CommandExecutionMixin):
@@ -95,14 +90,7 @@ def exec_cmd(self, command, **kwargs):
         :: raises InvalidParameterValue
         """
 
-        if 'online' in kwargs and 'offline' in kwargs:
-            if kwargs['online'] is True and kwargs['offline'] is True or \
-               kwargs['online'] is False and kwargs['offline'] is False:
-                error = 'Both parameters cannot have the same value' \
-                        'Currently they are: online={} offline={}'.format(
-                            kwargs['online'], kwargs['offline'])
-                raise InvalidParameterValue(error)
-
+        kwargs = self._reduce_boolean_pair(kwargs, 'online', 'offline')
         if 'offline' in kwargs:
             self._meta_data['exclusive_attributes'].append(
                 ('offline', 'standby'))

test/functional/tm/ltm/test_policy.py

@@ -20,25 +20,12 @@
 TESTDESCRIPTION = "TESTDESCRIPTION"
 
 
-def delete_resource(resources):
-    for resource in resources.get_collection():
-        system_policy_obj_name = ['_sys_CEC_SSL_client_policy',
-                                  '_sys_CEC_SSL_server_policy',
-                                  '_sys_CEC_video_policy']
-        if resource.name not in system_policy_obj_name:
-            resource.delete()
-
-
 @pytest.fixture
-def setup(request, bigip):
-    pc1 = bigip.ltm.policys
-    delete_resource(pc1)
+def setup(request, setup_device_snapshot):
+    return setup_device_snapshot
 
 
 def setup_policy_test(request, bigip, partition, name, strategy="first-match"):
-    def teardown():
-        delete_resource(pc1)
-    request.addfinalizer(teardown)
     pc1 = bigip.ltm.policys
     policy1 = pc1.policy.create(
         name=name, partition=partition, strategy=strategy)
@@ -70,10 +57,9 @@ def test_rules_refresh_update_load(self, setup, request, bigip):
         test_pol1 = rulespc.policy.load(partition='Common',
                                         name='_sys_CEC_video_policy')
         rules_s1 = test_pol1.rules_s
-        rules1 = rules_s1.rules.load(name='youporn_web_1')
+        rules1 = rules_s1.rules.load(name='cnn_web_1')
         r1actions = rules1.actions_s.actions.load(name="1")
         assert r1actions.kind == r1actions._meta_data['required_json_kind']
-        delete_resource(rulespc)
 
 
 class TestRulesAndConditions(object):
@@ -82,8 +68,7 @@ def test_rules_refresh_update_load(self, setup, request, bigip):
         test_pol1 = rulespc.policy.load(partition='Common',
                                         name='_sys_CEC_video_policy')
         rules_s1 = test_pol1.rules_s
-        rules1 = rules_s1.rules.load(name='youporn_web_1')
+        rules1 = rules_s1.rules.load(name='cnn_web_1')
         r1conditions = rules1.conditions_s.conditions.load(name="1")
         assert r1conditions.kind ==\
             r1conditions._meta_data['required_json_kind']
-        delete_resource(rulespc)

test/functional/tm/sys/test_failover.py

@@ -13,11 +13,36 @@
 # limitations under the License.
 #
 
-from f5.bigip.tm.sys.failover import InvalidParameterValue
+from f5.bigip.resource import BooleansToReduceHaveSameValue
+from f5.multi_device.utils import get_device_info
+from f5.multi_device.utils import pollster
 from pprint import pprint as pp
 
 import pytest
-import time
+
+
+def get_activation_state(device):
+    '''Get the activation state for a device.'''
+
+    device_name = get_device_info(device).name
+    act = device.tm.cm.devices.device.load(
+        name=device_name,
+        partition='Common'
+    )
+    return act.failoverState
+
+
+def check_device_state_as_expected(device, expected_state):
+    assert get_activation_state(device).lower() == expected_state.lower()
+
+
+@pytest.fixture
+def teardown_device_failover_state(request, mgmt_root):
+    def teardown():
+        if get_activation_state(mgmt_root).lower() != 'active':
+            f = mgmt_root.tm.sys.failover
+            f.exec_cmd('run', utilCmdArgs='online')
+    request.addfinalizer(teardown)
 
 
 class TestFailover(object):
@@ -47,41 +72,45 @@ def test_toggle_standby(self, bigip):
         assert f.command == u"run"
         pp('************')
         f.refresh()
+        pp('after refresh')
         pp(f.raw)
         assert 'Failover active' in f.apiRawValues['apiAnonymous']
 
     def test_attribute_values(self, bigip):
         fl = bigip.sys.failover
         # Testing both conditions
-        with pytest.raises(InvalidParameterValue):
+        with pytest.raises(BooleansToReduceHaveSameValue) as ex1:
             fl.exec_cmd('run', online=True, offline=True)
-        with pytest.raises(InvalidParameterValue):
+        assert 'online and offline, have same value: True' \
+            in ex1.value.message
+        with pytest.raises(BooleansToReduceHaveSameValue) as ex2:
             fl.exec_cmd('run', online=False, offline=False)
+        assert 'online and offline, have same value: False' \
+            in ex2.value.message
 
-    def test_exec_cmd(self, bigip):
-        fl = bigip.sys.failover.load()
-        f = bigip.sys.failover
+    def test_exec_cmd(self, mgmt_root, teardown_device_failover_state):
+        fl = mgmt_root.tm.sys.failover.load()
+        f = mgmt_root.tm.sys.failover
         f.exec_cmd('run', offline=True)
-        time.sleep(4)
+        get_activation_state(mgmt_root)
+        pollster(check_device_state_as_expected)(mgmt_root, 'forced-offline')
         fl.refresh()
+        pp(fl.raw)
         assert 'Failover forced_offline' in fl.apiRawValues['apiAnonymous']
         f.exec_cmd('run', offline=False, online=True)
-        # We need this 2 sec delay as sometimes the status does not change
-        # straight away, causing the assertion to fail.
-        time.sleep(2)
+        pollster(check_device_state_as_expected)(mgmt_root, 'active')
         fl.refresh()
+        pp(fl.raw)
         assert 'Failover active' in fl.apiRawValues['apiAnonymous']
 
-    def test_exec_cmd_cmdargs(self, bigip):
-        fl = bigip.sys.failover.load()
-        f = bigip.sys.failover
+    def test_exec_cmd_cmdargs(self, mgmt_root, teardown_device_failover_state):
+        fl = mgmt_root.tm.sys.failover.load()
+        f = mgmt_root.tm.sys.failover
         f.exec_cmd('run', utilCmdArgs='offline')
-        time.sleep(4)
+        pollster(check_device_state_as_expected)(mgmt_root, 'forced-offline')
         fl.refresh()
         assert 'Failover forced_offline' in fl.apiRawValues['apiAnonymous']
         f.exec_cmd('run', utilCmdArgs='online')
-        # We need this 2 sec delay as sometimes the status does not change
-        # straight away, causing the assertion to fail.
-        time.sleep(2)
+        pollster(check_device_state_as_expected)(mgmt_root, 'active')
         fl.refresh()
         assert 'Failover active' in fl.apiRawValues['apiAnonymous']