pygeai 0.6.0b6__py3-none-any.whl → 0.6.0b10__py3-none-any.whl

pygeai/tests/migration/test_strategies.py

@@ -25,7 +25,6 @@ class TestMigrationStrategies(unittest.TestCase):
         self.to_api_key = "to_key"
         self.to_instance = "http://to.instance"
         self.from_project_id = "proj_123"
-        self.to_project_id = "proj_456"
         self.to_project_name = "New Project"
         self.admin_email = "admin@example.com"
         self.agent_id = "agent_123"
@@ -54,10 +53,8 @@ class TestMigrationStrategies(unittest.TestCase):
         mock_org_manager.assert_any_call(api_key=self.from_api_key, base_url=self.from_instance)
         mock_org_manager.assert_any_call(api_key=self.to_api_key, base_url=self.to_instance)
 
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.OrganizationManager')
-    def test_project_migration_success(self, mock_org_manager, mock_stderr, mock_stdout):
+    def test_project_migration_success(self, mock_org_manager):
         mock_source = Mock()
         mock_destination = Mock()
         mock_org_manager.side_effect = [mock_source, mock_destination]
@@ -82,20 +79,14 @@ class TestMigrationStrategies(unittest.TestCase):
 
         mock_source.get_project_data.assert_called_with(project_id=self.from_project_id)
         mock_destination.create_project.assert_called_with(mock_project)
-        mock_stdout.assert_called_once()
-        self.assertIn("Migrated project:", mock_stdout.call_args[0][0])
-        mock_stderr.assert_not_called()
 
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.OrganizationManager')
-    def test_project_migration_error(self, mock_org_manager, mock_stderr, mock_stdout):
+    def test_project_migration_error_no_project_data(self, mock_org_manager):
         mock_source = Mock()
         mock_destination = Mock()
         mock_org_manager.side_effect = [mock_source, mock_destination]
 
-        mock_error_response = ErrorListResponse(errors=[Error(id=1, description="Migration failed")])
-        mock_source.get_project_data.return_value = mock_error_response
+        mock_source.get_project_data.return_value = Mock(spec=[])
 
         strategy = ProjectMigrationStrategy(
             from_api_key=self.from_api_key,
@@ -106,22 +97,22 @@ class TestMigrationStrategies(unittest.TestCase):
             to_project_name=self.to_project_name,
             admin_email=self.admin_email
         )
-        strategy.migrate()
 
-        mock_source.get_project_data.assert_called_with(project_id=self.from_project_id)
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Unable to retrieve project data", str(context.exception))
         mock_destination.create_project.assert_not_called()
-        mock_stderr.assert_called_once()
-        mock_stdout.assert_not_called()
 
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.OrganizationManager')
-    def test_project_migration_failure_no_response(self, mock_org_manager, mock_stderr, mock_stdout):
+    def test_project_migration_error_response(self, mock_org_manager):
         mock_source = Mock()
         mock_destination = Mock()
         mock_org_manager.side_effect = [mock_source, mock_destination]
 
-        mock_source.get_project_data.return_value = Mock(spec=[])
+        mock_project = Mock(spec=Project)
+        mock_source.get_project_data.return_value = Mock(project=mock_project)
+        mock_error_response = ErrorListResponse(errors=[Error(id=1, description="Creation failed")])
+        mock_destination.create_project.return_value = mock_error_response
 
         strategy = ProjectMigrationStrategy(
             from_api_key=self.from_api_key,
@@ -132,13 +123,10 @@ class TestMigrationStrategies(unittest.TestCase):
             to_project_name=self.to_project_name,
             admin_email=self.admin_email
         )
-        strategy.migrate()
 
-        mock_source.get_project_data.assert_called_with(project_id=self.from_project_id)
-        mock_destination.create_project.assert_not_called()
-        mock_stderr.assert_called_once()
-        self.assertIn("Unable to migrate project", mock_stderr.call_args[0][0])
-        mock_stdout.assert_not_called()
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Failed to create project", str(context.exception))
 
     @patch('pygeai.migration.strategies.AILabManager')
     def test_agent_migration_strategy_init(self, mock_lab_manager):
