watcher-tempest-plugin 3.5.0__tar.gz → 3.6.0__tar.gz

{watcher_tempest_plugin-3.5.0 → watcher_tempest_plugin-3.6.0}/AUTHORS

@@ -40,6 +40,7 @@ digambar <digambarpatil15@yahoo.co.in>
 ghanshyam <gmann@ghanshyammann.com>
 gujin <gu.jin@99cloud.net>
 huang.zhiping <huang.zhiping@99cloud.net>
+jgilaber <jgilaber@redhat.com>
 licanwei <li.canwei2@zte.com.cn>
 limin.lc <limin.lc@inspur.com>
 liyou01 <liyou01@inspur.com>

{watcher_tempest_plugin-3.5.0 → watcher_tempest_plugin-3.6.0}/ChangeLog

@@ -1,10 +1,24 @@
 CHANGES
 =======
 
+3.6.0
+-----
+
+* Skip Storage Capacity test until it's fixed
+* Add tests for extended compute datamodel
+* Remove server\_state check from data\_model test
+* Fail if action plan cannot be execute
+* Remove resource\_setup skip checks
+* Refactor execute\_strategy method into smaller helpers
+* Organize strategy tests and remove duplicated tests
+* Add basic datamodel list tests
+* Add a scenario test with continuous audit
+
 3.5.0
 -----
 
 * Add stable/2025.2 job
+* Add test for volume retype with zone migration
 * Check for single instance migration to backup node
 * Add Aetos jobs in check and experimental pipelines
 * Add custom flavor and dynamic threshold to workload\_balance tests

{watcher_tempest_plugin-3.5.0/watcher_tempest_plugin.egg-info → watcher_tempest_plugin-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: watcher-tempest-plugin
-Version: 3.5.0
+Version: 3.6.0
 Summary: Tempest plugin watcher-tempest-plugin
 Home-page: https://docs.openstack.org/watcher/latest/
 Author: OpenStack

{watcher_tempest_plugin-3.5.0 → watcher_tempest_plugin-3.6.0}/watcher_tempest_plugin/config.py

@@ -127,4 +127,21 @@ OptimizationGroup = [
         help="Upper version of the test target microversion range. "
              "The format is 'X.Y', where 'X' and 'Y' are int values."
     ),
+    cfg.BoolOpt(
+        "run_continuous_audit_tests",
+        default=False,
+        help="Whether or not to run continuous audit scenario tests.",
+    ),
+    cfg.BoolOpt(
+        "run_extended_attributes_tests",
+        default=False,
+        help="Whether or not to run compute model extended attributes tests. "
+             "Note that Watcher also needs to be configured to enable the "
+             "collection of extended attributes for the compute model and the "
+             "watcher option nova_client.api_version must be set configured "
+             "accordingly. Note that some attributes require the model "
+             "collector to run and update the model, so make sure that your "
+             "`watcher_cluster_data_model_collectors` period configuration is "
+             "less than 300 seconds."
+    ),
 ]

watcher_tempest_plugin-3.6.0/watcher_tempest_plugin/tests/api/admin/test_data_model.py

@@ -0,0 +1,65 @@
+# Copyright 2025 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from tempest.lib import decorators
+from tempest.lib import exceptions
+
+from watcher_tempest_plugin.tests.api.admin import base
+
+
+class TestListDataModel(base.BaseInfraOptimTest):
+    """Tests for data models"""
+
+    min_microversion = "1.3"
+
+    @classmethod
+    def resource_setup(cls):
+        super(TestListDataModel, cls).resource_setup()
+
+    @decorators.attr(type='smoke')
+    @decorators.idempotent_id('61b54061-d68c-4179-bb00-d72c97373224')
+    def test_list_data_models(self):
+        _, body = self.client.list_data_models()
+
+        self.assertIn('context', body)
+
+        # NOTE(dviroel): list data model returns at least
+        # one element for each compute node. But we don't want to
+        # if there is no enabled compute nodes.
+        if len(body['context']) > 0:
+            context_keys = body['context'][0].keys()
+            # assert that the context has some of the expected fields
+            # note that since we don't have any instances, we don't have
+            # server fields available
+            expected_fields = set([
+                'node_hostname', 'node_uuid', 'node_vcpus', 'node_memory',
+                'node_state', 'node_vcpu_ratio', 'node_vcpu_reserved'])
+            self.assertTrue(expected_fields.issubset(set(context_keys)))
+
+
+class TestNegativeListDataModel(base.BaseInfraOptimTest):
+    """Negative tests for data models"""
+
+    min_microversion = "1.3"
+
+    @classmethod
+    def resource_setup(cls):
+        super(TestNegativeListDataModel, cls).resource_setup()
+
+    @decorators.attr(type='smoke')
+    @decorators.idempotent_id('dd0f7313-e170-4de8-b9ce-840ef3cfdd5f')
+    def test_list_data_models_storage(self):
+
+        self.assertRaises(exceptions.NotFound, self.client.list_data_models,
+                          data_model_type="storage")

