@evolith/core-domain 1.0.0 → 1.0.1

package/rulesets/opa/schemas/protocol-selection.input.schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://evolith.dev/schema/opa/protocol-selection.input.schema.json",
+  "title": "Protocol Selection OPA Policy Input Schema",
+  "type": "object",
+  "required": ["satellite"],
+  "properties": {
+    "satellite": {
+      "type": "object",
+      "required": ["protocol"],
+      "properties": {
+        "protocol": {
+          "type": "object",
+          "required": ["internalServiceCallsNotGrpc", "publicApiNotRest", "graphqlInDomainLayer", "protoCentralized", "breakingChangesWithoutVersionBump"],
+          "properties": {
+            "internalServiceCallsNotGrpc": { "type": "boolean" },
+            "publicApiNotRest": { "type": "boolean" },
+            "graphqlInDomainLayer": { "type": "boolean" },
+            "protoCentralized": { "type": "boolean" },
+            "breakingChangesWithoutVersionBump": { "type": "boolean" }
+          }
+        }
+      }
+    }
+  }
+}

package/rulesets/opa/schemas/repository-taxonomy.input.schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://evolith.dev/schema/opa/repository-taxonomy.input.schema.json",
+  "title": "Repository Taxonomy OPA Policy Input Schema",
+  "type": "object",
+  "required": ["repository"],
+  "properties": {
+    "repository": {
+      "type": "object",
+      "required": ["type", "directories", "adrs"],
+      "properties": {
+        "type": { "type": "string", "enum": ["core", "satellite"] },
+        "directories": { "type": "array", "items": { "type": "string" } },
+        "adrs": { "type": "array", "items": { "type": "string" } }
+      }
+    }
+  }
+}

package/rulesets/opa/schemas/satellite-contracts.input.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://evolith.dev/schema/opa/satellite-contracts.input.schema.json",
+  "title": "Satellite Contracts OPA Policy Input Schema",
+  "type": "object",
+  "required": ["satellite"],
+  "properties": {
+    "satellite": {
+      "type": "object",
+      "required": ["contracts"],
+      "properties": {
+        "contracts": {
+          "type": "object",
+          "required": [
+            "hasEvolyamlAtRoot",
+            "phase",
+            "hasAdr0047",
+            "hasExtractionReadinessScore",
+            "coreVersionExists",
+            "phaseTransitionWithoutApproval",
+            "isDeprecated",
+            "deprecatedStatusMarked"
+          ],
+          "properties": {
+            "hasEvolyamlAtRoot": { "type": "boolean" },
+            "phase": { "type": "string", "enum": ["F1", "F2", "F3"] },
+            "hasAdr0047": { "type": "boolean" },
+            "hasExtractionReadinessScore": { "type": "boolean" },
+            "coreVersionExists": { "type": "boolean" },
+            "phaseTransitionWithoutApproval": { "type": "boolean" },
+            "isDeprecated": { "type": "boolean" },
+            "deprecatedStatusMarked": { "type": "boolean" }
+          }
+        }
+      }
+    }
+  }
+}