@@ -147,24 +135,19 @@ class TestMigrationStrategies(unittest.TestCase):
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             agent_id=self.agent_id
         )
         self.assertEqual(strategy.from_api_key, self.from_api_key)
         self.assertEqual(strategy.from_instance, self.from_instance)
         self.assertEqual(strategy.to_api_key, self.to_api_key)
         self.assertEqual(strategy.to_instance, self.to_instance)
-        self.assertEqual(strategy.from_project_id, self.from_project_id)
-        self.assertEqual(strategy.to_project_id, self.to_project_id)
         self.assertEqual(strategy.agent_id, self.agent_id)
         mock_lab_manager.assert_any_call(api_key=self.from_api_key, base_url=self.from_instance)
         mock_lab_manager.assert_any_call(api_key=self.to_api_key, base_url=self.to_instance)
 
     @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.AILabManager')
-    def test_agent_migration_success(self, mock_lab_manager, mock_stderr, mock_stdout):
+    def test_agent_migration_success(self, mock_lab_manager, mock_stdout):
         mock_source = Mock()
         mock_destination = Mock()
         mock_lab_manager.side_effect = [mock_source, mock_destination]
@@ -178,8 +161,6 @@ class TestMigrationStrategies(unittest.TestCase):
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             agent_id=self.agent_id
         )
         strategy.migrate()
@@ -188,63 +169,47 @@ class TestMigrationStrategies(unittest.TestCase):
         mock_destination.create_agent.assert_called_with(agent=mock_agent)
         mock_stdout.assert_called_once()
         self.assertIn("New agent detail:", mock_stdout.call_args[0][0])
-        mock_stderr.assert_not_called()
 
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.AILabManager')
-    def test_agent_migration_error(self, mock_lab_manager, mock_stderr, mock_stdout):
+    def test_agent_migration_error_not_agent(self, mock_lab_manager):
         mock_source = Mock()
         mock_destination = Mock()
         mock_lab_manager.side_effect = [mock_source, mock_destination]
 
-        mock_source.get_agent.side_effect = ValueError("Unable to retrieve requested agent.")
+        mock_source.get_agent.return_value = Mock(spec=[])
 
         strategy = AgentMigrationStrategy(
             from_api_key=self.from_api_key,
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             agent_id=self.agent_id
         )
-        strategy.migrate()
 
-        mock_source.get_agent.assert_called_with(agent_id=self.agent_id)
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Agent migration failed", str(context.exception))
         mock_destination.create_agent.assert_not_called()
-        mock_stderr.assert_called_once()
-        self.assertIn("Agent migration failed:", mock_stderr.call_args[0][0])
-        mock_stdout.assert_called_once()
-        self.assertIn("New agent detail:", mock_stdout.call_args[0][0])
 
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.AILabManager')
-    def test_agent_migration_error_response(self, mock_lab_manager, mock_stderr, mock_stdout):
+    def test_agent_migration_error_exception(self, mock_lab_manager):
         mock_source = Mock()
         mock_destination = Mock()
         mock_lab_manager.side_effect = [mock_source, mock_destination]
 
-        mock_error_response = ErrorListResponse(errors=[Error(id=1, description="Agent error")])
-        mock_source.get_agent.return_value = mock_error_response
+        mock_source.get_agent.side_effect = Exception("API Error")
 
         strategy = AgentMigrationStrategy(
             from_api_key=self.from_api_key,
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             agent_id=self.agent_id
         )
-        strategy.migrate()
 
-        mock_source.get_agent.assert_called_with(agent_id=self.agent_id)
-        mock_destination.create_agent.assert_not_called()
-        mock_stderr.assert_called_once()
-        mock_stdout.assert_called_once()
-        self.assertIn("New agent detail:", mock_stdout.call_args[0][0])
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Agent migration failed", str(context.exception))
 
     @patch('pygeai.migration.strategies.AILabManager')
     def test_tool_migration_strategy_init(self, mock_lab_manager):
