LZH-YS1998
142 lines
6.2 KiB
Python
142 lines
6.2 KiB
Python
"""Unit tests for WorkItemContextView — work-item read adapter.
|
|
|
|
Verifies the precedence rules (work_item.metadata first, task.metadata
|
|
fallback), defensive copies for list / dict returns, and graceful
|
|
degradation when either side is missing.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import unittest
|
|
from types import SimpleNamespace
|
|
|
|
from opc.layer2_organization.work_item_context_view import WorkItemContextView
|
|
|
|
|
|
def _wi(metadata: dict | None = None) -> SimpleNamespace:
|
|
return SimpleNamespace(metadata=metadata)
|
|
|
|
|
|
def _task(metadata: dict | None = None) -> SimpleNamespace:
|
|
return SimpleNamespace(metadata=metadata)
|
|
|
|
|
|
class WorkItemContextViewTests(unittest.TestCase):
|
|
def test_prefers_work_item_metadata_when_both_present(self) -> None:
|
|
view = WorkItemContextView(
|
|
work_item=_wi({"role": "senior_engineer", "shared": "wi-wins"}),
|
|
task=_task({"role": "legacy_role", "shared": "task-loses"}),
|
|
)
|
|
self.assertEqual(view.get("role"), "senior_engineer")
|
|
self.assertEqual(view.get("shared"), "wi-wins")
|
|
|
|
def test_falls_back_to_task_metadata_when_wi_key_missing(self) -> None:
|
|
view = WorkItemContextView(
|
|
work_item=_wi({"role": "engineer"}),
|
|
task=_task({"work_item_role_name": "Senior Engineer"}),
|
|
)
|
|
self.assertEqual(view.get("role"), "engineer")
|
|
self.assertEqual(view.get("work_item_role_name"), "Senior Engineer")
|
|
|
|
def test_returns_default_when_neither_present(self) -> None:
|
|
view = WorkItemContextView(work_item=_wi({}), task=_task({}))
|
|
self.assertIsNone(view.get("missing"))
|
|
self.assertEqual(view.get("missing", "fallback"), "fallback")
|
|
|
|
def test_construct_from_none_work_item_degrades_to_task_only(self) -> None:
|
|
"""task-mode path: no work_item linked. View must not crash and
|
|
must serve all values from task.metadata."""
|
|
view = WorkItemContextView(work_item=None, task=_task({"key": "val"}))
|
|
self.assertEqual(view.get("key"), "val")
|
|
self.assertEqual(view.get("missing", "d"), "d")
|
|
|
|
def test_construct_from_none_task_degrades_to_wi_only(self) -> None:
|
|
"""company-mode path where caller only has the work_item. View
|
|
serves everything from work_item.metadata."""
|
|
view = WorkItemContextView(work_item=_wi({"key": "val"}), task=None)
|
|
self.assertEqual(view.get("key"), "val")
|
|
|
|
def test_both_none_is_empty_view(self) -> None:
|
|
view = WorkItemContextView()
|
|
self.assertFalse(view.has("anything"))
|
|
self.assertEqual(view.get("anything", "d"), "d")
|
|
|
|
def test_get_list_returns_copy_not_reference(self) -> None:
|
|
"""Callers must not be able to accidentally mutate the source
|
|
through the returned list."""
|
|
source = ["a", "b", "c"]
|
|
view = WorkItemContextView(work_item=_wi({"items": source}))
|
|
returned = view.get_list("items")
|
|
returned.append("d")
|
|
self.assertEqual(source, ["a", "b", "c"]) # unchanged
|
|
self.assertEqual(view.get_list("items"), ["a", "b", "c"]) # view still clean
|
|
|
|
def test_get_list_coerces_tuple_to_list(self) -> None:
|
|
view = WorkItemContextView(work_item=_wi({"items": ("a", "b")}))
|
|
self.assertEqual(view.get_list("items"), ["a", "b"])
|
|
|
|
def test_get_list_missing_or_wrong_type_returns_empty(self) -> None:
|
|
view = WorkItemContextView(work_item=_wi({"k": "not a list"}))
|
|
self.assertEqual(view.get_list("k"), [])
|
|
self.assertEqual(view.get_list("missing"), [])
|
|
|
|
def test_get_dict_returns_copy_not_reference(self) -> None:
|
|
source = {"a": 1, "b": 2}
|
|
view = WorkItemContextView(work_item=_wi({"m": source}))
|
|
returned = view.get_dict("m")
|
|
returned["c"] = 3
|
|
self.assertEqual(source, {"a": 1, "b": 2})
|
|
self.assertEqual(view.get_dict("m"), {"a": 1, "b": 2})
|
|
|
|
def test_get_dict_missing_or_wrong_type_returns_empty(self) -> None:
|
|
view = WorkItemContextView(work_item=_wi({"k": "scalar"}))
|
|
self.assertEqual(view.get_dict("k"), {})
|
|
self.assertEqual(view.get_dict("missing"), {})
|
|
|
|
def test_has_detects_visible_keys_only(self) -> None:
|
|
view = WorkItemContextView(
|
|
work_item=_wi({"wi_only": 1}),
|
|
task=_task({"work_item_role_name": "legacy visible", "task_only": 2}),
|
|
)
|
|
self.assertTrue(view.has("wi_only"))
|
|
self.assertTrue(view.has("work_item_role_name"))
|
|
self.assertFalse(view.has("task_only"))
|
|
self.assertFalse(view.has("neither"))
|
|
|
|
def test_company_view_hides_unknown_task_fallback_keys(self) -> None:
|
|
view = WorkItemContextView(
|
|
work_item=_wi({}),
|
|
task=_task({"task_only": "hidden", "progress_log": ["legacy"]}),
|
|
)
|
|
self.assertEqual(view.get("task_only", "default"), "default")
|
|
self.assertEqual(view.get_list("progress_log"), ["legacy"])
|
|
|
|
def test_none_valued_wi_key_not_treated_as_missing(self) -> None:
|
|
"""dict.get semantics: if work_item has the key with value None,
|
|
the view returns None — it does NOT fall through to task.metadata.
|
|
This is the same rule the original task.metadata.get() used, so
|
|
migrated callers see identical behaviour."""
|
|
view = WorkItemContextView(
|
|
work_item=_wi({"k": None}),
|
|
task=_task({"k": "task_value"}),
|
|
)
|
|
self.assertIsNone(view.get("k"))
|
|
|
|
def test_object_without_metadata_attribute_degrades_gracefully(self) -> None:
|
|
"""Defensive: passing an object that lacks .metadata (or has it as
|
|
non-dict) should not crash — view becomes empty on that side."""
|
|
weird = SimpleNamespace(metadata="not a dict")
|
|
view = WorkItemContextView(work_item=weird, task=_task({"k": "v"}))
|
|
self.assertEqual(view.get("k"), "v")
|
|
|
|
def test_mutating_source_dict_after_construction_does_not_affect_view(self) -> None:
|
|
"""Construction snapshots the dicts (shallow copy). If the source
|
|
dict changes later, the view keeps its construction-time snapshot."""
|
|
src = {"key": "initial"}
|
|
view = WorkItemContextView(work_item=_wi(src))
|
|
src["key"] = "mutated"
|
|
self.assertEqual(view.get("key"), "initial")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|