package/rulesets/opa/schemas/taxonomy.input.schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://evolith.dev/schema/opa/taxonomy.input.schema.json",
+  "title": "Taxonomy OPA Policy Input Schema",
+  "type": "object",
+  "required": ["core", "satellitePath", "corePath", "satellite"],
+  "properties": {
+    "satellitePath": { "type": "string" },
+    "corePath": { "type": "string" },
+    "core": {
+      "type": "object",
+      "required": ["directories", "adrs"],
+      "properties": {
+        "directories": { "type": "array", "items": { "type": "string" } },
+        "adrs": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "satellite": {
+      "type": "object",
+      "required": ["directories"],
+      "properties": {
+        "packageJson": { "type": ["object", "null"] },
+        "directories": { "type": "array", "items": { "type": "string" } }
+      }
+    }
+  }
+}

package/rulesets/opa/schemas/testing-pyramid.input.schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://evolith.dev/schema/opa/testing-pyramid.input.schema.json",
+  "title": "Testing Pyramid OPA Policy Input Schema",
+  "type": "object",
+  "required": ["satellite"],
+  "properties": {
+    "satellite": {
+      "type": "object",
+      "required": ["testing"],
+      "properties": {
+        "testing": {
+          "type": "object",
+          "required": [
+            "unitTestPercentage",
+            "integrationTestPercentage",
+            "e2eTestPercentage",
+            "unitTestsExecuteIo",
+            "businessLogicCoverage",
+            "domainCoverage",
+            "applicationCoverage",
+            "infrastructureCoverage",
+            "apiCoverage",
+            "unitTestsHaveIoOperations"
+          ],
+          "properties": {
+            "unitTestPercentage": { "type": "number" },
+            "integrationTestPercentage": { "type": "number" },
+            "e2eTestPercentage": { "type": "number" },
+            "unitTestsExecuteIo": { "type": "boolean" },
+            "businessLogicCoverage": { "type": "number" },
+            "domainCoverage": { "type": "number" },
+            "applicationCoverage": { "type": "number" },
+            "infrastructureCoverage": { "type": "number" },
+            "apiCoverage": { "type": "number" },
+            "unitTestsHaveIoOperations": { "type": "boolean" }
+          }
+        }
+      }
+    }
+  }
+}

