fix: implemented codeQL and copilot suggestions by Ayaz-Microsoft · Pull Request #847 · microsoft/Multi-Agent-Custom-Automation-Engine-Solution-Accelerator

Ayaz-Microsoft · 2026-03-12T06:39:06Z

Purpose

... Implemented codeQL and copilot review suggestions
Current Findings Critical: 0, High:4

Does this introduce a breaking change?

Yes
No

How to Test

Get the code

git clone [repo-address]
cd [repo-name]
git checkout [branch-name]
npm install

Test the code

What to Check

Verify that the following are valid

...

Other Information

Ayaz-Microsoft · 2026-03-12T06:50:58Z

@copilot review this PR

Copilot · 2026-03-12T06:51:04Z

@Ayaz-Microsoft I've opened a new pull request, #849, to work on those changes. Once the pull request is ready, I'll request review from you.

Copilot

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

Copilot

Pull request overview

Copilot reviewed 7 out of 7 changed files in this pull request and generated 2 comments.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-03-12T12:47:48Z

src/tests/backend/v4/common/services/test_plan_service.py

+    def test_event_tracking_calls(self):
+        """Test that event tracking is callable via the mocked event_utils module."""
+        # Verify the mock event_utils has the track function accessible
+        assert callable(mock_event_utils.track_event_if_configured)
+        # Verify the plan_service module imported it (may be a mock attribute)
+        assert hasattr(plan_service_module, 'track_event_if_configured')



The original test verified actual behavior: it set up mocks, called handle_plan_approval, and asserted track_event_if_configured was called during execution. The replacement only checks that the mock attribute exists and is callable, which tests nothing about the actual integration of event tracking in handle_plan_approval. This significantly reduces test coverage of the event tracking behavior. If the original test had issues (e.g., flakiness), consider fixing it rather than replacing it with a no-op test.

Suggested change

def test_event_tracking_calls(self):

"""Test that event tracking is callable via the mocked event_utils module."""

# Verify the mock event_utils has the track function accessible

assert callable(mock_event_utils.track_event_if_configured)

# Verify the plan_service module imported it (may be a mock attribute)

assert hasattr(plan_service_module, 'track_event_if_configured')

@pytest.mark.asyncio

async def test_event_tracking_calls(self):

"""Test that handle_plan_approval triggers event tracking."""

# Prepare an approved plan so that the handler runs the approval path

mock_approval = MockPlanApprovalResponse(

plan_id="test-plan",

approved=True

)

user_id = "test-user"

# Setup a minimal mock database to satisfy any DB interactions

mock_db = MagicMock()

mock_database_factory.DatabaseFactory.get_database = AsyncMock(return_value=mock_db)

# Patch the event tracking function on the plan_service module

with patch.object(plan_service_module, 'track_event_if_configured', MagicMock()) as mock_track:

await PlanService.handle_plan_approval(mock_approval, user_id)

# Verify that event tracking was invoked during plan approval handling

mock_track.assert_called_once()

Copilot · 2026-03-12T12:47:49Z

src/tests/backend/common/database/test_database_base.py

        db = TestDatabase()
        mock_item = Mock()
+        await db.initialize()
+        await db.close()
        await db.add_item(mock_item)
        await db.update_item(mock_item)
-        result = await db.get_item_by_id("id", "pk", BaseDataModel)
-        assert result is None
-        results = await db.query_items("query", [], BaseDataModel)
-        assert results is None
        await db.delete_item("id", "pk")
