Update unit tests

coriolis/tests/api/v1/data/transfers_get_merged_transfer_values.yml

@@ -26,6 +26,8 @@
       instance_osmorphing_minion_pool_mappings:
         mock_instance_1: "mock_updated_pool_1"
         mock_instance_2: "mock_updated_pool_2"
+      clone_disks: true
+      skip_os_morphing: true
   expected_result:
     source_environment:
       mock_updated_source_key: 'mock_updated_source_value'
@@ -45,6 +47,8 @@
     instance_osmorphing_minion_pool_mappings:
       mock_instance_1: "mock_updated_pool_1"
       mock_instance_2: "mock_updated_pool_2"
+    clone_disks: true
+    skip_os_morphing: true
 
 - config:
     transfer:
@@ -61,6 +65,7 @@
       instance_osmorphing_minion_pool_mappings:
         mock_instance_1: "mock_pool_1"
         mock_instance_2: "mock_pool_2"
+      clone_disks: true
     updated_values: {}
   expected_result:
     source_environment:
@@ -73,6 +78,8 @@
     network_map:
       mock_network_key: 'mock_network_value'
     notes: "mock_notes"
+    clone_disks: true
+    skip_os_morphing: false
 
 - config:
     transfer:
@@ -85,10 +92,12 @@
       instance_osmorphing_minion_pool_mappings:
         mock_instance_1: "mock_pool_1"
         mock_instance_2: "mock_pool_2"
+      skip_os_morphing: true
     updated_values: {}
   expected_result:
     source_environment: {}
     destination_environment: {}
     network_map: {}
     notes: "mock_notes"
-
+    skip_os_morphing: true
+    clone_disks: false

coriolis/tests/api/v1/data/transfers_validate_create_body.yml

@@ -17,6 +17,8 @@
         network_map: "mock_network_map"
         user_scripts: "mock_user_scripts"
         storage_mappings: "mock_storage_mappings"
+        clone_disks: true
+        skip_os_morphing: true
   exception_raised: False
   expected_result:
     - replica
@@ -33,6 +35,8 @@
     - mock_destination_minion_pool_id
     - {'mock_instance_1': 'mock_pool', 'mock_instance_2': 'mock_pool'}
     - mock_user_scripts
+    - true
+    - true
 
 - config:
     body:

coriolis/tests/api/v1/test_transfer_schedules.py

@@ -181,13 +181,15 @@ class TransferScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
             "schedule": schedule,
             "enabled": False,
             "expiration_date": date,
-            "shutdown_instance": True
+            "shutdown_instance": True,
+            "auto_deploy": False,
         }
         expected_result = (
             mock_validate_schedule.return_value,
             False,
             mock_validate_expiration_date.return_value,
-            True
+            True,
+            False
         )
 
         result = self.transfer_schedules._validate_create_body(mock_body)
@@ -221,13 +223,15 @@ class TransferScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_body = {
             "schedule": schedule,
             "enabled": False,
-            "shutdown_instance": True
+            "shutdown_instance": True,
+            "auto_deploy": False,
         }
         expected_result = (
             mock_validate_schedule.return_value,
             False,
             None,
-            True
+            True,
+            False
         )
 
         result = self.transfer_schedules._validate_create_body(mock_body)
@@ -275,13 +279,15 @@ class TransferScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
             "schedule": schedule,
             "enabled": False,
             "expiration_date": date,
-            "shutdown_instance": True
+            "shutdown_instance": True,
+            "auto_deploy": True,
         }
         expected_result = {
             "schedule": mock_validate_schedule.return_value,
             "enabled": False,
             "expiration_date": mock_validate_expiration_date.return_value,
-            "shutdown_instance": True
+            "shutdown_instance": True,
+            "auto_deploy": True,
         }
 
         result = self.transfer_schedules._validate_update_body(
@@ -348,7 +354,7 @@ class TransferScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
         schedule = mock.sentinel.schedule
         exp_date = mock.sentinel.exp_date
         mock_validate_create_body.return_value = (
-            schedule, False, exp_date, True)
+            schedule, False, exp_date, True, False)
 
         result = self.transfer_schedules.create(mock_req, transfer_id, body)
 
