Merge pull request #1140 from CERTCC/task/1087-propose-case-actor-node

feat: implement ProposeCaseToActorNode and wire into case-creation trees (#1087)

Author: sei-ahouseholder

test/core/behaviors/case/nodes/test_case_setup.py

@@ -433,3 +433,217 @@ def test_fails_when_case_not_in_datalayer(
             case_actor_participant_id=f"{actor_id}/case-actor/participant",
         )
         assert result.status == py_trees.common.Status.FAILURE
+
+
+# ---------------------------------------------------------------------------
+# ProposeCaseToActorNode tests
+# ---------------------------------------------------------------------------
+
+
+class TestProposeCaseToActorNode:
+    """ProposeCaseToActorNode sends Create(as_CaseProposal) to the case-actor."""
+
+    from vultron.core.behaviors.case.nodes.actor import (
+        ProposeCaseToActorNode,
+    )
+
+    CASE_ACTOR_ID = "https://example.org/actors/case-actor-service"
+
+    def test_succeeds_and_queues_proposal_to_outbox(
+        self,
+        bt_scenario: BTTestScenario,
+        actor: VultronCaseActor,
+        actor_id: str,
+        report: VultronReport,
+        case_obj: VultronCase,
+    ) -> None:
+        """Happy path: node returns SUCCESS and enqueues a Create activity."""
+        from vultron.core.behaviors.case.nodes.actor import (
+            ProposeCaseToActorNode,
+        )
+
+        outbox_before = list(
+            bt_scenario.dl.outbox_list_for_actor(actor_id) or []
+        )
+        result = bt_scenario.run(
+            ProposeCaseToActorNode(),
+            actor_id=actor_id,
+            case_id=case_obj.id_,
+            case_actor_id=self.CASE_ACTOR_ID,
+        )
+        bt_scenario.assert_success(result)
+
+        outbox_after = list(
+            bt_scenario.dl.outbox_list_for_actor(actor_id) or []
+        )
+        assert len(outbox_after) > len(
+            outbox_before
+        ), "ProposeCaseToActorNode must enqueue an activity to the outbox"
+
+    def test_persists_create_activity_in_datalayer(
+        self,
+        bt_scenario: BTTestScenario,
+        actor: VultronCaseActor,
+        actor_id: str,
+        report: VultronReport,
+        case_obj: VultronCase,
+    ) -> None:
+        """Create(as_CaseProposal) activity is persisted to the DataLayer."""
+        from vultron.core.behaviors.case.nodes.actor import (
+            ProposeCaseToActorNode,
+        )
+
+        create_activities_before = bt_scenario.dl.list_objects("Create")
+        bt_scenario.run(
+            ProposeCaseToActorNode(),
+            actor_id=actor_id,
+            case_id=case_obj.id_,
+            case_actor_id=self.CASE_ACTOR_ID,
+        )
+
+        create_activities_after = bt_scenario.dl.list_objects("Create")
+        assert len(create_activities_after) > len(
+            create_activities_before
+        ), "At least one new Create activity should be in the DataLayer"
+
+    def test_fails_without_case_id(
+        self,
+        bt_scenario: BTTestScenario,
+        actor: VultronCaseActor,
+        actor_id: str,
+    ) -> None:
+        """Node returns FAILURE when case_id is missing from the blackboard."""
+        from vultron.core.behaviors.case.nodes.actor import (
+            ProposeCaseToActorNode,
+        )
+
+        result = bt_scenario.run(
+            ProposeCaseToActorNode(),
+            actor_id=actor_id,
+            case_actor_id=self.CASE_ACTOR_ID,
+            # case_id intentionally omitted
+        )
+        bt_scenario.assert_failure(result)
+
+    def test_fails_without_case_actor_id(
+        self,
+        bt_scenario: BTTestScenario,
+        actor: VultronCaseActor,
+        actor_id: str,
+        case_obj: VultronCase,
+    ) -> None:
+        """Node returns FAILURE when case_actor_id is missing from the blackboard."""
+        from vultron.core.behaviors.case.nodes.actor import (
+            ProposeCaseToActorNode,
+        )
+
+        result = bt_scenario.run(
+            ProposeCaseToActorNode(),
+            actor_id=actor_id,
+            case_id=case_obj.id_,
+            # case_actor_id intentionally omitted
+        )
+        bt_scenario.assert_failure(result)
+
+    def test_fails_when_case_has_no_reports(
+        self,
+        bt_scenario: BTTestScenario,
+        actor: VultronCaseActor,
+        actor_id: str,
+    ) -> None:
+        """Node returns FAILURE when the case has no linked VulnerabilityReport."""
+        from vultron.core.behaviors.case.nodes.actor import (
+            ProposeCaseToActorNode,
+        )
+
+        empty_case = VultronCase(
+            id_="https://example.org/cases/empty-case",
+            name="Empty Case",
+            vulnerability_reports=[],
+        )
+        bt_scenario.dl.create(empty_case)
+
+        result = bt_scenario.run(
+            ProposeCaseToActorNode(),
+            actor_id=actor_id,
+            case_id=empty_case.id_,
+            case_actor_id=self.CASE_ACTOR_ID,
+        )
+        bt_scenario.assert_failure(result)
+
+    def test_fails_when_report_not_in_datalayer(
+        self,
+        bt_scenario: BTTestScenario,
+        actor: VultronCaseActor,
+        actor_id: str,
+    ) -> None:
+        """Node returns FAILURE when the linked report is absent from DataLayer."""
+        from vultron.core.behaviors.case.nodes.actor import (
+            ProposeCaseToActorNode,
+        )
+
+        dangling_case = VultronCase(
+            id_="https://example.org/cases/dangling",
+            name="Dangling Case",
+            vulnerability_reports=["https://example.org/reports/ghost"],
+        )
+        bt_scenario.dl.create(dangling_case)
+
+        result = bt_scenario.run(
+            ProposeCaseToActorNode(),
+            actor_id=actor_id,
+            case_id=dangling_case.id_,
+            case_actor_id=self.CASE_ACTOR_ID,
+        )
+        bt_scenario.assert_failure(result)
+
+    def test_fails_when_case_not_in_datalayer(
+        self,
+        bt_scenario: BTTestScenario,
+        actor: VultronCaseActor,
+        actor_id: str,
+    ) -> None:
+        """Node returns FAILURE when the case record is absent from DataLayer."""
+        from vultron.core.behaviors.case.nodes.actor import (
+            ProposeCaseToActorNode,
+        )
+
+        result = bt_scenario.run(
+            ProposeCaseToActorNode(),
+            actor_id=actor_id,
+            case_id="https://example.org/cases/nonexistent",
+            case_actor_id=self.CASE_ACTOR_ID,
+        )
+        bt_scenario.assert_failure(result)
+
+    def test_fails_when_no_trigger_activity_factory(
+        self,
+        actor: VultronCaseActor,
+        actor_id: str,
+        report: VultronReport,
+        case_obj: VultronCase,
+    ) -> None:
+        """Node returns FAILURE when trigger_activity_factory is absent."""
+        import py_trees
+
+        from vultron.adapters.driven.datalayer_sqlite import SqliteDataLayer
+        from vultron.core.behaviors.bridge import BTBridge
+        from vultron.core.behaviors.case.nodes.actor import (
+            ProposeCaseToActorNode,
+        )
+
+        # Build a bridge with NO trigger_activity_factory injected.
+        dl = SqliteDataLayer("sqlite:///:memory:")
+        dl.create(actor)
+        dl.create(report)
+        dl.create(case_obj)
+        bridge_no_factory = BTBridge(datalayer=dl)
+
+        py_trees.blackboard.Blackboard.storage.clear()
+        result = bridge_no_factory.execute_with_setup(
+            tree=ProposeCaseToActorNode(),
+            actor_id=actor_id,
+            case_id=case_obj.id_,
+            case_actor_id=self.CASE_ACTOR_ID,
+        )
+        assert result.status == py_trees.common.Status.FAILURE

test/core/behaviors/case/test_create_tree.py

@@ -27,6 +27,9 @@
 from py_trees.common import Status
 
 from vultron.adapters.driven.datalayer_sqlite import SqliteDataLayer
+from vultron.adapters.driven.trigger_activity_adapter import (
+    TriggerActivityAdapter,
+)
 from vultron.core.models.activity import VultronActivity
 from vultron.core.models.vultron_types import (
     VultronCase,
@@ -86,7 +89,12 @@ def create_case_activity(case_obj, actor_id):
 
 @pytest.fixture
 def bridge(datalayer):
-    return BTBridge(datalayer=datalayer)
+    # ProposeCaseToActorNode requires trigger_activity_factory; inject it here
+    # so all tree-execution tests exercise the full node sequence.
+    return BTBridge(
+        datalayer=datalayer,
+        trigger_activity=TriggerActivityAdapter(datalayer),
+    )
 
 
 # ============================================================================
@@ -116,6 +124,32 @@ def test_create_case_tree_second_child_is_sequence(case_obj, actor_id):
     assert isinstance(tree.children[1], py_trees.composites.Sequence)
 
 
+def test_propose_case_to_actor_node_wired_after_create_actor_node(
+    case_obj, actor_id
+):
+    """ProposeCaseToActorNode appears immediately after CreateCaseActorNode (CP-04-002)."""
+    from vultron.core.behaviors.case.nodes.actor import ProposeCaseToActorNode
+    from vultron.core.behaviors.case.case_setup_tree import CreateCaseActorNode
+
+    tree = create_create_case_tree(case_obj=case_obj, actor_id=actor_id)
+    effect_seq = tree.children[1]
+    node_types = [type(c) for c in effect_seq.children]
+
+    assert (
+        ProposeCaseToActorNode in node_types
+    ), "ProposeCaseToActorNode must be present in create_create_case_tree"
+    propose_idx = node_types.index(ProposeCaseToActorNode)
+    create_actor_idx = next(
+        i
+        for i, c in enumerate(effect_seq.children)
+        if isinstance(c, CreateCaseActorNode)
+    )
+    assert propose_idx == create_actor_idx + 1, (
+        "ProposeCaseToActorNode must appear immediately after "
+        "CreateCaseActorNode (CP-04-002)"
+    )
+
+
 # ============================================================================
 # Execution tests
 # ============================================================================

test/core/behaviors/case/test_receive_report_case_tree.py

@@ -97,14 +97,44 @@ def test_tree_second_child_is_sequence(
     def test_tree_flow_has_ten_children(
         self, report, offer, reporter_actor_id
     ):
-        """ReceiveReportCaseFlow sequence has exactly 9 action nodes."""
+        """ReceiveReportCaseFlow sequence has exactly 10 action nodes."""
         tree = create_receive_report_case_tree(
             report_id=report.id_,
             offer_id=offer.id_,
             reporter_actor_id=reporter_actor_id,
         )
         flow = tree.children[1]
-        assert len(flow.children) == 9
+        assert len(flow.children) == 10
+
+    def test_propose_case_to_actor_node_is_wired(
+        self, report, offer, reporter_actor_id
+    ):
+        """ProposeCaseToActorNode appears after CreateCaseActorNode in the flow."""
+        from vultron.core.behaviors.case.nodes.actor import (
+            ProposeCaseToActorNode,
+        )
+        from vultron.core.behaviors.case.case_setup_tree import (
+            CreateCaseActorNode,
+        )
+
+        tree = create_receive_report_case_tree(
+            report_id=report.id_,
+            offer_id=offer.id_,
+            reporter_actor_id=reporter_actor_id,
+        )
+        flow = tree.children[1]
+        node_types = [type(c) for c in flow.children]
+        assert ProposeCaseToActorNode in node_types
+        propose_idx = node_types.index(ProposeCaseToActorNode)
+        create_actor_idx = next(
+            i
+            for i, c in enumerate(flow.children)
+            if isinstance(c, CreateCaseActorNode)
+        )
+        assert propose_idx == create_actor_idx + 1, (
+            "ProposeCaseToActorNode must appear immediately after "
+            "CreateCaseActorNode"
+        )
 
 
 # ============================================================================

test/core/use_cases/received/test_case_proposal.py

@@ -37,6 +37,9 @@
 )
 from vultron.wire.as2.vocab.examples._base import gen_report
 from vultron.wire.as2.vocab.objects.case_proposal import as_CaseProposal
+from vultron.wire.as2.vocab.objects.vulnerability_report import (
+    VulnerabilityReport,
+)
 
 _CASE_ACTOR_URI = "https://example.org/case-actors/svc-1"
 _VENDOR_URI = "https://example.org/vendors/acme"
@@ -134,7 +137,9 @@ def test_execute_report_linked_to_case(self, make_payload):
         case_obj = dl.read(case_rows[0].id_)
         assert is_case_model(case_obj)
 
-        report_id = proposal.object_.id_
+        report_obj = proposal.object_
+        assert isinstance(report_obj, VulnerabilityReport)
+        report_id = report_obj.id_
         assert (
             report_id in case_obj.vulnerability_reports
         ), f"Report '{report_id}' not linked to case"
@@ -200,6 +205,9 @@ def test_execute_records_case_actor_uri(self, make_payload):
         """accept_case_proposal_received updates VultronReportCaseLink.trusted_case_actor_id."""
         dl = SqliteDataLayer("sqlite:///:memory:")
         proposal = _make_proposal()
+        assert isinstance(
+            proposal.object_, VulnerabilityReport
+        ), "_make_proposal() must embed a full VulnerabilityReport"
         report_id = proposal.object_.id_
 
         # Seed a VultronReportCaseLink so the use case can find it