-
-    @pytest.mark.asyncio
-    async def test_abstract_plan_operations_via_super(self):
-        """Test plan abstract methods via super() calls."""
-
-        class TestDatabase(DatabaseBase):
-            async def initialize(self): pass
-            async def close(self): pass
-            async def add_item(self, item): pass
-            async def update_item(self, item): pass
-            async def get_item_by_id(self, item_id, partition_key, model_class): return None
-            async def query_items(self, query, parameters, model_class): return []
-            async def delete_item(self, item_id, partition_key): pass
-            async def add_plan(self, plan):
-                await super().add_plan(plan)
-            async def update_plan(self, plan):
-                await super().update_plan(plan)
-            async def get_plan_by_plan_id(self, plan_id):
-                return await super().get_plan_by_plan_id(plan_id)
-            async def get_plan(self, plan_id):
-                return await super().get_plan(plan_id)
-            async def get_all_plans(self):
-                return await super().get_all_plans()
-            async def get_all_plans_by_team_id(self, team_id):
-                return await super().get_all_plans_by_team_id(team_id)
-            async def get_all_plans_by_team_id_status(self, user_id, team_id, status):
-                return await super().get_all_plans_by_team_id_status(user_id, team_id, status)
-            async def delete_plan_by_plan_id(self, plan_id):
-                return await super().delete_plan_by_plan_id(plan_id)
-            async def add_step(self, step): pass
-            async def update_step(self, step): pass
-            async def get_steps_by_plan(self, plan_id): return []
-            async def get_step(self, step_id, session_id): return None
-            async def add_team(self, team): pass
-            async def update_team(self, team): pass
-            async def get_team(self, team_id): return None
-            async def get_team_by_id(self, team_id): return None
-            async def get_all_teams(self): return []
-            async def delete_team(self, team_id): return False
-            async def get_data_by_type(self, data_type): return []
-            async def get_all_items(self): return []
-            async def get_steps_for_plan(self, plan_id): return []
-            async def get_current_team(self, user_id): return None
-            async def delete_current_team(self, user_id): return None
-            async def set_current_team(self, current_team): pass
-            async def update_current_team(self, current_team): pass
-            async def add_mplan(self, mplan): pass
-            async def update_mplan(self, mplan): pass
-            async def get_mplan(self, plan_id): return None
-            async def add_agent_message(self, message): pass
-            async def update_agent_message(self, message): pass
-            async def get_agent_messages(self, plan_id): return None
-            async def add_team_agent(self, team_agent): pass
-            async def delete_team_agent(self, team_id, agent_name): pass
-            async def get_team_agent(self, team_id, agent_name): return None
-
-        db = TestDatabase()
-        mock_plan = Mock()
-        await db.add_plan(mock_plan)
-        await db.update_plan(mock_plan)
-        assert await db.get_plan_by_plan_id("id") is None
-        assert await db.get_plan("id") is None
-        assert await db.get_all_plans() is None
-        assert await db.get_all_plans_by_team_id("team_id") is None
-        assert await db.get_all_plans_by_team_id_status("user", "team", "status") is None
-        assert await db.delete_plan_by_plan_id("id") is None
-
-    @pytest.mark.asyncio
-    async def test_abstract_step_operations_via_super(self):
-        """Test step abstract methods via super() calls."""
-
-        class TestDatabase(DatabaseBase):
-            async def initialize(self): pass
-            async def close(self): pass
-            async def add_item(self, item): pass
-            async def update_item(self, item): pass
-            async def get_item_by_id(self, item_id, partition_key, model_class): return None
-            async def query_items(self, query, parameters, model_class): return []
-            async def delete_item(self, item_id, partition_key): pass
-            async def add_plan(self, plan): pass
-            async def update_plan(self, plan): pass
-            async def get_plan_by_plan_id(self, plan_id): return None
-            async def get_plan(self, plan_id): return None
-            async def get_all_plans(self): return []
-            async def get_all_plans_by_team_id(self, team_id): return []
-            async def get_all_plans_by_team_id_status(self, user_id, team_id, status): return []
-            async def add_step(self, step):
-                await super().add_step(step)
-            async def update_step(self, step):
-                await super().update_step(step)
-            async def get_steps_by_plan(self, plan_id):
-                return await super().get_steps_by_plan(plan_id)
-            async def get_step(self, step_id, session_id):
-                return await super().get_step(step_id, session_id)
-            async def get_steps_for_plan(self, plan_id):
-                return await super().get_steps_for_plan(plan_id)
-            async def add_team(self, team): pass
-            async def update_team(self, team): pass
-            async def get_team(self, team_id): return None
-            async def get_team_by_id(self, team_id): return None
-            async def get_all_teams(self): return []
-            async def delete_team(self, team_id): return False
-            async def get_data_by_type(self, data_type): return []
-            async def get_all_items(self): return []
-            async def get_current_team(self, user_id): return None
-            async def delete_current_team(self, user_id): return None
-            async def set_current_team(self, current_team): pass
-            async def update_current_team(self, current_team): pass
-            async def delete_plan_by_plan_id(self, plan_id): return False
-            async def add_mplan(self, mplan): pass
-            async def update_mplan(self, mplan): pass
-            async def get_mplan(self, plan_id): return None
-            async def add_agent_message(self, message): pass
-            async def update_agent_message(self, message): pass
-            async def get_agent_messages(self, plan_id): return None
-            async def add_team_agent(self, team_agent): pass
-            async def delete_team_agent(self, team_id, agent_name): pass
-            async def get_team_agent(self, team_id, agent_name): return None
-
-        db = TestDatabase()
-        mock_step = Mock()
-        await db.add_step(mock_step)
-        await db.update_step(mock_step)
-        assert await db.get_steps_by_plan("plan_id") is None
-        assert await db.get_step("step_id", "session_id") is None
-        assert await db.get_steps_for_plan("plan_id") is None
-
-    @pytest.mark.asyncio
-    async def test_abstract_team_operations_via_super(self):
-        """Test team abstract methods via super() calls."""
-
-        class TestDatabase(DatabaseBase):
-            async def initialize(self): pass
-            async def close(self): pass
-            async def add_item(self, item): pass
-            async def update_item(self, item): pass
-            async def get_item_by_id(self, item_id, partition_key, model_class): return None
-            async def query_items(self, query, parameters, model_class): return []
-            async def delete_item(self, item_id, partition_key): pass
-            async def add_plan(self, plan): pass
-            async def update_plan(self, plan): pass
-            async def get_plan_by_plan_id(self, plan_id): return None
-            async def get_plan(self, plan_id): return None
-            async def get_all_plans(self): return []
-            async def get_all_plans_by_team_id(self, team_id): return []
-            async def get_all_plans_by_team_id_status(self, user_id, team_id, status): return []
-            async def add_step(self, step): pass
-            async def update_step(self, step): pass
-            async def get_steps_by_plan(self, plan_id): return []
-            async def get_step(self, step_id, session_id): return None
-            async def add_team(self, team):
-                await super().add_team(team)
-            async def update_team(self, team):
-                await super().update_team(team)
-            async def get_team(self, team_id):
-                return await super().get_team(team_id)
-            async def get_team_by_id(self, team_id):
-                return await super().get_team_by_id(team_id)
-            async def get_all_teams(self):
-                return await super().get_all_teams()
-            async def delete_team(self, team_id):
-                return await super().delete_team(team_id)
-            async def get_data_by_type(self, data_type): return []
-            async def get_all_items(self): return []
-            async def get_steps_for_plan(self, plan_id): return []
-            async def get_current_team(self, user_id): return None
-            async def delete_current_team(self, user_id): return None
-            async def set_current_team(self, current_team): pass
-            async def update_current_team(self, current_team): pass
-            async def delete_plan_by_plan_id(self, plan_id): return False
-            async def add_mplan(self, mplan): pass
-            async def update_mplan(self, mplan): pass
-            async def get_mplan(self, plan_id): return None
-            async def add_agent_message(self, message): pass
-            async def update_agent_message(self, message): pass
-            async def get_agent_messages(self, plan_id): return None
-            async def add_team_agent(self, team_agent): pass
-            async def delete_team_agent(self, team_id, agent_name): pass
-            async def get_team_agent(self, team_id, agent_name): return None
-
-        db = TestDatabase()
-        mock_team = Mock()
-        await db.add_team(mock_team)
-        await db.update_team(mock_team)
-        assert await db.get_team("team_id") is None
-        assert await db.get_team_by_id("team_id") is None
-        assert await db.get_all_teams() is None
-        assert await db.delete_team("team_id") is None
-
-    @pytest.mark.asyncio
-    async def test_abstract_data_management_via_super(self):
-        """Test data management abstract methods via super() calls."""
-
-        class TestDatabase(DatabaseBase):
-            async def initialize(self): pass
-            async def close(self): pass
-            async def add_item(self, item): pass
-            async def update_item(self, item): pass
-            async def get_item_by_id(self, item_id, partition_key, model_class): return None
-            async def query_items(self, query, parameters, model_class): return []
-            async def delete_item(self, item_id, partition_key): pass
-            async def add_plan(self, plan): pass
-            async def update_plan(self, plan): pass
-            async def get_plan_by_plan_id(self, plan_id): return None
-            async def get_plan(self, plan_id): return None
-            async def get_all_plans(self): return []
-            async def get_all_plans_by_team_id(self, team_id): return []
-            async def get_all_plans_by_team_id_status(self, user_id, team_id, status): return []
-            async def add_step(self, step): pass
-            async def update_step(self, step): pass
-            async def get_steps_by_plan(self, plan_id): return []
-            async def get_step(self, step_id, session_id): return None
-            async def add_team(self, team): pass
-            async def update_team(self, team): pass
-            async def get_team(self, team_id): return None
-            async def get_team_by_id(self, team_id): return None
-            async def get_all_teams(self): return []
-            async def delete_team(self, team_id): return False
-            async def get_data_by_type(self, data_type):
-                return await super().get_data_by_type(data_type)
-            async def get_all_items(self):
-                return await super().get_all_items()
-            async def get_steps_for_plan(self, plan_id): return []
-            async def get_current_team(self, user_id): return None
-            async def delete_current_team(self, user_id): return None
-            async def set_current_team(self, current_team): pass
-            async def update_current_team(self, current_team): pass
-            async def delete_plan_by_plan_id(self, plan_id): return False
-            async def add_mplan(self, mplan): pass
-            async def update_mplan(self, mplan): pass
-            async def get_mplan(self, plan_id): return None
-            async def add_agent_message(self, message): pass
-            async def update_agent_message(self, message): pass
-            async def get_agent_messages(self, plan_id): return None
-            async def add_team_agent(self, team_agent): pass
-            async def delete_team_agent(self, team_id, agent_name): pass
-            async def get_team_agent(self, team_id, agent_name): return None
-
-        db = TestDatabase()
-        assert await db.get_data_by_type("type") is None
-        assert await db.get_all_items() is None
-
-    @pytest.mark.asyncio
-    async def test_abstract_current_team_operations_via_super(self):
-        """Test current team abstract methods via super() calls."""
-
-        class TestDatabase(DatabaseBase):
-            async def initialize(self): pass
-            async def close(self): pass
-            async def add_item(self, item): pass
-            async def update_item(self, item): pass
-            async def get_item_by_id(self, item_id, partition_key, model_class): return None
-            async def query_items(self, query, parameters, model_class): return []
-            async def delete_item(self, item_id, partition_key): pass
-            async def add_plan(self, plan): pass
-            async def update_plan(self, plan): pass
-            async def get_plan_by_plan_id(self, plan_id): return None
-            async def get_plan(self, plan_id): return None
-            async def get_all_plans(self): return []
-            async def get_all_plans_by_team_id(self, team_id): return []
-            async def get_all_plans_by_team_id_status(self, user_id, team_id, status): return []
-            async def add_step(self, step): pass
-            async def update_step(self, step): pass
-            async def get_steps_by_plan(self, plan_id): return []
-            async def get_step(self, step_id, session_id): return None
-            async def add_team(self, team): pass
-            async def update_team(self, team): pass
-            async def get_team(self, team_id): return None
-            async def get_team_by_id(self, team_id): return None
-            async def get_all_teams(self): return []
-            async def delete_team(self, team_id): return False
-            async def get_data_by_type(self, data_type): return []
-            async def get_all_items(self): return []
-            async def get_steps_for_plan(self, plan_id): return []
-            async def get_current_team(self, user_id):
-                return await super().get_current_team(user_id)
-            async def delete_current_team(self, user_id):
-                return await super().delete_current_team(user_id)
-            async def set_current_team(self, current_team):
-                await super().set_current_team(current_team)
-            async def update_current_team(self, current_team):
-                await super().update_current_team(current_team)
-            async def delete_plan_by_plan_id(self, plan_id): return False
-            async def add_mplan(self, mplan): pass
-            async def update_mplan(self, mplan): pass
-            async def get_mplan(self, plan_id): return None
-            async def add_agent_message(self, message): pass
-            async def update_agent_message(self, message): pass
-            async def get_agent_messages(self, plan_id): return None
-            async def add_team_agent(self, team_agent): pass
-            async def delete_team_agent(self, team_id, agent_name): pass
-            async def get_team_agent(self, team_id, agent_name): return None
-
-        db = TestDatabase()
-        mock_team = Mock()
-        assert await db.get_current_team("user_id") is None
-        assert await db.delete_current_team("user_id") is None
-        await db.set_current_team(mock_team)
-        await db.update_current_team(mock_team)
-
-    @pytest.mark.asyncio
-    async def test_abstract_mplan_operations_via_super(self):
-        """Test mplan abstract methods via super() calls."""
-
-        class TestDatabase(DatabaseBase):
-            async def initialize(self): pass
-            async def close(self): pass
-            async def add_item(self, item): pass
-            async def update_item(self, item): pass
-            async def get_item_by_id(self, item_id, partition_key, model_class): return None
-            async def query_items(self, query, parameters, model_class): return []
-            async def delete_item(self, item_id, partition_key): pass
-            async def add_plan(self, plan): pass
-            async def update_plan(self, plan): pass
-            async def get_plan_by_plan_id(self, plan_id): return None
-            async def get_plan(self, plan_id): return None
-            async def get_all_plans(self): return []
-            async def get_all_plans_by_team_id(self, team_id): return []
-            async def get_all_plans_by_team_id_status(self, user_id, team_id, status): return []
-            async def add_step(self, step): pass
-            async def update_step(self, step): pass
-            async def get_steps_by_plan(self, plan_id): return []
-            async def get_step(self, step_id, session_id): return None
-            async def add_team(self, team): pass
-            async def update_team(self, team): pass
-            async def get_team(self, team_id): return None
-            async def get_team_by_id(self, team_id): return None
-            async def get_all_teams(self): return []
-            async def delete_team(self, team_id): return False
-            async def get_data_by_type(self, data_type): return []
-            async def get_all_items(self): return []
-            async def get_steps_for_plan(self, plan_id): return []
-            async def get_current_team(self, user_id): return None
-            async def delete_current_team(self, user_id): return None
-            async def set_current_team(self, current_team): pass
-            async def update_current_team(self, current_team): pass
-            async def delete_plan_by_plan_id(self, plan_id): return False
-            async def add_mplan(self, mplan):
-                await super().add_mplan(mplan)
-            async def update_mplan(self, mplan):
-                await super().update_mplan(mplan)
-            async def get_mplan(self, plan_id):
-                return await super().get_mplan(plan_id)
-            async def add_agent_message(self, message): pass
-            async def update_agent_message(self, message): pass
-            async def get_agent_messages(self, plan_id): return None
-            async def add_team_agent(self, team_agent): pass
-            async def delete_team_agent(self, team_id, agent_name): pass
-            async def get_team_agent(self, team_id, agent_name): return None
-
-        db = TestDatabase()
-        mock_mplan = Mock()
-        await db.add_mplan(mock_mplan)
-        await db.update_mplan(mock_mplan)
-        assert await db.get_mplan("plan_id") is None
-
-    @pytest.mark.asyncio
-    async def test_abstract_agent_message_operations_via_super(self):
-        """Test agent message abstract methods via super() calls."""
-
-        class TestDatabase(DatabaseBase):
-            async def initialize(self): pass
-            async def close(self): pass
-            async def add_item(self, item): pass
-            async def update_item(self, item): pass
-            async def get_item_by_id(self, item_id, partition_key, model_class): return None
-            async def query_items(self, query, parameters, model_class): return []
-            async def delete_item(self, item_id, partition_key): pass
-            async def add_plan(self, plan): pass
-            async def update_plan(self, plan): pass
-            async def get_plan_by_plan_id(self, plan_id): return None
-            async def get_plan(self, plan_id): return None
-            async def get_all_plans(self): return []
-            async def get_all_plans_by_team_id(self, team_id): return []
-            async def get_all_plans_by_team_id_status(self, user_id, team_id, status): return []
-            async def add_step(self, step): pass
-            async def update_step(self, step): pass
-            async def get_steps_by_plan(self, plan_id): return []
-            async def get_step(self, step_id, session_id): return None
-            async def add_team(self, team): pass
-            async def update_team(self, team): pass
-            async def get_team(self, team_id): return None
-            async def get_team_by_id(self, team_id): return None
-            async def get_all_teams(self): return []
-            async def delete_team(self, team_id): return False
-            async def get_data_by_type(self, data_type): return []
-            async def get_all_items(self): return []
-            async def get_steps_for_plan(self, plan_id): return []
-            async def get_current_team(self, user_id): return None
-            async def delete_current_team(self, user_id): return None
-            async def set_current_team(self, current_team): pass
-            async def update_current_team(self, current_team): pass
-            async def delete_plan_by_plan_id(self, plan_id): return False
-            async def add_mplan(self, mplan): pass
-            async def update_mplan(self, mplan): pass
-            async def get_mplan(self, plan_id): return None
-            async def add_agent_message(self, message):
-                await super().add_agent_message(message)
-            async def update_agent_message(self, message):
-                await super().update_agent_message(message)
-            async def get_agent_messages(self, plan_id):
-                return await super().get_agent_messages(plan_id)
-            async def add_team_agent(self, team_agent): pass
-            async def delete_team_agent(self, team_id, agent_name): pass
-            async def get_team_agent(self, team_id, agent_name): return None
-
-        db = TestDatabase()
-        mock_message = Mock()
-        await db.add_agent_message(mock_message)
-        await db.update_agent_message(mock_message)
-        assert await db.get_agent_messages("plan_id") is None
-
-    @pytest.mark.asyncio
-    async def test_abstract_team_agent_operations_via_super(self):
-        """Test team agent abstract methods via super() calls."""
-
-        class TestDatabase(DatabaseBase):
-            async def initialize(self): pass
-            async def close(self): pass
-            async def add_item(self, item): pass
-            async def update_item(self, item): pass
-            async def get_item_by_id(self, item_id, partition_key, model_class): return None
-            async def query_items(self, query, parameters, model_class): return []
-            async def delete_item(self, item_id, partition_key): pass
-            async def add_plan(self, plan): pass
-            async def update_plan(self, plan): pass
-            async def get_plan_by_plan_id(self, plan_id): return None
-            async def get_plan(self, plan_id): return None
-            async def get_all_plans(self): return []
-            async def get_all_plans_by_team_id(self, team_id): return []
-            async def get_all_plans_by_team_id_status(self, user_id, team_id, status): return []
-            async def add_step(self, step): pass
-            async def update_step(self, step): pass
-            async def get_steps_by_plan(self, plan_id): return []
-            async def get_step(self, step_id, session_id): return None
-            async def add_team(self, team): pass
-            async def update_team(self, team): pass
-            async def get_team(self, team_id): return None
-            async def get_team_by_id(self, team_id): return None
-            async def get_all_teams(self): return []
-            async def delete_team(self, team_id): return False
-            async def get_data_by_type(self, data_type): return []
-            async def get_all_items(self): return []
-            async def get_steps_for_plan(self, plan_id): return []
-            async def get_current_team(self, user_id): return None
-            async def delete_current_team(self, user_id): return None
-            async def set_current_team(self, current_team): pass
-            async def update_current_team(self, current_team): pass
-            async def delete_plan_by_plan_id(self, plan_id): return False
-            async def add_mplan(self, mplan): pass
-            async def update_mplan(self, mplan): pass
-            async def get_mplan(self, plan_id): return None
-            async def add_agent_message(self, message): pass
-            async def update_agent_message(self, message): pass
-            async def get_agent_messages(self, plan_id): return None
-            async def add_team_agent(self, team_agent):
-                await super().add_team_agent(team_agent)
-            async def delete_team_agent(self, team_id, agent_name):
-                await super().delete_team_agent(team_id, agent_name)
-            async def get_team_agent(self, team_id, agent_name):
-                return await super().get_team_agent(team_id, agent_name)
-
-        db = TestDatabase()
-        mock_agent = Mock()
-        await db.add_team_agent(mock_agent)
+        await db.add_plan(mock_item)
+        await db.update_plan(mock_item)
+        await db.add_step(mock_item)
+        await db.update_step(mock_item)
+        await db.add_team(mock_item)
+        await db.update_team(mock_item)
+        await db.set_current_team(mock_item)
+        await db.update_current_team(mock_item)
+        await db.add_mplan(mock_item)
+        await db.update_mplan(mock_item)
+        await db.add_agent_message(mock_item)
+        await db.update_agent_message(mock_item)
+        await db.add_team_agent(mock_item)
        await db.delete_team_agent("team_id", "agent_name")