@@ -361,7 +367,7 @@ class TransferScheduleControllerTestCase(test_base.CoriolisBaseTestCase):
             "migration:transfer_schedules:create")
         mock_validate_create_body.assert_called_once_with(body)
         mock_create.assert_called_once_with(
-            mock_context, transfer_id, schedule, False, exp_date, True)
+            mock_context, transfer_id, schedule, False, exp_date, True, False)
         mock_single.assert_called_once_with(mock_create.return_value)
 
     @mock.patch.object(transfer_schedules.TransferScheduleController,

coriolis/tests/api/v1/test_transfer_tasks_executions.py

@@ -136,7 +136,7 @@ class TransferTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
         transfer_id = mock.sentinel.transfer_id
-        execution = {"shutdown_instances": True}
+        execution = {"shutdown_instances": True, "auto_deploy": True}
         mock_body = {"execution": execution}
 
         result = self.transfer_api.create(mock_req, transfer_id, mock_body)
@@ -149,7 +149,7 @@ class TransferTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_context.can.assert_called_once_with(
             "migration:transfer_executions:create")
         mock_create.assert_called_once_with(
-            mock_context, transfer_id, True)
+            mock_context, transfer_id, True, True)
         mock_single.assert_called_once_with(mock_create.return_value)
 
     @mock.patch.object(transfer_tasks_execution_view, 'single')
@@ -175,7 +175,7 @@ class TransferTasksExecutionControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_context.can.assert_called_once_with(
             "migration:transfer_executions:create")
         mock_create.assert_called_once_with(
-            mock_context, transfer_id, False)
+            mock_context, transfer_id, False, False)
         mock_single.assert_called_once_with(mock_create.return_value)
 
     @mock.patch.object(api.API, 'delete')

coriolis/tests/api/v1/test_transfers.py

@@ -201,7 +201,7 @@ class TransferControllerTestCase(test_base.CoriolisBaseTestCase):
         mock_context = mock.Mock()
         mock_req.environ = {'coriolis.context': mock_context}
         mock_body = {}
-        mock_validate_create_body.return_value = (mock.sentinel.value,) * 13
+        mock_validate_create_body.return_value = (mock.sentinel.value,) * 15
 
         result = self.transfers.create(mock_req, mock_body)
 

coriolis/tests/conductor/rpc/test_client.py

@@ -152,7 +152,8 @@ class ConductorClientTestCase(test_base.CoriolisRPCClientTestCase):
     def test_execute_transfer_tasks(self):
         args = {
             "transfer_id": "mock_transfer_id",
-            "shutdown_instances": False
+            "shutdown_instances": False,
+            "auto_deploy": False,
         }
         self._test(self.client.execute_transfer_tasks, args)
 
@@ -192,7 +193,9 @@ class ConductorClientTestCase(test_base.CoriolisRPCClientTestCase):
         }
         new_args = {
             "notes": None,
-            "user_scripts": None
+            "user_scripts": None,
+            "clone_disks": True,
+            "skip_os_morphing": False,
         }
         args.update(new_args)
         self._test(self.client.create_instances_transfer, args)
@@ -230,7 +233,9 @@ class ConductorClientTestCase(test_base.CoriolisRPCClientTestCase):
             "clone_disks": False,
             "force": False,
             "skip_os_morphing": False,
-            "user_scripts": None
+            "user_scripts": None,
+            "wait_for_execution": None,
+            "trust_id": None,
         }
         self._test(self.client.deploy_transfer_instances, args)
 
@@ -294,7 +299,8 @@ class ConductorClientTestCase(test_base.CoriolisRPCClientTestCase):
             "schedule": "mock_schedule",
             "enabled": "mock_enabled",
             "exp_date": "mock_exp_date",
-            "shutdown_instance": "mock_shutdown_instance"
+            "shutdown_instance": "mock_shutdown_instance",
+            "auto_deploy": False,
         }
         self._test(self.client.create_transfer_schedule, args)
 