@@ -253,24 +218,19 @@ class TestMigrationStrategies(unittest.TestCase):
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             tool_id=self.tool_id
         )
         self.assertEqual(strategy.from_api_key, self.from_api_key)
         self.assertEqual(strategy.from_instance, self.from_instance)
         self.assertEqual(strategy.to_api_key, self.to_api_key)
         self.assertEqual(strategy.to_instance, self.to_instance)
-        self.assertEqual(strategy.from_project_id, self.from_project_id)
-        self.assertEqual(strategy.to_project_id, self.to_project_id)
         self.assertEqual(strategy.tool_id, self.tool_id)
         mock_lab_manager.assert_any_call(api_key=self.from_api_key, base_url=self.from_instance)
         mock_lab_manager.assert_any_call(api_key=self.to_api_key, base_url=self.to_instance)
 
     @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.AILabManager')
-    def test_tool_migration_success(self, mock_lab_manager, mock_stderr, mock_stdout):
+    def test_tool_migration_success(self, mock_lab_manager, mock_stdout):
         mock_source = Mock()
         mock_destination = Mock()
         mock_lab_manager.side_effect = [mock_source, mock_destination]
@@ -284,8 +244,6 @@ class TestMigrationStrategies(unittest.TestCase):
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             tool_id=self.tool_id
         )
         strategy.migrate()
@@ -294,63 +252,27 @@ class TestMigrationStrategies(unittest.TestCase):
         mock_destination.create_tool.assert_called_with(tool=mock_tool)
         mock_stdout.assert_called_once()
         self.assertIn("New tool detail:", mock_stdout.call_args[0][0])
-        mock_stderr.assert_not_called()
-
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
-    @patch('pygeai.migration.strategies.AILabManager')
-    def test_tool_migration_error(self, mock_lab_manager, mock_stderr, mock_stdout):
-        mock_source = Mock()
-        mock_destination = Mock()
-        mock_lab_manager.side_effect = [mock_source, mock_destination]
-
-        mock_source.get_tool.side_effect = ValueError("Unable to retrieve requested tool.")
-
-        strategy = ToolMigrationStrategy(
-            from_api_key=self.from_api_key,
-            from_instance=self.from_instance,
-            to_api_key=self.to_api_key,
-            to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
-            tool_id=self.tool_id
-        )
-        strategy.migrate()
-
-        mock_source.get_tool.assert_called_with(tool_id=self.tool_id)
-        mock_destination.create_tool.assert_not_called()
-        mock_stderr.assert_called_once()
-        self.assertIn("Tool migration failed:", mock_stderr.call_args[0][0])
-        mock_stdout.assert_called_once()
-        self.assertIn("New tool detail:", mock_stdout.call_args[0][0])
 
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.AILabManager')
-    def test_tool_migration_error_response(self, mock_lab_manager, mock_stderr, mock_stdout):
+    def test_tool_migration_error_not_tool(self, mock_lab_manager):
         mock_source = Mock()
         mock_destination = Mock()
         mock_lab_manager.side_effect = [mock_source, mock_destination]
 
-        mock_error_response = ErrorListResponse(errors=[Error(id=1, description="Tool error")])
-        mock_source.get_tool.return_value = mock_error_response
+        mock_source.get_tool.return_value = Mock(spec=[])
 
         strategy = ToolMigrationStrategy(
             from_api_key=self.from_api_key,
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             tool_id=self.tool_id
         )
-        strategy.migrate()
 
-        mock_source.get_tool.assert_called_with(tool_id=self.tool_id)
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Tool migration failed", str(context.exception))
         mock_destination.create_tool.assert_not_called()
-        mock_stderr.assert_called_once()
-        mock_stdout.assert_called_once()
-        self.assertIn("New tool detail:", mock_stdout.call_args[0][0])
 
     @patch('pygeai.migration.strategies.AILabManager')
     def test_process_migration_strategy_init(self, mock_lab_manager):
@@ -359,24 +281,19 @@ class TestMigrationStrategies(unittest.TestCase):
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             process_id=self.process_id
         )
         self.assertEqual(strategy.from_api_key, self.from_api_key)
         self.assertEqual(strategy.from_instance, self.from_instance)
         self.assertEqual(strategy.to_api_key, self.to_api_key)
         self.assertEqual(strategy.to_instance, self.to_instance)