package/rulesets/opa/schemas/version-pinning.input.schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://evolith.dev/schema/opa/version-pinning.input.schema.json",
+  "title": "Version Pinning OPA Policy Input Schema",
+  "type": "object",
+  "required": ["satellite"],
+  "properties": {
+    "satellite": {
+      "type": "object",
+      "required": ["packageJson", "workspacePackageJsons"],
+      "properties": {
+        "packageJson": {
+          "type": ["object", "null"],
+          "properties": {
+            "dependencies": { "type": "object", "additionalProperties": { "type": "string" } },
+            "devDependencies": { "type": "object", "additionalProperties": { "type": "string" } }
+          }
+        },
+        "workspacePackageJsons": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["path", "content"],
+            "properties": {
+              "path": { "type": "string" },
+              "content": {
+                "type": "object",
+                "properties": {
+                  "dependencies": { "type": "object", "additionalProperties": { "type": "string" } },
+                  "devDependencies": { "type": "object", "additionalProperties": { "type": "string" } }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/rulesets/opa/sdlc/coverage.rego

@@ -0,0 +1,49 @@
+package evolith.sdlc.coverage
+
+# Gate F3 — Quality Thresholds (QT-01..08)
+
+violations[{"id": "QT-01", "message": msg}] {
+	input.coverage_percentage < 80
+	msg := sprintf("QT-01: Coverage below threshold: got %d%%, expected >= 80%%", [input.coverage_percentage])
+}
+
+violations[{"id": "QT-02", "message": msg}] {
+	input.maxCyclomaticComplexity > 15
+	msg := sprintf("QT-02: Cyclomatic complexity exceeds 15 (found %d) — refactor required before merge", [input.maxCyclomaticComplexity])
+}
+
+violations[{"id": "QT-03", "message": msg}] {
+	input.criticalCveCount > 0
+	msg := sprintf("QT-03: %d Critical CVE(s) detected — merge blocked until resolved", [input.criticalCveCount])
+}
+
+violations[{"id": "QT-03", "message": msg}] {
+	input.highCveCount > 0
+	msg := sprintf("QT-03: %d High CVE(s) detected — justification required before merge", [input.highCveCount])
+}
+
+violations[{"id": "QT-04", "message": msg}] {
+	input.technicalDebtRatio > 5
+	not input.technicalDebtRemediationPlanExists
+	msg := sprintf("QT-04: Technical debt ratio is %v%% (threshold: 5%%) — remediation plan required for RC stamp", [input.technicalDebtRatio])
+}
+
+violations[{"id": "QT-06", "message": "QT-06: Code behavior change detected without corresponding documentation update — architecture, API, or ops runbook docs must be updated"}] {
+	input.behaviorChangedWithoutDocUpdate
+}
+
+violations[{"id": "QT-07", "message": msg}] {
+	input.apiPathsWithoutObservability > 0
+	msg := sprintf("QT-07: %d production API path(s) missing traces, logs, or metrics — Production Live blocked", [input.apiPathsWithoutObservability])
+}
+
+violations[{"id": "QT-08", "message": "QT-08: Breaking contract change to gRPC/REST inter-module interface detected — consumer-driven contract tests must pass before merge"}] {
+	input.breakingContractChange
+	not input.contractTestsPassed
+}
+
+default allow = false
+
+allow {
+	count(violations) == 0
+}

package/rulesets/opa/sdlc/coverage.test.rego

@@ -0,0 +1,29 @@
+package evolith.sdlc.coverage_test
+
+import data.evolith.sdlc.coverage
+
+test_coverage_above_threshold_is_allowed {
+	coverage.allow with input as {"coverage_percentage": 85}
+}
+
+test_coverage_at_threshold_is_allowed {
+	coverage.allow with input as {"coverage_percentage": 80}
+}
+
+test_coverage_below_threshold_is_not_allowed {
+	not coverage.allow with input as {"coverage_percentage": 75}
+}
+
+test_coverage_zero_is_not_allowed {
+	not coverage.allow with input as {"coverage_percentage": 0}
+}
+
+test_violations_produced_when_below_threshold {
+	violations := coverage.violations with input as {"coverage_percentage": 50}
+	count(violations) > 0
+}
+
+test_no_violations_when_above_threshold {
+	violations := coverage.violations with input as {"coverage_percentage": 90}
+	count(violations) == 0
+}

package/rulesets/opa/sdlc/pyramid-distribution.rego

@@ -0,0 +1,31 @@
+package evolith.sdlc.pyramid
+
+# Gate F4 — Pyramid Distribution
+# Target: 70% unit / 20% integration / 10% E2E
+# Acceptable deviation: +/- 10 percentage points per tier
+
+target_unit = 70
+target_integration = 20
+target_e2e = 10
+tolerance = 10
+
+violations[msg] {
+	abs(input.unit_pct - target_unit) > tolerance
+	msg := sprintf("Unit distribution off by %dpp (got %d%%, target %d%%)", [abs(input.unit_pct - target_unit), input.unit_pct, target_unit])
+}
+
+violations[msg] {
+	abs(input.integration_pct - target_integration) > tolerance
+	msg := sprintf("Integration distribution off by %dpp (got %d%%, target %d%%)", [abs(input.integration_pct - target_integration), input.integration_pct, target_integration])
+}
+
+violations[msg] {
+	abs(input.e2e_pct - target_e2e) > tolerance
+	msg := sprintf("E2E distribution off by %dpp (got %d%%, target %d%%)", [abs(input.e2e_pct - target_e2e), input.e2e_pct, target_e2e])
+}
+
+default allow = false
+
+allow {
+	count(violations) == 0
+}

package/rulesets/opa/sdlc/pyramid-distribution.test.rego

@@ -0,0 +1,33 @@
+package evolith.sdlc.pyramid_test
+
+import data.evolith.sdlc.pyramid
+
+test_perfect_distribution_is_allowed {
+	pyramid.allow with input as {"unit_pct": 70, "integration_pct": 20, "e2e_pct": 10}
+}
+
+test_within_tolerance_is_allowed {
+	pyramid.allow with input as {"unit_pct": 75, "integration_pct": 15, "e2e_pct": 10}
+}
+
+test_at_tolerance_boundary_is_allowed {
+	pyramid.allow with input as {"unit_pct": 80, "integration_pct": 10, "e2e_pct": 10}
+}
+
+test_beyond_tolerance_is_not_allowed {
+	not pyramid.allow with input as {"unit_pct": 90, "integration_pct": 5, "e2e_pct": 5}
+}
+
+test_all_zero_is_not_allowed {
+	not pyramid.allow with input as {"unit_pct": 0, "integration_pct": 0, "e2e_pct": 0}
+}
+
+test_violations_produced_when_out_of_tolerance {
+	violations := pyramid.violations with input as {"unit_pct": 95, "integration_pct": 3, "e2e_pct": 2}
+	count(violations) > 0
+}
+
+test_no_violations_when_valid {
+	violations := pyramid.violations with input as {"unit_pct": 70, "integration_pct": 20, "e2e_pct": 10}
+	count(violations) == 0
+}

package/rulesets/opa/taxonomy.rego

@@ -0,0 +1,51 @@
+package evolith.taxonomy
+
+violations[{"id": "TAX-05", "message": msg}] {
+    expected := {"reference", "rulesets", "sdk", ".harness"}
+    actual := {dir | dir := input.core.directories[_]}
+    missing := expected - actual
+    count(missing) > 0
+    msg := sprintf("Missing top-level directories: %v", [concat(", ", missing)])
+}
+
+violations[{"id": "TAX-06", "message": msg}] {
+    input.satellitePath != input.corePath
+    input.satellite.packageJson != null
+    expected := {"src", "tests", "docs"}
+    actual := {dir | dir := input.satellite.directories[_]}
+    missing := expected - actual
+    count(missing) > 0
+    msg := sprintf("Satellite missing directories: %v", [concat(", ", missing)])
+}
+
+violations[{"id": "TAX-11", "message": "Root-level topologies/ is prohibited; topology content must stay inside approved corpus and ruleset locations unless a superseding ADR changes root taxonomy"}] {
+    dir := input.core.directories[_]
+    dir == "topologies"
+}
+
+is_valid_adr_name(name) {
+    regex.match(`^[0-9]{4}-[a-z0-9-]+\.md$`, name)
+}
+
+violations[{"id": "TAX-07", "message": msg}] {
+    adr := input.core.adrs[_]
+    name := split(adr, "/")[count(split(adr, "/")) - 1]
+    regex.match(`^[0-9]`, name)
+    not endswith(name, ".es.md")
+    not is_valid_adr_name(name)
+    msg := sprintf("ADR filenames not matching kebab-case pattern: %v", [name])
+}
+
+violations[{"id": "TAX-08", "message": msg}] {
+    adr := input.core.adrs[_]
+    name := split(adr, "/")[count(split(adr, "/")) - 1]
+    endswith(name, ".md")
+    not endswith(name, ".es.md")
+    es_name := replace(name, ".md", ".es.md")
+    
+    # Check if es_name exists in the list of adrs
+    adrs_set := {split(a, "/")[count(split(a, "/")) - 1] | a := input.core.adrs[_]}
+    not adrs_set[es_name]
+    
+    msg := sprintf("ADRs missing bilingual pair: %v", [name])
+}

package/rulesets/opa/taxonomy.test.rego

@@ -0,0 +1,28 @@
+package evolith.taxonomy_test
+
+import data.evolith.taxonomy
+
+test_core_with_all_required_dirs_has_no_violations {
+  violations := taxonomy.violations with input as {"core": {"directories": ["reference", "rulesets", "sdk", ".harness"], "adrs": ["0001-monorepo-orchestration-principle.md", "0001-monorepo-orchestration-principle.es.md"]}, "satellitePath": "/core", "satellite": {"directories": ["src", "tests", "docs"], "files": [], "packageJson": {}}}
+  count(violations) == 0
+}
+
+test_missing_top_level_dirs_is_rejected {
+  violations := taxonomy.violations with input as {"core": {"directories": ["reference", "sdk"], "adrs": []}, "satellitePath": "/core", "satellite": {"directories": [], "files": [], "packageJson": null}}
+  violations[_].id == "TAX-05"
+}
+
+test_satellite_missing_standard_dirs_is_rejected {
+  violations := taxonomy.violations with input as {"core": {"directories": ["reference", "rulesets", "sdk", ".harness"], "adrs": []}, "satellitePath": "/satellite", "corePath": "/core", "satellite": {"directories": ["src"], "files": [], "packageJson": {}}}
+  violations[_].id == "TAX-06"
+}
+
+test_root_topologies_dir_is_rejected {
+  violations := taxonomy.violations with input as {"core": {"directories": ["reference", "rulesets", "sdk", ".harness", "topologies"], "adrs": []}, "satellitePath": "/core", "satellite": {"directories": [], "files": [], "packageJson": null}}
+  violations[_].id == "TAX-11"
+}
+
+test_adr_missing_bilingual_pair_is_rejected {
+  violations := taxonomy.violations with input as {"core": {"directories": ["reference", "rulesets", "sdk", ".harness"], "adrs": ["0001-monorepo-orchestration-principle.md", "reference/architecture/adrs/core/0079-multi-topology-reference-corpus.md"]}, "satellitePath": "/core", "satellite": {"directories": [], "files": [], "packageJson": null}}
+  violations[_].id == "TAX-08"
+}

package/rulesets/opa/telemetry-evidence.rego

@@ -0,0 +1,102 @@
+package evolith.telemetry_evidence
+
+# ---------------------------------------------------------------------------
+# Native counterpart: rulesets/observability/telemetry-evidence.rules.json
+# ADR reference: ADR-0007 (Observability), ADR-0046 (Rollback Triggers)
+# Dual-Engine Parity: R-25
+#
+# Checks structural evidence of observability instrumentation in the satellite.
+# Runtime trace/log/metric content is verified by the Phase 5 gate evidence
+# (Observability Validation artifact). These OPA checks verify that the
+# required instrumentation packages are present in the satellite's dependencies.
+# ---------------------------------------------------------------------------
+
+import rego.v1
+
+# ---------------------------------------------------------------------------
+# Helpers: combined dependency map
+# ---------------------------------------------------------------------------
+
+all_deps[pkg] if {
+    input.satellite.packageJson.dependencies[pkg]
+}
+
+all_deps[pkg] if {
+    input.satellite.packageJson.devDependencies[pkg]
+}
+
+# ---------------------------------------------------------------------------
+# OBS-EVD-01: Production paths must emit distributed trace context
+# Satisfied by: @opentelemetry/* packages, DataDog (dd-trace), Elastic APM
+# ---------------------------------------------------------------------------
+
+has_tracing if {
+    some pkg in all_deps
+    startswith(pkg, "@opentelemetry/")
+}
+
+has_tracing if {
+    all_deps["dd-trace"]
+}
+
+has_tracing if {
+    all_deps["elastic-apm-node"]
+}
+
+violations contains {"id": "OBS-EVD-01", "message": "Production request paths must emit TraceId, SpanId, and CorrelationId. No distributed tracing package (@opentelemetry/*, dd-trace, elastic-apm-node) detected in satellite dependencies."} if {
+    not has_tracing
+}
+
+# ---------------------------------------------------------------------------
+# OBS-EVD-02: Structured logs must carry request correlation fields
+# Satisfied by: pino, winston, bunyan, or @nestjs/common (Logger)
+# ---------------------------------------------------------------------------
+
+has_structured_logging if {
+    all_deps["pino"]
+}
+
+has_structured_logging if {
+    all_deps["winston"]
+}
+
+has_structured_logging if {
+    all_deps["bunyan"]
+}
+
+has_structured_logging if {
+    all_deps["@nestjs/common"]
+}
+
+violations contains {"id": "OBS-EVD-02", "message": "Structured logs must include request correlation fields and avoid raw PII. No structured logging package (pino, winston, bunyan, @nestjs/common) detected in satellite dependencies."} if {
+    not has_structured_logging
+}
+
+# ---------------------------------------------------------------------------
+# OBS-EVD-03: Service health metrics must be reported
+# Satisfied by: prom-client or @opentelemetry/* (covers metrics API)
+# ---------------------------------------------------------------------------
+
+has_health_metrics if {
+    all_deps["prom-client"]
+}
+
+has_health_metrics if {
+    some pkg in all_deps
+    startswith(pkg, "@opentelemetry/")
+}
+
+violations contains {"id": "OBS-EVD-03", "message": "Production services must report error rate, latency percentile, throughput, and availability metrics. No metrics package (prom-client, @opentelemetry/*) detected in satellite dependencies."} if {
+    not has_health_metrics
+}
+
+# ---------------------------------------------------------------------------
+# OBS-EVD-04: Phase 5 gate evidence SHOULD reference an observability dashboard
+# Non-blocking — uses input.satellite.scorecards.observabilityOperational
+# which is populated by the OPA input builder when observability evidence
+# is present in the satellite's .harness/evidence directory.
+# ---------------------------------------------------------------------------
+
+violations contains {"id": "OBS-EVD-04", "message": "Phase 5 gate evidence SHOULD reference the dashboard or query used to verify nominal monitoring (observabilityOperational not declared in satellite scorecards)."} if {
+    not input.satellite.scorecards.observabilityOperational
+}

package/rulesets/opa/testing-pyramid.rego

@@ -0,0 +1,49 @@
+package evolith.testing_pyramid
+
+violations[{"id": "TPY-01", "message": "Test distribution does not follow 70/20/10 pyramid — unit tests below 65% or above 75%"}] {
+    input.satellite.testing.unitTestPercentage < 65
+}
+
+violations[{"id": "TPY-01", "message": "Test distribution does not follow 70/20/10 pyramid — integration tests below 15% or above 25%"}] {
+    input.satellite.testing.integrationTestPercentage < 15
+}
+
+violations[{"id": "TPY-01", "message": "Test distribution does not follow 70/20/10 pyramid — e2e tests below 5% or above 15%"}] {
+    input.satellite.testing.e2eTestPercentage < 5
+}
+
+violations[{"id": "TPY-02", "message": "Unit tests execute IO — must isolate pure core and application classes"}] {
+    input.satellite.testing.unitTestsExecuteIo
+}
+
+violations[{"id": "TPY-05", "message": "Business logic coverage below 80% threshold"}] {
+    input.satellite.testing.businessLogicCoverage < 80
+}
+
+violations[{"id": "TPY-06", "message": "Domain coverage below 95% threshold"}] {
+    input.satellite.testing.domainCoverage < 95
+}
+
+violations[{"id": "TPY-06", "message": "Application coverage below 85% threshold"}] {
+    input.satellite.testing.applicationCoverage < 85
+}
+
+violations[{"id": "TPY-06", "message": "Infrastructure coverage below 60% threshold"}] {
+    input.satellite.testing.infrastructureCoverage < 60
+}
+
+violations[{"id": "TPY-06", "message": "API/BFF coverage below 70% threshold"}] {
+    input.satellite.testing.apiCoverage < 70
+}
+
+violations[{"id": "TPY-03", "message": "Integration tests must use ephemeral containers (Docker/Testcontainers) — no shared persistent test databases allowed"}] {
+    not input.satellite.testing.integrationUsesEphemeralContainers
+}
+
+violations[{"id": "TPY-04", "message": "E2E tests must cover full HTTP routes — no E2E tests found against HTTP endpoints"}] {
+    not input.satellite.testing.e2eCoversHttpRoutes
+}
+
+violations[{"id": "TPY-07", "message": "Unit tests execute IO operations — must not use file system, network, or database"}] {
+    input.satellite.testing.unitTestsHaveIoOperations
+}

package/rulesets/opa/testing-pyramid.test.rego

@@ -0,0 +1,81 @@
+package evolith.testing_pyramid_test
+
+import data.evolith.testing_pyramid
+
+compliant_input := {"satellite": {"testing": {
+  "unitTestPercentage": 70,
+  "integrationTestPercentage": 20,
+  "e2eTestPercentage": 10,
+  "unitTestsExecuteIo": false,
+  "businessLogicCoverage": 85,
+  "domainCoverage": 96,
+  "applicationCoverage": 88,
+  "infrastructureCoverage": 65,
+  "apiCoverage": 75,
+  "unitTestsHaveIoOperations": false,
+}}}
+
+test_compliant_testing_pyramid_has_no_violations {
+  violations := testing_pyramid.violations with input as compliant_input
+  count(violations) == 0
+}
+
+test_low_unit_test_percentage_is_rejected {
+  i := json.patch(compliant_input, [{"op": "replace", "path": "/satellite/testing/unitTestPercentage", "value": 50}])
+  violations := testing_pyramid.violations with input as i
+  violations[_].id == "TPY-01"
+}
+
+test_low_integration_test_percentage_is_rejected {
+  i := json.patch(compliant_input, [{"op": "replace", "path": "/satellite/testing/integrationTestPercentage", "value": 10}])
+  violations := testing_pyramid.violations with input as i
+  violations[_].id == "TPY-01"
+}
+
+test_low_e2e_test_percentage_is_rejected {
+  i := json.patch(compliant_input, [{"op": "replace", "path": "/satellite/testing/e2eTestPercentage", "value": 2}])
+  violations := testing_pyramid.violations with input as i
+  violations[_].id == "TPY-01"
+}
+
+test_unit_tests_executing_io_is_rejected {
+  i := json.patch(compliant_input, [{"op": "replace", "path": "/satellite/testing/unitTestsExecuteIo", "value": true}])
+  violations := testing_pyramid.violations with input as i
+  violations[_].id == "TPY-02"
+}
+
+test_low_business_logic_coverage_is_rejected {
+  i := json.patch(compliant_input, [{"op": "replace", "path": "/satellite/testing/businessLogicCoverage", "value": 70}])
+  violations := testing_pyramid.violations with input as i
+  violations[_].id == "TPY-05"
+}
+
+test_low_domain_coverage_is_rejected {
+  i := json.patch(compliant_input, [{"op": "replace", "path": "/satellite/testing/domainCoverage", "value": 80}])
+  violations := testing_pyramid.violations with input as i
+  violations[_].id == "TPY-06"
+}
+
+test_low_application_coverage_is_rejected {
+  i := json.patch(compliant_input, [{"op": "replace", "path": "/satellite/testing/applicationCoverage", "value": 70}])
+  violations := testing_pyramid.violations with input as i
+  violations[_].id == "TPY-06"
+}
+
+test_low_infrastructure_coverage_is_rejected {
+  i := json.patch(compliant_input, [{"op": "replace", "path": "/satellite/testing/infrastructureCoverage", "value": 40}])
+  violations := testing_pyramid.violations with input as i
+  violations[_].id == "TPY-06"
+}
+
+test_low_api_coverage_is_rejected {
+  i := json.patch(compliant_input, [{"op": "replace", "path": "/satellite/testing/apiCoverage", "value": 50}])
+  violations := testing_pyramid.violations with input as i
+  violations[_].id == "TPY-06"
+}
+
+test_unit_tests_with_io_operations_is_rejected {
+  i := json.patch(compliant_input, [{"op": "replace", "path": "/satellite/testing/unitTestsHaveIoOperations", "value": true}])
+  violations := testing_pyramid.violations with input as i
+  violations[_].id == "TPY-07"
+}