coriolis/tests/conductor/rpc/test_server.py

@@ -1376,6 +1376,7 @@ class ConductorServerEndpointTestCase(test_base.CoriolisBaseTestCase):
                 mock.sentinel.context,
                 mock_transfer,
                 mock_tasks_execution.return_value,
+                delete_trust_id=True
             )
 
         mock_get_transfer_tasks_execution.assert_called_once_with(
@@ -2215,283 +2216,109 @@ class ConductorServerEndpointTestCase(test_base.CoriolisBaseTestCase):
         mock_get_available_providers.assert_called_once_with(
             mock.sentinel.context)
 
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        '_get_transfer'
-    )
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        '_check_reservation_for_transfer'
-    )
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        '_check_transfer_running_executions'
-    )
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        '_check_valid_transfer_tasks_execution'
-    )
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        'get_endpoint'
-    )
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        '_get_provider_types'
-    )
-    @mock.patch.object(models, "Deployment")
-    @mock.patch.object(uuid, "uuid4", return_value="deployment_id")
-    @mock.patch.object(copy, "deepcopy")
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        '_check_minion_pools_for_action'
-    )
-    @mock.patch.object(models, "TasksExecution")
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        '_get_instance_scripts'
-    )
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        '_create_task'
-    )
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        '_check_execution_tasks_sanity'
-    )
+    @mock.patch.object(models, 'Deployment')
     @mock.patch.object(db_api, 'add_deployment')
-    @mock.patch.object(lockutils, 'lock')
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        "_minion_manager_client"
-    )
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        "_set_tasks_execution_status"
-    )
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        "_begin_tasks"
-    )
-    @mock.patch.object(
-        server.ConductorServerEndpoint,
-        "get_deployment"
-    )
-    @ddt.file_data("data/deploy_transfer_instance_config.yml")
-    @ddt.unpack
-    def test_deploy_transfer_instance(
-            self,
-            mock_get_deployment,
-            mock_begin_tasks,
-            mock_set_tasks_execution_status,
-            mock_minion_manager_client,
-            mock_lock,
-            mock_add_deployment,
-            mock_check_execution_tasks_sanity,
-            mock_create_task,
-            mock_get_instance_scripts,
-            mock_tasks_execution,
-            mock_check_minion_pools_for_action,
-            mock_deepcopy,
-            mock_uuid4,
-            mock_deployment,
-            mock_get_provider_types,
-            mock_get_endpoint,
-            mock_check_valid_transfer_tasks_execution,
-            mock_check_transfer_running_executions,
-            mock_check_reservation_for_transfer,
-            mock_get_transfer,
-            config,
-            expected_tasks,
-    ):
-        skip_os_morphing = config.get('skip_os_morphing', False)
-        has_os_morphing_minion = config.get('has_os_morphing_minion', False)
-        get_optimal_flavor = config.get('get_optimal_flavor', False)
-        clone_disks = config.get('clone_disks', False)
-
-        if get_optimal_flavor:
-            mock_get_provider_types.return_value = [
-                constants.PROVIDER_TYPE_INSTANCE_FLAVOR
-            ]
-
-        instance_osmorphing_minion_pool_mappings = None
-        if not skip_os_morphing and has_os_morphing_minion:
-            instance_osmorphing_minion_pool_mappings = {
-                mock.sentinel.instance1: mock.sentinel.pool1,
-                mock.sentinel.instance2: mock.sentinel.pool2,
-            }
-
-        mock_get_transfer.return_value = mock.Mock(
-            instances=[mock.sentinel.instance1, mock.sentinel.instance2],
-            info={
-                mock.sentinel.instance1: {
-                    'volumes_info': mock.sentinel.volumes_info1
-                },
-                mock.sentinel.instance2: {
-                    'volumes_info': {}
-                },
-            },
-            instance_osmorphing_minion_pool_mappings={}
-        )
+    @mock.patch.object(server.ConductorServerEndpoint, '_get_transfer')
+    @mock.patch.object(server.ConductorServerEndpoint, '_execute_deployment')
+    @mock.patch.object(server.ConductorServerEndpoint, 'get_deployment')
+    def test_deploy_transfer_instances(
+            self, mock_get_deployment, mock_execute_deployment,
+            mock_get_transfer, mock_add_deployment, mock_deployment_model):
+        transfer_mock = mock.MagicMock()
+        transfer_mock.instance_osmorphing_minion_pool_mappings = {
+            mock.sentinel.instance1: mock.sentinel.pool1}
+        transfer_mock.user_scripts = {}
+        transfer_mock.clone_disks = False
+        transfer_mock.skip_os_morphing = True
+        transfer_mock.instances = [mock.sentinel.instance1]
+        mock_get_transfer.return_value = transfer_mock
+        osm_pool_mappings = {mock.sentinel.instance1: mock.sentinel.pool2}
+        deployment = mock_deployment_model.return_value
 