-        self.assertEqual(strategy.from_project_id, self.from_project_id)
-        self.assertEqual(strategy.to_project_id, self.to_project_id)
         self.assertEqual(strategy.process_id, self.process_id)
         mock_lab_manager.assert_any_call(api_key=self.from_api_key, base_url=self.from_instance)
         mock_lab_manager.assert_any_call(api_key=self.to_api_key, base_url=self.to_instance)
 
     @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.AILabManager')
-    def test_process_migration_success(self, mock_lab_manager, mock_stderr, mock_stdout):
+    def test_process_migration_success(self, mock_lab_manager, mock_stdout):
         mock_source = Mock()
         mock_destination = Mock()
         mock_lab_manager.side_effect = [mock_source, mock_destination]
@@ -390,8 +307,6 @@ class TestMigrationStrategies(unittest.TestCase):
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             process_id=self.process_id
         )
         strategy.migrate()
@@ -400,63 +315,27 @@ class TestMigrationStrategies(unittest.TestCase):
         mock_destination.create_process.assert_called_with(process=mock_process)
         mock_stdout.assert_called_once()
         self.assertIn("New process detail:", mock_stdout.call_args[0][0])
-        mock_stderr.assert_not_called()
 
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.AILabManager')
-    def test_process_migration_error(self, mock_lab_manager, mock_stderr, mock_stdout):
+    def test_process_migration_error_not_process(self, mock_lab_manager):
         mock_source = Mock()
         mock_destination = Mock()
         mock_lab_manager.side_effect = [mock_source, mock_destination]
 
-        mock_source.get_process.side_effect = ValueError("Unable to retrieve requested process.")
+        mock_source.get_process.return_value = Mock(spec=[])
 
         strategy = AgenticProcessMigrationStrategy(
             from_api_key=self.from_api_key,
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             process_id=self.process_id
         )
-        strategy.migrate()
-
-        mock_source.get_process.assert_called_with(process_id=self.process_id)
-        mock_destination.create_process.assert_not_called()
-        mock_stderr.assert_called_once()
-        self.assertIn("Process migration failed:", mock_stderr.call_args[0][0])
-        mock_stdout.assert_called_once()
-        self.assertIn("New process detail:", mock_stdout.call_args[0][0])
-
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
-    @patch('pygeai.migration.strategies.AILabManager')
-    def test_process_migration_error_response(self, mock_lab_manager, mock_stderr, mock_stdout):
-        mock_source = Mock()
-        mock_destination = Mock()
-        mock_lab_manager.side_effect = [mock_source, mock_destination]
-
-        mock_error_response = ErrorListResponse(errors=[Error(id=1, description="Process error")])
-        mock_source.get_process.return_value = mock_error_response
-
-        strategy = AgenticProcessMigrationStrategy(
-            from_api_key=self.from_api_key,
-            from_instance=self.from_instance,
-            to_api_key=self.to_api_key,
-            to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
-            process_id=self.process_id
-        )
-        strategy.migrate()
 
-        mock_source.get_process.assert_called_with(process_id=self.process_id)
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Process migration failed", str(context.exception))
         mock_destination.create_process.assert_not_called()
-        mock_stdout.assert_called_once()
-        mock_stderr.assert_called_once()
-        self.assertIn("Process migration failed:", mock_stderr.call_args[0][0])
 
     @patch('pygeai.migration.strategies.AILabManager')
     def test_task_migration_strategy_init(self, mock_lab_manager):
@@ -465,24 +344,19 @@ class TestMigrationStrategies(unittest.TestCase):
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             task_id=self.task_id
         )
         self.assertEqual(strategy.from_api_key, self.from_api_key)
         self.assertEqual(strategy.from_instance, self.from_instance)
         self.assertEqual(strategy.to_api_key, self.to_api_key)
         self.assertEqual(strategy.to_instance, self.to_instance)