-        assert await db.get_team_agent("team_id", "agent_name") is None



The consolidated test calls many methods but removed most of the return-value assertions that the original tests had (e.g., asserting get_item_by_id returns None, query_items returns None, get_all_plans returns None, etc.). The test now only exercises the calls without verifying the base class returns the expected values. Consider adding back assertions for the methods that return values (the get_* and delete_* methods).

…cking test

…oft/Multi-Agent-Custom-Automation-Engine-Solution-Accelerator into bugfix/codeQL-suggestions # Please enter a commit message to explain why this merge is necessary, # especially if it merges an updated upstream into a topic branch. # # Lines starting with '#' will be ignored, and an empty message aborts # the commit.

github-actions · 2026-03-16T13:54:17Z

🎉 This PR is included in version 4.1.0 🎉

The release is available on GitHub release

Your semantic-release bot 📦🚀

implemented codeQL and copilot sugestions

c5ddbe1

Ayaz-Microsoft requested review from Avijit-Microsoft, Fr4nc3, Prajwal-Microsoft, Roopan-Microsoft, Vinay-Microsoft, aniaroramsft, dgp10801, marktayl1, nchandhi and toherman-msft as code owners March 12, 2026 06:39

Ayaz-Microsoft changed the title ~~refactor: implemented codeQL and copilot suggestions~~ fix: implemented codeQL and copilot suggestions Mar 12, 2026