-        def call_deploy_transfer_instance():
-            return self.server.deploy_transfer_instances(
-                mock.sentinel.context,
+        result = testutils.get_wrapped_function(
+            self.server.deploy_transfer_instances)(
+                self.server,
+                mock.sentinel.ctxt,
                 mock.sentinel.transfer_id,
-                clone_disks=clone_disks,
                 force=False,
-                instance_osmorphing_minion_pool_mappings=(
-                    instance_osmorphing_minion_pool_mappings),
-                skip_os_morphing=skip_os_morphing,
+                clone_disks=True,
+                instance_osmorphing_minion_pool_mappings=osm_pool_mappings,
+                skip_os_morphing=False,
                 user_scripts=mock.sentinel.user_scripts,
-            )
-
-        # One of the instances has no volumes info
-        self.assertRaises(
-            exception.InvalidTransferState,
-            call_deploy_transfer_instance,
-        )
-
-        mock_get_endpoint.assert_called_once_with(
-            mock.sentinel.context,
-            mock_get_transfer.return_value.destination_endpoint_id
-        )
+                wait_for_execution=None,
+                trust_id=None)
 
+        self.assertEqual(mock_get_deployment.return_value, result)
+        self.assertEqual(mock.sentinel.user_scripts, deployment.user_scripts)
+        self.assertEqual(True, deployment.clone_disks)
+        self.assertEqual(False, deployment.skip_os_morphing)
+        self.assertEqual(
+            mock.sentinel.pool2,
+            deployment.instance_osmorphing_minion_pool_mappings[
+                mock.sentinel.instance1])
+        self.assertTrue(
+            transfer_mock.destination_environment is not
+            deployment.destination_environment)
         mock_get_transfer.assert_called_once_with(
-            mock.sentinel.context,
-            mock.sentinel.transfer_id,
-            include_task_info=True,
-        )
-        mock_check_transfer_running_executions.assert_called_once_with(
-            mock.sentinel.context,
-            mock_get_transfer.return_value
-        )
-        mock_check_valid_transfer_tasks_execution.assert_called_once_with(
-            mock_get_transfer.return_value,
-            False
-        )
-        mock_get_provider_types.assert_called_once_with(
-            mock.sentinel.context,
-            mock_get_endpoint.return_value
-        )
-
-        # add the missing volumes info
-        mock_get_transfer.return_value.info[mock.sentinel.instance2] = {
-            'volumes_info': mock.sentinel.volumes_info2
-        }
-
-        def create_task_side_effect(
-                instance,
-                task_type,
-                execution,
-                depends_on=None,
-                on_error=False,
-                on_error_only=False
-        ):
-            return mock.Mock(
-                id=task_type,
-                type=task_type,
-                instance=instance,
-                execution=execution,
-                depends_on=depends_on,
-                on_error=on_error,
-                on_error_only=on_error_only,
-            )
-
-        mock_create_task.side_effect = create_task_side_effect
-
-        # no longer raises exception
-        deployment = call_deploy_transfer_instance()
+            mock.sentinel.ctxt, mock.sentinel.transfer_id,
+            include_task_info=True)
+        mock_add_deployment.assert_called_once_with(
+            mock.sentinel.ctxt, deployment)
+        mock_execute_deployment.assert_called_once_with(
+            mock.sentinel.ctxt, deployment, False)
+        mock_get_deployment.assert_called_once_with(
+            mock.sentinel.ctxt, deployment.id)
 