-        self.assertEqual(strategy.from_project_id, self.from_project_id)
-        self.assertEqual(strategy.to_project_id, self.to_project_id)
         self.assertEqual(strategy.task_id, self.task_id)
         mock_lab_manager.assert_any_call(api_key=self.from_api_key, base_url=self.from_instance)
         mock_lab_manager.assert_any_call(api_key=self.to_api_key, base_url=self.to_instance)
 
     @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.AILabManager')
-    def test_task_migration_success(self, mock_lab_manager, mock_stderr, mock_stdout):
+    def test_task_migration_success(self, mock_lab_manager, mock_stdout):
         mock_source = Mock()
         mock_destination = Mock()
         mock_lab_manager.side_effect = [mock_source, mock_destination]
@@ -496,8 +370,6 @@ class TestMigrationStrategies(unittest.TestCase):
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             task_id=self.task_id
         )
         strategy.migrate()
@@ -506,73 +378,28 @@ class TestMigrationStrategies(unittest.TestCase):
         mock_destination.create_task.assert_called_with(task=mock_task)
         mock_stdout.assert_called_once()
         self.assertIn("New task detail:", mock_stdout.call_args[0][0])
-        mock_stderr.assert_not_called()
 
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
     @patch('pygeai.migration.strategies.AILabManager')
-    def test_task_migration_error(self, mock_lab_manager, mock_stderr, mock_stdout):
+    def test_task_migration_error_not_task(self, mock_lab_manager):
         mock_source = Mock()
         mock_destination = Mock()
         mock_lab_manager.side_effect = [mock_source, mock_destination]
 
-        mock_source.get_task.side_effect = ValueError("Unable to retrieve requested task.")
+        mock_source.get_task.return_value = Mock(spec=[])
 
         strategy = TaskMigrationStrategy(
             from_api_key=self.from_api_key,
             from_instance=self.from_instance,
             to_api_key=self.to_api_key,
             to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
             task_id=self.task_id
         )
-        strategy.migrate()
 
-        mock_source.get_task.assert_called_with(task_id=self.task_id)
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Task migration failed", str(context.exception))
         mock_destination.create_task.assert_not_called()
-        mock_stderr.assert_called_once()
-        self.assertIn("Task migration failed:", mock_stderr.call_args[0][0])
-        mock_stdout.assert_called_once()
-        self.assertIn("New task detail:", mock_stdout.call_args[0][0])
-
-    @patch('pygeai.core.utils.console.Console.write_stdout')
-    @patch('pygeai.core.utils.console.Console.write_stderr')
-    @patch('pygeai.migration.strategies.AILabManager')
-    def test_task_migration_error_response(self, mock_lab_manager, mock_stderr, mock_stdout):
-        mock_source = Mock()
-        mock_destination = Mock()
-        mock_lab_manager.side_effect = [mock_source, mock_destination]
 
-        mock_error_response = ErrorListResponse(errors=[Error(id=1, description="Task error")])
-        mock_source.get_task.return_value = mock_error_response
 
-        strategy = TaskMigrationStrategy(
-            from_api_key=self.from_api_key,
-            from_instance=self.from_instance,
-            to_api_key=self.to_api_key,
-            to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_id=self.to_project_id,
-            task_id=self.task_id
-        )
-        strategy.migrate()
-
-        mock_source.get_task.assert_called_with(task_id=self.task_id)
-        mock_destination.create_task.assert_not_called()
-        mock_stderr.assert_called_once()
-        mock_stdout.assert_called_once()
-        self.assertIn("New task detail:", mock_stdout.call_args[0][0])
-
-    @patch('pygeai.migration.strategies.ProjectMigrationStrategy')
-    def test_migration_strategy_default_to_api_key(self, mock_strategy):
-        strategy = ProjectMigrationStrategy(
-            from_api_key=self.from_api_key,
-            from_instance=self.from_instance,
-            to_api_key=None,
-            to_instance=self.to_instance,
-            from_project_id=self.from_project_id,
-            to_project_name=self.to_project_name,
-            admin_email=self.admin_email
-        )
-        self.assertEqual(strategy.to_api_key, self.from_api_key)
+if __name__ == '__main__':
+    unittest.main()