238 lines
8.6 KiB
Python
238 lines
8.6 KiB
Python
"""Digesting a solution architecture's files into an operating spec, in code."""
|
|
|
|
import json
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
from execution_engine.scope import ESSENTIAL, merged, read_scope
|
|
|
|
from app.operating_model import digest, spec
|
|
from app.operating_model.workflow import ROOT
|
|
from tests.support import BUNDLE, CATALOGUE, WORKFLOW
|
|
|
|
FIXTURE = Path(__file__).parent / "fixtures" / "architecture" / "case-08-landing-zone"
|
|
SOURCES = digest.read_folder(FIXTURE)
|
|
KINDS = digest.item_kinds(ROOT, "gcp")
|
|
DIGESTED = digest.architecture(SOURCES, KINDS)
|
|
GRAPH = json.loads(SOURCES[digest.GRAPH])
|
|
|
|
|
|
def test_every_file_the_digest_reads_came_with_the_fixture():
|
|
assert set(SOURCES) == set(digest.FILES)
|
|
assert set(DIGESTED.used) == set(digest.FILES)
|
|
|
|
|
|
def test_every_component_becomes_one_item_and_every_element_is_accounted_for():
|
|
items = DIGESTED.spec["solution"]["items"]
|
|
components = json.loads(SOURCES[digest.COMPONENTS])
|
|
|
|
assert [item["source_ref"] for item in items] == [c["id"] for c in components]
|
|
assert [item["id"] for item in items] == [f"S-{n}" for n in range(1, 10)]
|
|
placed = [element for item in items for element in item["elements"]]
|
|
assert sorted(placed) == sorted(e["id"] for e in GRAPH["elements"])
|
|
assert len(placed) == 60
|
|
|
|
|
|
def test_an_item_takes_its_product_and_its_kind_from_the_providers_table():
|
|
by_ref = {item["source_ref"]: item for item in DIGESTED.spec["solution"]["items"]}
|
|
|
|
assert (by_ref["C-2"]["product"], by_ref["C-2"]["kind"]) == (
|
|
"Cloud Interconnect",
|
|
"network",
|
|
)
|
|
assert by_ref["C-4"]["kind"] == "storage"
|
|
assert by_ref["C-7"]["kind"] == "keys"
|
|
# A product the table does not know is a service; nothing is guessed.
|
|
assert by_ref["C-3"]["kind"] == "service"
|
|
|
|
|
|
def test_what_the_architecture_leaves_to_operation_becomes_the_conditions():
|
|
conditions = DIGESTED.spec["solution"]["conditions"]
|
|
left_to_operation = [
|
|
(entry["id"], statement)
|
|
for name in (digest.REQUIREMENTS, digest.RECOMMENDATIONS)
|
|
for entry in json.loads(SOURCES[name])
|
|
for statement in entry.get("outside_code") or []
|
|
]
|
|
|
|
assert [(c["source_ref"], c["condition"]) for c in conditions] == [
|
|
(identifier, " ".join(statement.split()))
|
|
for identifier, statement in left_to_operation
|
|
]
|
|
recovery = next(
|
|
c for c in conditions if "recovery time objective" in c["condition"]
|
|
)
|
|
assert recovery["source_ref"] == "NFR-11"
|
|
items = {item["id"] for item in DIGESTED.spec["solution"]["items"]}
|
|
assert all(c["on"] and set(c["on"]) <= items for c in conditions)
|
|
|
|
|
|
def test_the_settings_checked_at_build_are_not_conditions():
|
|
# 104 Checks on infrastructure settings were verified in validation. Keeping
|
|
# them true is configuration management, not a Condition each.
|
|
assert len(GRAPH["checks"]) == 104
|
|
assert len(DIGESTED.spec["solution"]["conditions"]) == 12
|
|
|
|
|
|
def test_only_what_the_customer_stated_is_carried_across_as_stated():
|
|
carried = DIGESTED.spec
|
|
|
|
assert carried["operations"]["support_hours"] == "24x7" # stated: always
|
|
assert carried["compliance"]["frameworks"] == ["DORA", "ISO27001", "PCI_DSS_v4"]
|
|
assert carried["commercial"]["currency"] == "GBP"
|
|
assert carried["solution"]["cloud_provider"] == "gcp"
|
|
assert carried["engagement"]["kind"] == "platform_foundation"
|
|
# The architecture agent assumed these for the customer; they are asked again.
|
|
assert "change_process" not in carried["operations"]
|
|
assert "service_levels" not in carried
|
|
|
|
|
|
def test_the_build_and_what_the_customer_owns_of_it_are_carried_across():
|
|
build = DIGESTED.spec["solution"]["build"]
|
|
|
|
assert build["duration_days"] == 36
|
|
assert build["customer_owned"] == [
|
|
"Order and provision the Interconnect carrier circuits"
|
|
]
|
|
|
|
|
|
def test_the_spec_says_which_execution_it_was_digested_from():
|
|
assert DIGESTED.spec["metadata"] == {
|
|
"customer_case": "case-08-landing-zone",
|
|
"source": "architecture:case-08-landing-zone-185426",
|
|
}
|
|
assert "payment platform" in DIGESTED.spec["intent"]["statement"]
|
|
|
|
|
|
def test_the_digested_spec_is_one_the_catalogue_accepts():
|
|
scope = read_scope(
|
|
DIGESTED.spec, BUNDLE.scope_catalogue(), provider_values=BUNDLE.scope_values
|
|
)
|
|
|
|
# What only the customer can say is still essential: what the business wants
|
|
# from the solution, and who operates it.
|
|
assert [gap["field"] for gap in scope.gaps(ESSENTIAL)] == [
|
|
"intent.business_outcomes",
|
|
"sourcing.model",
|
|
]
|
|
|
|
|
|
def test_every_digested_value_is_marked_and_what_the_caller_adds_is_theirs():
|
|
scope = merged(
|
|
DIGESTED.spec,
|
|
"sourcing:\n model: shared\ncommercial:\n currency: EUR\n"
|
|
"intent:\n business_outcomes: decide\n",
|
|
BUNDLE.scope_catalogue(),
|
|
provider_values=BUNDLE.scope_values,
|
|
notes=DIGESTED.notes,
|
|
)
|
|
|
|
assert scope.source("solution.items") == "digested"
|
|
assert scope.notes["solution.items"].startswith("9 components")
|
|
assert scope.source("sourcing.model") == "supplied"
|
|
assert scope.values["commercial.currency"] == "EUR"
|
|
assert scope.source("commercial.currency") == "supplied"
|
|
assert scope.gaps(ESSENTIAL) == []
|
|
|
|
|
|
def test_the_capabilities_proposed_follow_from_what_was_digested():
|
|
scope = read_scope(
|
|
DIGESTED.spec, BUNDLE.scope_catalogue(), provider_values=BUNDLE.scope_values
|
|
).for_context()
|
|
|
|
proposed = CATALOGUE.applicable(scope)
|
|
|
|
assert "backup-and-recovery" in proposed # the audit log store is storage
|
|
assert "regulatory-evidence" in proposed # DORA, ISO 27001, PCI DSS
|
|
assert len(spec.items(scope)) == 9
|
|
|
|
|
|
def test_a_check_that_did_not_pass_is_an_inherited_risk():
|
|
sources = dict(SOURCES)
|
|
verdicts = json.loads(sources[digest.VERDICTS])
|
|
verdicts["checks"][0].update(verdict="fail", evidence="display_name is empty")
|
|
sources[digest.VERDICTS] = json.dumps(verdicts)
|
|
|
|
risks = digest.architecture(sources, KINDS).spec["solution"]["inherited_risks"]
|
|
|
|
assert risks == [
|
|
{
|
|
"on": "S-1",
|
|
"risk": "Check K-1 failed in validation: `display_name` is set "
|
|
"(display_name is empty)",
|
|
"source_ref": "K-1",
|
|
}
|
|
]
|
|
assert "inherited_risks" not in DIGESTED.spec["solution"] # every Check passed
|
|
|
|
|
|
def test_files_passed_without_their_manifest_are_marked_unverified():
|
|
sources = {k: v for k, v in SOURCES.items() if k != digest.MANIFEST}
|
|
|
|
digested = digest.architecture(sources, KINDS)
|
|
|
|
assert digested.spec["metadata"] == {"source": "architecture:unverified"}
|
|
assert (
|
|
"not known to be one completed Execution" in digested.notes["metadata.source"]
|
|
)
|
|
assert len(digested.spec["solution"]["items"]) == 9
|
|
|
|
|
|
def test_the_graph_alone_is_enough_to_say_what_is_operated():
|
|
digested = digest.architecture({digest.GRAPH: SOURCES[digest.GRAPH]}, KINDS)
|
|
|
|
items = digested.spec["solution"]["items"]
|
|
# With no components file, they are taken from the Elements, in the order met.
|
|
assert sorted(item["source_ref"] for item in items) == [
|
|
f"C-{n}" for n in range(1, 10)
|
|
]
|
|
assert "conditions" not in digested.spec["solution"]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("change", "problem"),
|
|
[
|
|
(
|
|
lambda s: s.update({digest.GRAPH: "{"}),
|
|
"target-architecture.json: not valid JSON",
|
|
),
|
|
(
|
|
lambda s: s.update({digest.GRAPH: "[]"}),
|
|
"must be an object with a list of elements",
|
|
),
|
|
(
|
|
lambda s: s.update(
|
|
{digest.MANIFEST: json.dumps({"status": "completed_with_warnings"})}
|
|
),
|
|
"the Execution did not complete",
|
|
),
|
|
(
|
|
lambda s: s.update(
|
|
{digest.COMPONENTS: json.dumps([{"id": "C-1", "name": "Only one"}])}
|
|
),
|
|
"these Elements name a component that components.json does not have",
|
|
),
|
|
],
|
|
)
|
|
def test_an_architecture_that_cannot_be_used_is_refused_and_says_why(change, problem):
|
|
sources = dict(SOURCES)
|
|
change(sources)
|
|
|
|
with pytest.raises(ValueError, match=problem):
|
|
digest.architecture(sources, KINDS)
|
|
|
|
|
|
def test_sources_that_are_not_an_architecture_are_left_to_be_read():
|
|
assert digest.architecture({"design.md": "# Our platform\n"}, KINDS).spec == {}
|
|
assert WORKFLOW.digest is not None
|
|
assert WORKFLOW.digest({"design.md": "# Our platform\n"}).used == ()
|
|
|
|
|
|
def test_the_command_prints_the_spec_and_what_it_was_read_from(capsys):
|
|
assert digest.main([str(FIXTURE)]) == 0
|
|
|
|
printed = capsys.readouterr()
|
|
assert "source: architecture:case-08-landing-zone-185426" in printed.out
|
|
assert "# solution.items: 9 components" in printed.err
|
|
assert digest.main([str(FIXTURE.parent)]) == 1
|