-        mock_check_minion_pools_for_action.assert_called_once_with(
-            mock.sentinel.context,
-            mock_deployment.return_value
-        )
-        mock_check_reservation_for_transfer.assert_called_once_with(
-            mock_get_transfer.return_value)
+    @mock.patch.object(models, 'Deployment')
+    @mock.patch.object(db_api, 'add_deployment')
+    @mock.patch.object(server.ConductorServerEndpoint, '_get_transfer')
+    @mock.patch.object(server.ConductorServerEndpoint, '_execute_deployment')
+    @mock.patch.object(server.ConductorServerEndpoint, 'get_deployment')
+    def test_deploy_transfer_instances_wait_for_execution(
+            self, mock_get_deployment, mock_execute_deployment,
+            mock_get_transfer, mock_add_deployment, mock_deployment_model):
+        transfer_mock = mock.MagicMock()
+        transfer_mock.instance_osmorphing_minion_pool_mappings = {
+            mock.sentinel.instance1: mock.sentinel.pool1}
+        transfer_mock.user_scripts = {}
+        transfer_mock.clone_disks = False
+        transfer_mock.skip_os_morphing = True
+        transfer_mock.instances = [mock.sentinel.instance1]
+        mock_get_transfer.return_value = transfer_mock
+        deployment = mock_deployment_model.return_value
 
