add regression test case for bug 1978983

This change add a repoducer test for evacuating
a vm in the powering-off state

While backporting to stable/victoria
Fixed conflict in functional.integrated_helpers
1 - Added placeholder NOT_SPECIFIED as object
	Its a default parameter value for _evacuate_server
2 - Updated _evacuate_server defition
	to allow function to wait, until expected
	server state reached
3 - Added _start_server and _stop_server
4 - Updated _evacuate_server arguments for test_evacuate
as per updated _evacuate_server signature

Related-Bug: #1978983
Change-Id: I5540df6c7497956219c06cff6f15b51c2c8bc299
(cherry picked from commit 5904c7f993ac737d68456fc05adf0aaa7a6f3018)
(cherry picked from commit 6bd0bf00fca6ac6460d70c855eded3898cfe2401)
(cherry picked from commit 1e0af92e17f878ce64bd16e428cb3c10904b0877)
(cherry picked from commit b57b0eef218fd7604658842c9277aad782d11b45)

3 files changed, 121 insertions, 6 deletions

diff --git a/nova/tests/functional/integrated_helpers.py b/nova/tests/functional/integrated_helpers.py
index fcbbdce9d4..44afcb0381 100644
--- a/nova/tests/functional/integrated_helpers.py
+++ b/nova/tests/functional/integrated_helpers.py
@@ -94,6 +94,12 @@ class StubComputeRPCAPI(compute_rpcapi.ComputeAPI):
             return rpc.ClientRouter(default_client)
 
 
+# placeholder used as a default parameter value to distinguish between the case
+# when the parameter is specified by the caller with None from the case when it
+# was not specified
+NOT_SPECIFIED = object()
+
+
 class InstanceHelperMixin:
 
     def _wait_for_server_parameter(
@@ -493,12 +499,42 @@ class InstanceHelperMixin:
         self.api.post_server_action(server['id'], {'unshelve': {}})
         return self._wait_for_state_change(server, expected_state)
 
-    def _evacuate_server(self, server, host, expected_state='ACTIVE'):
+    def _evacuate_server(
+            self, server, extra_post_args=None, expected_host=None,
+            expected_state='ACTIVE', expected_task_state=NOT_SPECIFIED,
+            expected_migration_status='done'):
         """Evacuate a server."""
-        self.api.post_server_action(server['id'], {'evacuate': {}})
-        self._wait_for_server_parameter(
-            self.server, {'OS-EXT-SRV-ATTR:host': host,
-                          'status': expected_state})
+        api = getattr(self, 'admin_api', self.api)
+
+        post = {'evacuate': {}}
+        if extra_post_args:
+            post['evacuate'].update(extra_post_args)
+
+        expected_result = {'status': expected_state}
+        if expected_host:
+            expected_result['OS-EXT-SRV-ATTR:host'] = expected_host
+        if expected_task_state is not NOT_SPECIFIED:
+            expected_result['OS-EXT-STS:task_state'] = expected_task_state
+
+        api.post_server_action(server['id'], post)
+
+        # NOTE(gibi): The order of waiting for the migration and returning
+        # a fresh server from _wait_for_server_parameter is important as
+        # the compute manager sets status of the instance before sets the
+        # host and finally sets the migration status. So waiting for the
+        # migration first makes the returned server object more consistent.
+        self._wait_for_migration_status(server, [expected_migration_status])
+        return self._wait_for_server_parameter(server, expected_result)
+
+    def _start_server(self, server):
+        self.api.post_server_action(server['id'], {'os-start': None})
+        return self._wait_for_state_change(server, 'ACTIVE')
+
+    def _stop_server(self, server, wait_for_stop=True):
+        self.api.post_server_action(server['id'], {'os-stop': None})
+        if wait_for_stop:
+            return self._wait_for_state_change(server, 'SHUTOFF')
+        return server
 
 
 class PlacementHelperMixin:
diff --git a/nova/tests/functional/regressions/test_bug_1978983.py b/nova/tests/functional/regressions/test_bug_1978983.py
new file mode 100644
index 0000000000..75260abf37
--- /dev/null
+++ b/nova/tests/functional/regressions/test_bug_1978983.py
@@ -0,0 +1,78 @@
+# Copyright 2022 Red Hat, Inc.
+# All Rights Reserved.
+#
+# 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 nova import test
+from nova.tests import fixtures as nova_fixtures
+from nova.tests.functional.api import client
+from nova.tests.functional import fixtures as func_fixtures
+from nova.tests.functional import integrated_helpers
+
+
+class EvacuateServerWithTaskState(
+    test.TestCase, integrated_helpers.InstanceHelperMixin,
+):
+    """Regression test for bug 1978983
+    If instance task state is powering-off or not None
+    instance should be allowed to evacuate.
+    """
+
+    def setUp(self):
+        super().setUp()
+        # Stub out external dependencies.
+        self.useFixture(nova_fixtures.NeutronFixture(self))
+        self.useFixture(nova_fixtures.GlanceFixture(self))
+        self.useFixture(func_fixtures.PlacementFixture())
+        self.useFixture(nova_fixtures.HostNameWeigherFixture())
+
+        # Start nova controller services.
+        self.start_service('conductor')
+        self.start_service('scheduler')
+
+        api_fixture = self.useFixture(nova_fixtures.OSAPIFixture(
+            api_version='v2.1'))
+        self.api = api_fixture.admin_api
+
+        self.src = self._start_compute(host='host1')
+        self.dest = self._start_compute(host='host2')
+
+    def test_evacuate_instance(self):
+        """Evacuating a server
+        """
+        server = self._create_server(networks=[])
+
+        self.api.microversion = 'latest'
+        server = self._wait_for_state_change(server, 'ACTIVE')
+        self.assertEqual('host1', server['OS-EXT-SRV-ATTR:host'])
+
+        # stop host1 compute service
+        self.src.stop()
+
+        # poweroff instance
+        self._stop_server(server, wait_for_stop=False)
+        server = self._wait_for_server_parameter(
+            server, {'OS-EXT-STS:task_state': 'powering-off'})
+
+        # FIXME(auniyal): As compute service is down in source node
+        # instance is stuck at powering-off, evacuation fails with
+        # msg: Cannot 'evacuate' instance <instance-id> while it is in
+        # task_state powering-off (HTTP 409)
+
+        ex = self.assertRaises(
+            client.OpenStackApiException,
+            self._evacuate_server,
+            server,
+            expected_host=self.dest.host)
+        self.assertEqual(409, ex.response.status_code)
diff --git a/nova/tests/functional/test_servers.py b/nova/tests/functional/test_servers.py
index 426745cb8a..90f3f48457 100644
--- a/nova/tests/functional/test_servers.py
+++ b/nova/tests/functional/test_servers.py
@@ -8181,7 +8181,8 @@ class AcceleratorServerOpsTest(AcceleratorServerBase):
         arqs = self.cyborg.fake_get_arqs_for_instance(self.server['id'])
         compute_to_stop, compute_to_evacuate = self._test_evacuate(
             self.server, self.NUM_HOSTS)
-        self._evacuate_server(self.server, compute_to_evacuate.host)
+        self._evacuate_server(self.server,
+            expected_host=compute_to_evacuate.host)
         compute_to_stop.start()
         self.server = self.api.get_server(self.server['id'])
         arqs_new = self.cyborg.fake_get_arqs_for_instance(self.server['id'])