Ayaz-Microsoft requested a review from Copilot March 12, 2026 06:43

Copilot AI mentioned this pull request Mar 12, 2026

test: restore clean test_send_status_update_async_success coverage #849

Draft

Copilot AI reviewed Mar 12, 2026

View reviewed changes

Ayaz-Microsoft added 3 commits March 12, 2026 12:47

test: add async test for successful status update in ConnectionConfig

da96959

test: update event tracking test to verify callable mock integration

b07c5b3

Merge branch 'dev-v4' into bugfix/codeQL-suggestions

14432aa

Ayaz-Microsoft requested a review from Copilot March 12, 2026 12:45

Copilot started reviewing on behalf of Ayaz-Microsoft March 12, 2026 12:46 View session

Copilot AI reviewed Mar 12, 2026

View reviewed changes

Ayaz-Microsoft added 2 commits March 12, 2026 18:19

test: remove redundant assertion for plan_service module in event tra…

f36a005

…cking test

Roopan-Microsoft approved these changes Mar 12, 2026

View reviewed changes

Roopan-Microsoft merged commit 47f28ee into dev-v4 Mar 12, 2026
3 checks passed

github-actions bot added the released label Mar 16, 2026

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

fix: implemented codeQL and copilot suggestions#847

fix: implemented codeQL and copilot suggestions#847
Roopan-Microsoft merged 6 commits intodev-v4from
bugfix/codeQL-suggestions