+        result = testutils.get_wrapped_function(
+            self.server.deploy_transfer_instances)(
+                self.server,
+                mock.sentinel.ctxt,
+                mock.sentinel.transfer_id,
+                force=False,
+                clone_disks=None,
+                instance_osmorphing_minion_pool_mappings=None,
+                skip_os_morphing=None,
+                user_scripts=None,
+                wait_for_execution=mock.sentinel.wait_for_execution,
+                trust_id=mock.sentinel.trust_id)
+
+        self.assertEqual(mock_get_deployment.return_value, result)
+        self.assertEqual(transfer_mock.user_scripts, deployment.user_scripts)
+        self.assertEqual(transfer_mock.clone_disks, deployment.clone_disks)
         self.assertEqual(
-            mock_tasks_execution.return_value.status,
-            constants.EXECUTION_STATUS_UNEXECUTED
-        )
+            transfer_mock.skip_os_morphing, deployment.skip_os_morphing)
         self.assertEqual(
-            mock_tasks_execution.return_value.type,
-            constants.EXECUTION_TYPE_DEPLOYMENT
-        )
-
-        for instance in mock_get_transfer.return_value.instances:
-            mock_get_instance_scripts.assert_any_call(
-                mock.sentinel.user_scripts,
-                instance,
-            )
-            mock_create_task.assert_any_call(
-                instance,
-                constants.TASK_TYPE_VALIDATE_DEPLOYMENT_INPUTS,
-                mock_tasks_execution.return_value,
-            )
-
-            # tasks defined in the yaml config
-            for task in expected_tasks:
-                kwargs = {}
-                if 'on_error' in task:
-                    kwargs = {'on_error': task['on_error']}
-                if 'on_error_only' in task:
-                    kwargs = {'on_error_only': task['on_error_only']}
-                mock_create_task.assert_has_calls([
-                    mock.call(
-                        instance,
-                        task['type'],
-                        mock_tasks_execution.return_value,
-                        depends_on=task['depends_on'],
-                        **kwargs,
-                    )
-                ])
-
-        mock_check_execution_tasks_sanity.assert_called_once_with(
-            mock_tasks_execution.return_value,
-            mock_deployment.return_value.info,
-        )
-
+            transfer_mock.instance_osmorphing_minion_pool_mappings,
+            deployment.instance_osmorphing_minion_pool_mappings)
+        self.assertTrue(
+            transfer_mock.destination_environment is not
+            deployment.destination_environment)
+        mock_get_transfer.assert_called_once_with(
+            mock.sentinel.ctxt, mock.sentinel.transfer_id,
+            include_task_info=True)
         mock_add_deployment.assert_called_once_with(
-            mock.sentinel.context,
-            mock_deployment.return_value,
-        )
-
-        if not skip_os_morphing and has_os_morphing_minion:
-            mock_lock.assert_any_call(
-                constants.DEPLOYMENT_LOCK_NAME_FORMAT
-                % mock_deployment.return_value.id,
-                external=True,
-            )
-            mock_minion_manager_client\
-                .allocate_minion_machines_for_deployment\
-                .assert_called_once_with(
-                    mock.sentinel.context,
-                    mock_deployment.return_value,
-                    include_transfer_minions=False,
-                    include_osmorphing_minions=True
-                )
-            mock_set_tasks_execution_status.assert_called_once_with(
-                mock.sentinel.context,
-                mock_tasks_execution.return_value,
-                constants.EXECUTION_STATUS_AWAITING_MINION_ALLOCATIONS
-            )
-        else:
-            mock_begin_tasks.assert_called_once_with(
-                mock.sentinel.context,
-                mock_deployment.return_value,
-                mock_tasks_execution.return_value,
-            )
-
+            mock.sentinel.ctxt, deployment)
+        mock_execute_deployment.assert_not_called()
         mock_get_deployment.assert_called_once_with(
-            mock.sentinel.context,
-            mock_deployment.return_value.id,
-        )
-
-        self.assertEqual(
-            deployment,
-            mock_get_deployment.return_value
-        )
+            mock.sentinel.ctxt, deployment.id)
 
     def test_get_instance_scripts(
         self
@@ -4781,7 +4608,8 @@ class ConductorServerEndpointTestCase(test_base.CoriolisBaseTestCase):
             mock.sentinel.schedule,
             mock.sentinel.enabled,
             mock.sentinel.exp_date,
-            mock.sentinel.shutdown_instance
+            mock.sentinel.shutdown_instance,
+            mock.sentinel.auto_deploy
         )
 
         self.assertEqual(
@@ -4796,6 +4624,7 @@ class ConductorServerEndpointTestCase(test_base.CoriolisBaseTestCase):
                 transfer_schedule.expiration_date,
                 transfer_schedule.enabled,
                 transfer_schedule.shutdown_instance,
+                transfer_schedule.auto_deploy,
                 transfer_schedule.trust_id
             ),
             (
@@ -4805,6 +4634,7 @@ class ConductorServerEndpointTestCase(test_base.CoriolisBaseTestCase):
                 mock.sentinel.exp_date,
                 mock.sentinel.enabled,
                 mock.sentinel.shutdown_instance,
+                mock.sentinel.auto_deploy,
                 mock.sentinel.trust_id
             )
         )

coriolis/tests/db/sqlalchemy/test_models.py

@@ -281,6 +281,8 @@ class BaseTransferActionTestCase(test_base.CoriolisBaseTestCase):
             mock.sentinel.instance_osmorphing_minion_pool_mappings
         transfer.user_scripts = mock.sentinel.user_scripts
         transfer.info = mock.sentinel.info
+        transfer.clone_disks = True
+        transfer.skip_os_morphing = False
         expected_result = {
             "base_id": mock.sentinel.base_id,
             "user_id": mock.sentinel.user_id,
@@ -309,7 +311,9 @@ class BaseTransferActionTestCase(test_base.CoriolisBaseTestCase):
             "instance_osmorphing_minion_pool_mappings":
                 mock.sentinel.instance_osmorphing_minion_pool_mappings,
             "user_scripts": mock.sentinel.user_scripts,
-            "info": mock.sentinel.info
+            "info": mock.sentinel.info,
+            "clone_disks": True,
+            "skip_os_morphing": False,
         }
 
         result = transfer.to_dict()

coriolis/tests/transfer_cron/rpc/test_server.py