{watcher_tempest_plugin-3.5.0 → watcher_tempest_plugin-3.6.0}/watcher_tempest_plugin/tests/scenario/base.py

@@ -53,14 +53,26 @@ CONF = config.CONF
 # Note that it will not affect the version of the Nova API used by
 # Watcher, only the version used by tempest when used from those tests.
 NOVA_API_VERSION_CREATE_WITH_HOST = '2.74'
+# Nova API version that adds 'pinned_availability_zone' to GET /servers/details
+# response.
+NOVA_API_VERSION_SERVER_PINNED_AZ = '2.96'
 
 
 class BaseInfraOptimScenarioTest(manager.ScenarioTest):
     """Base class for Infrastructure Optimization API tests."""
 
+    # Default Goal and Strategy to be defined in each test class that inherit
+    # from this base class.
+    GOAL = None
+    STRATEGY = None
+
     min_microversion = None
     max_microversion = manager.LATEST_MICROVERSION
 
+    # Holds the initial configuration of available compute nodes, to assist
+    # the rollback procedure.
+    initial_compute_nodes_setup = []
+
     # States where the object is waiting for some event to perform a transition
     IDLE_STATES = ('RECOMMENDED', 'FAILED', 'SUCCEEDED', 'CANCELLED')
     # States where the object can only be DELETED (end of its life-cycle)
@@ -261,6 +273,12 @@ class BaseInfraOptimScenarioTest(manager.ScenarioTest):
         return all([ap['state'] in cls.AP_FINISHED_STATES
                     for ap in action_plans['action_plans']])
 