Ayaz-Microsoft commented Mar 12, 2026 •

edited

Loading

Uh oh!

Ayaz-Microsoft commented Mar 12, 2026

Uh oh!

Copilot AI commented Mar 12, 2026

Uh oh!

Copilot AI left a comment

Uh oh!

Copilot AI left a comment

Uh oh!

Copilot AI Mar 12, 2026

Uh oh!

Copilot AI Mar 12, 2026

Uh oh!

Uh oh!

github-actions bot commented Mar 16, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

-    def test_event_tracking_calls(self):
-        """Test that event tracking is callable via the mocked event_utils module."""
-        # Verify the mock event_utils has the track function accessible
-        assert callable(mock_event_utils.track_event_if_configured)
-        # Verify the plan_service module imported it (may be a mock attribute)
-        assert hasattr(plan_service_module, 'track_event_if_configured')
+    @pytest.mark.asyncio
+    async def test_event_tracking_calls(self):
+        """Test that handle_plan_approval triggers event tracking."""
+        # Prepare an approved plan so that the handler runs the approval path
+        mock_approval = MockPlanApprovalResponse(
+            plan_id="test-plan",
+            approved=True
+        )
+        user_id = "test-user"
+        # Setup a minimal mock database to satisfy any DB interactions
+        mock_db = MagicMock()
+        mock_database_factory.DatabaseFactory.get_database = AsyncMock(return_value=mock_db)
+        # Patch the event tracking function on the plan_service module
+        with patch.object(plan_service_module, 'track_event_if_configured', MagicMock()) as mock_track:
+            await PlanService.handle_plan_approval(mock_approval, user_id)
+            # Verify that event tracking was invoked during plan approval handling
+            mock_track.assert_called_once()

Conversation

Ayaz-Microsoft commented Mar 12, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Purpose

Does this introduce a breaking change?

How to Test

What to Check

Other Information

Uh oh!

Ayaz-Microsoft commented Mar 12, 2026

Uh oh!

Copilot AI commented Mar 12, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI Mar 12, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 12, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

github-actions bot commented Mar 16, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

Ayaz-Microsoft commented Mar 12, 2026 •

edited

Loading