@@ -27,10 +27,11 @@ class TriggerTransferTestCase(test_base.CoriolisBaseTestCase):
         result = server._trigger_transfer(
             mock.sentinel.ctxt,
             mock_conductor_client,
-            mock.sentinel.transfer_id, False)
+            mock.sentinel.transfer_id, False, False)
 
         mock_conductor_client.execute_transfer_tasks.assert_called_once_with(
-            mock.sentinel.ctxt, mock.sentinel.transfer_id, False)
+            mock.sentinel.ctxt, mock.sentinel.transfer_id,
+            shutdown_instance=False, auto_deploy=False)
 
         self.assertEqual(
             result, 'Execution %s for Transfer %s' % (
@@ -47,7 +48,7 @@ class TriggerTransferTestCase(test_base.CoriolisBaseTestCase):
             server._trigger_transfer(
                 mock.sentinel.ctxt,
                 mock_conductor_client,
-                mock.sentinel.action_id, False)
+                mock.sentinel.action_id, False, False)
 
 
 @ddt.ddt
@@ -97,7 +98,8 @@ class TransferCronServerEndpointTestCase(test_base.CoriolisBaseTestCase):
         test_schedule = {
             'trust_id': 'test_schedule_trust_id',
             'transfer_id': 'test_schedule_transfer_id',
-            'shutdown_instance': 'test_schedule_shutdown_instance'
+            'shutdown_instance': False,
+            'auto_deploy': False,
         }
 
         self.server._register_schedule(test_schedule)
@@ -110,7 +112,7 @@ class TransferCronServerEndpointTestCase(test_base.CoriolisBaseTestCase):
             True, datetime.datetime(2022, 12, 31), None, None,
             mock_trigger_transfer, 'test_admin_context',
             self.server._rpc_client, 'test_schedule_transfer_id',
-            'test_schedule_shutdown_instance')
+            False, False)
         mock_register.assert_called_once()
 
     @mock.patch.object(server.TransferCronServerEndpoint,

coriolis/tests/transfer_cron/test_api.py

@@ -24,14 +24,15 @@ class APITestCase(test_base.CoriolisBaseTestCase):
         enabled = mock.sentinel.enabled
         exp_date = mock.sentinel.exp_date
         shutdown_instance = mock.sentinel.shutdown_instance
+        auto_deploy = mock.sentinel.auto_deploy
 
         result = self.api.create(
             self.ctxt, self.transfer_id, schedule, enabled, exp_date,
-            shutdown_instance)
+            shutdown_instance, auto_deploy)
 
         self.rpc_client.create_transfer_schedule.assert_called_once_with(
             self.ctxt, self.transfer_id, schedule, enabled, exp_date,
-            shutdown_instance)
+            shutdown_instance, auto_deploy)
         self.assertEqual(result,
                          self.rpc_client.create_transfer_schedule.return_value)
 

coriolis/tests/transfer_tasks_executions/test_api.py

@@ -21,12 +21,13 @@ class APITestCase(test_base.CoriolisBaseTestCase):
 
     def test_create(self):
         shutdown_instances = mock.sentinel.shutdown_instances
+        auto_deploy = mock.sentinel.auto_deploy
 
         result = self.api.create(self.ctxt, self.transfer_id,
-                                 shutdown_instances)
+                                 shutdown_instances, auto_deploy)
 
         self.rpc_client.execute_transfer_tasks.assert_called_once_with(
-            self.ctxt, self.transfer_id, shutdown_instances)
+            self.ctxt, self.transfer_id, shutdown_instances, auto_deploy)
         self.assertEqual(result,
                          self.rpc_client.execute_transfer_tasks.return_value)
 

coriolis/tests/transfers/test_api.py

@@ -44,7 +44,7 @@ class APITestCase(test_base.CoriolisBaseTestCase):
             origin_minion_pool_id, destination_minion_pool_id,
             instance_osmorphing_minion_pool_mappings, source_environment,
             destination_environment, instances, network_map, storage_mappings,
-            None, None)
+            None, None, True, False)
         self.assertEqual(
             result, self.rpc_client.create_instances_transfer.return_value)