+    def check_min_enabled_compute_nodes(self, min_nodes):
+        enabled_compute_nodes = self.get_enabled_compute_nodes()
+        msg = ("This test required at least %s enabled compute nodes, but "
+               "only %s were found." % (min_nodes, len(enabled_compute_nodes)))
+        self.assertGreaterEqual(len(enabled_compute_nodes), min_nodes, msg=msg)
+
     def wait_for_all_action_plans_to_finish(self):
         assert test_utils.call_until_true(
             func=self._are_all_action_plans_finished,
@@ -911,6 +929,11 @@ class BaseInfraOptimScenarioTest(manager.ScenarioTest):
         _, audit = cls.client.show_audit(audit_uuid)
         return audit.get('state') in cls.AUDIT_FINISHED_STATES
 
+    @classmethod
+    def is_audit_ongoing(cls, audit_uuid):
+        _, audit = cls.client.show_audit(audit_uuid)
+        return audit.get('state') == 'ONGOING'
+
     # ### ACTION PLANS ### #
 
     def delete_action_plan(self, action_plan_uuid):
@@ -922,6 +945,10 @@ class BaseInfraOptimScenarioTest(manager.ScenarioTest):
         resp, _ = self.client.delete_action_plan(action_plan_uuid)
         return resp
 
+    def has_action_plans(self, audit_uuid=None):
+        _, action_plans = self.client.list_action_plans(audit_uuid=audit_uuid)
+        return len(action_plans['action_plans']) > 0
+
     def has_action_plan_finished(self, action_plan_uuid):
         _, action_plan = self.client.show_action_plan(action_plan_uuid)
         return action_plan.get('state') in self.AP_FINISHED_STATES
@@ -934,23 +961,36 @@ class BaseInfraOptimScenarioTest(manager.ScenarioTest):
                 return False
         return True
 
-    def execute_strategy(self, goal_name, strategy_name,
-                         expected_actions=[], **audit_kwargs):
-        """Execute an action plan based on the specific strategy
-
-        - create an audit template with the specific strategy
-        - run the audit to create an action plan
-        - get the action plan
-        - Verify that all action types in the expected_actions
-          list are present in the action plan.
-        - run the action plan
-        - get results and make sure it succeeded
-        """
+    def has_action_plans_recommended(self, audit_uuid=None):
+        _, action_plans = self.client.list_action_plans(audit_uuid=audit_uuid)
+        for ap in action_plans['action_plans']:
+            _, action_plan = self.client.show_action_plan(ap['uuid'])
+            if action_plan.get('state') == 'RECOMMENDED':
+                return True
+        return False
+
+    def create_audit_template_for_strategy(self, goal_name=None,
+                                           strategy_name=None):
+        """Create and return an audit template for the given goal/strategy."""
+
+        goal_name = goal_name or self.GOAL
+        strategy_name = strategy_name or self.STRATEGY
+
         _, goal = self.client.show_goal(goal_name)
         _, strategy = self.client.show_strategy(strategy_name)
         _, audit_template = self.create_audit_template(
             goal['uuid'], strategy=strategy['uuid'])
 
+        return audit_template
+
+    def create_audit_and_wait(self, audit_template_uuid, **audit_kwargs):
+        """Create an audit from template and wait until it finishes.
+
+        Returns the finished audit object (dict).
+        Raises on FAILED/CANCELLED states.
+        """
+        # Ensure previous action plans are finished before
+        # creating a new audit
         self.assertTrue(test_utils.call_until_true(
             func=functools.partial(
                 self.has_action_plans_finished),
@@ -962,8 +1002,9 @@ class BaseInfraOptimScenarioTest(manager.ScenarioTest):
         state = audit_kwargs.pop('state', None)
         interval = audit_kwargs.pop('interval', None)
         parameters = audit_kwargs.pop('parameters', None)
+
         _, audit = self.create_audit(
-            audit_template['uuid'],
+            audit_template_uuid,
             audit_type=audit_type,
             state=state,
             interval=interval,
@@ -972,7 +1013,8 @@ class BaseInfraOptimScenarioTest(manager.ScenarioTest):
         try:
             self.assertTrue(test_utils.call_until_true(
                 func=functools.partial(
-                    self.has_audit_finished, audit['uuid']),
+                    self.has_audit_finished,
+                    audit['uuid']),
                 duration=600,
                 sleep_for=2
             ))
@@ -980,46 +1022,67 @@ class BaseInfraOptimScenarioTest(manager.ScenarioTest):
             self.fail("The audit has failed!")
 
         _, finished_audit = self.client.show_audit(audit['uuid'])
-        if finished_audit.get('state') in ('FAILED', 'CANCELLED', 'SUSPENDED'):
+        if finished_audit.get('state') in (
+                'FAILED', 'CANCELLED', 'SUSPENDED'):
             self.fail("The audit ended in unexpected state: %s!"
                       % finished_audit.get('state'))
 
+        return finished_audit
+
+    def get_action_plan_and_validate_actions(
+            self, audit_uuid, expected_action_types=None):
+        """Fetch action plan for a finished audit and validate actions.
+
+        Returns the action_plan object (dict).
+        """
         _, action_plans = self.client.list_action_plans(
-            audit_uuid=audit['uuid'])
-        action_plan = action_plans['action_plans'][0]
+            audit_uuid=audit_uuid)
+        action_plan_ref = action_plans['action_plans'][0]
+        _, action_plan = self.client.show_action_plan(
+            action_plan_ref['uuid'])
 
-        _, action_plan = self.client.show_action_plan(action_plan['uuid'])
-        created_actions = self.client.list_actions(
+        actions = self.client.list_actions(
             action_plan_uuid=action_plan["uuid"])[1]['actions']
 
-        if expected_actions:
-            action_types = {a['action_type'] for a in created_actions}
-            if set(expected_actions) != action_types:
-                self.fail("The audit has found action types %s when expecting "
-                          "%s" % (action_types, expected_actions))
+        if expected_action_types:
+            action_types = {a['action_type'] for a in actions}
+            if set(expected_action_types) != action_types:
+                self.fail(
+                    "The audit has found action types %s when expecting %s"
+                    % (action_types, expected_action_types)
+                )
+
+        return action_plan, actions
 
-        if action_plan['state'] in ('SUPERSEDED', 'SUCCEEDED'):
-            # This means the action plan is superseded so we cannot trigger it,
-            # or it is empty.
-            return
+    def execute_action_plan_and_validate_states(
+            self, action_plan_uuid,
+            expected_action_plan_states=['SUCCEEDED'],
+            expected_action_states=['SUCCEEDED']):
+        """Start the action plan execution and wait for completion.
 
+        Returns the finished action plan object (dict).
+        """
         # Execute the action by changing its state to PENDING
-        _, updated_ap = self.client.start_action_plan(action_plan['uuid'])
+        _, updated_ap = self.client.start_action_plan(action_plan_uuid)
 
         self.assertTrue(test_utils.call_until_true(
             func=functools.partial(
-                self.has_action_plan_finished, action_plan['uuid']),
+                self.has_action_plan_finished,
+                action_plan_uuid
+            ),
             duration=600,
             sleep_for=2
         ))
-        _, finished_ap = self.client.show_action_plan(action_plan['uuid'])
-        _, action_list = self.client.list_actions(
+        _, finished_ap = self.client.show_action_plan(action_plan_uuid)
+        _, finished_actions = self.client.list_actions(
             action_plan_uuid=finished_ap["uuid"])
         self.assertIn(updated_ap['state'], ('PENDING', 'ONGOING'))
-        self.assertIn(finished_ap['state'], ('SUCCEEDED', 'SUPERSEDED'))
+        self.assertIn(finished_ap['state'], expected_action_plan_states)
+
+        for action in finished_actions['actions']:
+            self.assertIn(action.get('state'), expected_action_states)
 
-        for action in action_list['actions']:
-            self.assertEqual('SUCCEEDED', action.get('state'))
+        return finished_ap, finished_actions
 
     def check_node_trait(self, node_id, trait):
         """Check if trait is in node traits
@@ -1070,6 +1133,47 @@ class BaseInfraOptimScenarioTest(manager.ScenarioTest):
                            for s in body.get('context', [])
                            if 'server_uuid' in s and 'node_hostname' in s]
 
+    def wait_for_instances_attributes_in_model(self, instances, attributes_map,
+                                               timeout=300):
+        """Waits until all instances have attributes updated in the model.
+
+        Builds a list of instances that have all attributes updated in the
+        model. Compare with the list of instances provided as argument.
+
+        :param instances: List of instances to wait for.
+        :param attributes_map: Map withattributes and expected values.
+        :param timeout: Timeout in seconds.
+
+        :raises: Exception if attributes were not updated in the model.
+        """
+
+        timeout_end = time.time() + timeout
+
+        _, body = self.client.list_data_models(data_model_type="compute")
+
+        # Get all server_uuid from model that have all attributes updated
+        # according to the attributes_map.
+        model_ids = [
+            s['server_uuid']
+            for s in body.get('context', [])
+            if 'server_uuid' in s and all(
+                s.get(k) == v for k, v in attributes_map.items())]
+
+        instance_ids = [i['id'] for i in instances]
+
+        # Check all instances are in the model list built.
+        while (not set(instance_ids) <= set(model_ids) or not model_ids):
+            time.sleep(15)
+            if time.time() >= timeout_end:
+                raise Exception("Attributes were not updated in the model.")
+
+            _, body = self.client.list_data_models(data_model_type="compute")
+            model_ids = [
+                s['server_uuid']
+                for s in body.get('context', [])
+                if 'server_uuid' in s and all(
+                    s.get(k) == v for k, v in attributes_map.items())]
+
     def wait_delete_instances_from_model(self, timeout=300):
         """Waits until all deleted instaces be removed from model."""
         timeout_end = time.time() + timeout

watcher_tempest_plugin-3.6.0/watcher_tempest_plugin/tests/scenario/test_continuous_audit.py

@@ -0,0 +1,171 @@
+# Copyright 2025 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import functools
+
+from tempest import config
+from tempest.lib.common.utils import test_utils
+from tempest.lib import decorators
+
+from watcher_tempest_plugin.tests.scenario import base
+
+CONF = config.CONF
+
+
+class TestContinuousAudit(base.BaseInfraOptimScenarioTest):
+    """Tests that create continuous audits and execute strategies."""
+
+    # Minimal version required for list data models
+    min_microversion = "1.3"
+    # Minimal version required for _create_one_instance_per_host
+    compute_min_microversion = base.NOVA_API_VERSION_CREATE_WITH_HOST
+
+    @classmethod
+    def skip_checks(cls):
+        super().skip_checks()
+        if not CONF.optimize.run_continuous_audit_tests:
+            raise cls.skipException(
+                "Continuous audit tests are disabled.")
+
+        if CONF.compute.min_compute_nodes < 2:
+            raise cls.skipException(
+                "Less than 2 compute nodes, skipping multinode tests.")
+
+        if not CONF.compute_feature_enabled.live_migration:
+            raise cls.skipException("Live migration is not enabled")
+
+    @decorators.idempotent_id("bd6a18e9-bd51-4164-9e7f-4f19d9b428ba")
+    @decorators.attr(type=['strategy', 'zone_migration'])
+    def test_continuous_audit_zone_migration(self):
+        """Create a continuous audit using zone_migration strategy"""
+        # NOTE(dviroel): We don't need to start/trigger the action plan to
+        # validate continous audits, but we need to create the workload and
+        # check if the strategy will get updates from the model.
+        self.check_min_enabled_compute_nodes(2)
+        self.addCleanup(self.wait_delete_instances_from_model)
+
+        src_host = self.get_enabled_compute_nodes()[0]['host']
+        audit_parameters = {
+            "compute_nodes": [{"src_node": src_host}],
+        }
+
+        audit_template = self.create_audit_template_for_strategy(
+            goal_name="hardware_maintenance", strategy_name="zone_migration")
+
+        self.assertTrue(test_utils.call_until_true(
+            func=functools.partial(
+                self.has_action_plans_finished),
+            duration=600,
+            sleep_for=2
+        ))
+
+        # 1. Create a continuous audit that should propose
+        #    SUCCEEDED action plans, without actions, since
+        #    we don't have any instances to move yet
+        #    NOTE(dviroel): This is intentional to force a
+        #    cluster model update from continous audit thread.
+        _, audit = self.create_audit(
+            audit_template["uuid"],
+            audit_type="CONTINUOUS",
+            interval="10",
+            parameters=audit_parameters)
+
+        # Wait until it reach the ONGOING state, otherwise fail
+        try:
+            self.assertTrue(test_utils.call_until_true(
+                func=functools.partial(
+                    self.is_audit_ongoing, audit["uuid"]),
+                duration=300,
+                sleep_for=2
+            ))
+        except ValueError:
+            self.fail("Audit failed to reach ONGOING state.")
+
+        # Wait for an action plan from this audit
+        try:
+            self.assertTrue(test_utils.call_until_true(
+                func=functools.partial(
+                    self.has_action_plans, audit["uuid"]),
+                duration=300,
+                sleep_for=10
+            ))
+        except ValueError:
+            self.fail("Audit failed to create an action plan.")
+
+        _, action_plans = self.client.list_action_plans(
+            audit_uuid=audit["uuid"])
+        action_plan = action_plans["action_plans"][0]
+
+        # Since a new run of the continuous audit will change the last
+        # action plan to CANCELLED. It is hard to guarantee that we will
+        # always have a SUCCEEDED action plan.
+        self.assertIn(action_plan['state'], ('SUCCEEDED', 'CANCELLED'))
+
+        # Action plan should have no actions
+        created_actions = self.client.list_actions(
+            action_plan_uuid=action_plan["uuid"])[1]["actions"]
+        self.assertEqual(len(created_actions), 0)
+
+        # 2. Create a instance in the host, that is our
+        # src_host in zone_migration.
+        instance = self._create_instance(host=src_host)
+        # wait for compute model updates
+        self.wait_for_instances_in_model([instance])
+
+        # Wait for a first RECOMMENDED action plan from this audit
+        try:
+            self.assertTrue(test_utils.call_until_true(
+                func=functools.partial(
+                    self.has_action_plans_recommended, audit["uuid"]),
+                duration=300,
+                sleep_for=10
+            ))
+        except ValueError:
+            self.fail("Audit failed to create a RECOMMENDED action plan.")
+
+        # Update state to CANCELLED, so it can be deleted afterwards
+        _, audit = self.client.update_audit(
+            audit["uuid"],
+            [{"op": "replace", "path": "/state", "value": "CANCELLED"}]
+        )
+
+        try:
+            self.assertTrue(test_utils.call_until_true(
+                func=functools.partial(
+                    self.has_audit_finished, audit["uuid"]),
+                duration=300,
+                sleep_for=2
+            ))
+        except ValueError:
+            self.fail("The audit failed to reach one of finished states.")
+
+        # 3. Check that the audit created a RECOMMENDED action plan, with
+        #    a migrate action
+        _, action_plans = self.client.list_action_plans(
+            audit_uuid=audit["uuid"])
+        recommended_aps = [ap for ap in action_plans["action_plans"]
+                           if ap["state"] == "RECOMMENDED"]
+
+        # At least one action plan should be a RECOMMENDED one
+        self.assertGreaterEqual(len(recommended_aps), 1)
+
+        # Validate action plan action type
+        created_actions = self.client.list_actions(
+            action_plan_uuid=recommended_aps[0]["uuid"])[1]["actions"]
+
+        expected_actions = ["migrate"]
+        action_types = {a["action_type"] for a in created_actions}
+        if set(expected_actions) != action_types:
+            self.fail("The audit has found action types %s when expecting "
+                      "%s" % (action_types, expected_actions))