158 lines
9.1 KiB
Python

"""Offline contract tests for the internal test environment renderer."""
import copy
import os
import subprocess
import unittest
from scripts.internal_test_lane.environment import render_environment, render_initializer, validate_config
def config():
pair = {"requests": {"cpu": "100m", "memory": "128Mi"}, "limits": {"cpu": "500m", "memory": "512Mi"}}
return {
"schemaVersion": 1,
"batchId": "acceptance-1",
"hostname": "test.example.test",
"productionOrigins": ["http://120.48.180.80", "https://prod.example.test"],
"image": "registry.example.test/droboticflow/api@sha256:" + "a" * 64,
"mongoImage": "registry.example.test/mongo@sha256:" + "b" * 64,
"buildCommit": "c" * 40,
"workspaceGi": 10,
"mongoGi": 5,
"resources": {name: copy.deepcopy(pair) for name in ("api", "processor", "mongo")},
"tlsSecretName": "internal-test-tls",
"imagePullSecretName": "internal-test-registry",
"ingressNamespace": "ingress-nginx",
}
class EnvironmentTests(unittest.TestCase):
def test_rendered_batch_uses_dedicated_database_and_retained_pvcs(self):
rendered = render_environment(config())
self.assertEqual(rendered["kind"], "List")
items = rendered["items"]
pvc_names = {x["metadata"]["name"] for x in items if x["kind"] == "PersistentVolumeClaim"}
self.assertEqual(pvc_names, {"internal-test-acceptance-1-workspace", "internal-test-acceptance-1-mongo-data"})
cfg = next(x for x in items if x["kind"] == "ConfigMap" and x["metadata"]["name"] == "internal-test-acceptance-1-config")
self.assertEqual(cfg["data"]["MONGO_DB"], "droboticflow_internal_test_acceptance_1")
self.assertEqual(cfg["data"]["ANNOTATION_PROCESSOR_MODE"], "external")
self.assertEqual(cfg["data"]["DROBOTICFLOW_REQUIRE_SESSION_AUTH"], "true")
deployments = {x["metadata"]["name"]: x for x in items if x["kind"] == "Deployment"}
self.assertEqual(deployments["internal-test-acceptance-1-mongo"]["spec"]["replicas"], 1)
self.assertEqual(deployments["internal-test-acceptance-1-api"]["spec"]["replicas"], 0)
self.assertEqual(deployments["internal-test-acceptance-1-processor"]["spec"]["replicas"], 0)
mongo_pod = deployments["internal-test-acceptance-1-mongo"]["spec"]["template"]["spec"]
mongo_env = mongo_pod["containers"][0]["env"]
refs = {entry["name"]: entry["valueFrom"]["secretKeyRef"]["key"] for entry in mongo_env if "valueFrom" in entry}
self.assertEqual(refs, {
"MONGO_INITDB_ROOT_USERNAME": "MONGO_ROOT_USERNAME",
"MONGO_INITDB_ROOT_PASSWORD": "MONGO_ROOT_PASSWORD",
"MONGO_APP_USERNAME": "MONGO_APP_USERNAME",
"MONGO_APP_PASSWORD": "MONGO_APP_PASSWORD",
})
self.assertEqual(mongo_pod["securityContext"]["runAsUser"], 999)
self.assertEqual(mongo_pod["securityContext"]["fsGroup"], 999)
self.assertTrue(mongo_pod["securityContext"]["runAsNonRoot"])
def test_initializer_is_a_separate_ephemeral_pod_with_only_test_scope(self):
manifest = render_environment(config())
self.assertFalse(any(x["kind"] == "Pod" for x in manifest["items"]))
initializer = render_initializer(config())
self.assertEqual(initializer["kind"], "Pod")
self.assertEqual(initializer["metadata"]["name"], "internal-test-acceptance-1-initializer")
pod = initializer["spec"]
self.assertFalse(pod["automountServiceAccountToken"])
self.assertEqual(pod["restartPolicy"], "Never")
self.assertEqual(pod["volumes"][0]["persistentVolumeClaim"]["claimName"],
"internal-test-acceptance-1-workspace")
refs = {x["name"]: x["valueFrom"]["secretKeyRef"] for x in pod["containers"][0]["env"] if "valueFrom" in x}
self.assertEqual(refs, {"MONGO_URI": {"name": "internal-test-acceptance-1-credentials", "key": "MONGO_URI"}})
def test_validation_rejects_a_production_or_ip_hostname(self):
for hostname in ("prod.example.test", "120.48.180.80", "localhost"):
candidate = config()
candidate["hostname"] = hostname
with self.subTest(hostname=hostname), self.assertRaises(ValueError):
validate_config(candidate)
def test_quota_allows_three_retained_batches_and_one_active(self):
c = config()
quota = next(x for x in render_environment(c)["items"] if x["kind"] == "ResourceQuota")["spec"]["hard"]
self.assertEqual(quota["persistentvolumeclaims"], "8")
self.assertEqual(quota["requests.storage"], f"{4 * (c['workspaceGi'] + c['mongoGi'])}Gi")
def test_namespace_quota_is_replaced_across_batches(self):
first = next(x for x in render_environment(config())["items"] if x["kind"] == "ResourceQuota")
later = config()
later["batchId"] = "acceptance-2"
second = next(x for x in render_environment(later)["items"] if x["kind"] == "ResourceQuota")
self.assertEqual(first["metadata"]["name"], "internal-test-quota")
self.assertEqual(second["metadata"]["name"], first["metadata"]["name"])
self.assertEqual(first["metadata"]["namespace"], second["metadata"]["namespace"])
def test_runtime_has_only_batch_scoped_secret_refs_and_no_cluster_credential(self):
items = render_environment(config())["items"]
deployments = {x["metadata"]["name"]: x for x in items if x["kind"] == "Deployment"}
for component in ("api", "processor"):
pod = deployments[f"internal-test-acceptance-1-{component}"]["spec"]["template"]["spec"]
self.assertFalse(pod["automountServiceAccountToken"])
environment = pod["containers"][0]["env"]
refs = {item["name"]: item["valueFrom"]["secretKeyRef"] for item in environment if "valueFrom" in item}
self.assertEqual(refs["MONGO_URI"]["name"], "internal-test-acceptance-1-credentials")
self.assertNotIn("MONGO_ROOT_PASSWORD", refs)
self.assertNotIn("MONGO_APP_PASSWORD", refs)
self.assertEqual([part["name"] for part in pod["initContainers"]],
["validate-mongo-target", "wait-for-seed"])
gate = pod["initContainers"][1]
self.assertIn("_internalTestSeed", gate["command"][-1])
self.assertIn("state: 'complete'", gate["command"][-1])
self.assertFalse(any(x["kind"] in ("RoleBinding", "ClusterRoleBinding", "Secret") for x in items))
def test_workspace_is_shareable_and_network_denies_unapproved_egress(self):
items = render_environment(config())["items"]
workspace = next(x for x in items if x["kind"] == "PersistentVolumeClaim" and x["metadata"]["name"].endswith("-workspace"))
self.assertEqual(workspace["spec"]["accessModes"], ["ReadWriteMany"])
policies = {x["metadata"]["name"]: x["spec"] for x in items if x["kind"] == "NetworkPolicy"}
self.assertEqual(policies["internal-test-acceptance-1-default-deny"]["policyTypes"], ["Ingress", "Egress"])
self.assertEqual(len(policies["internal-test-acceptance-1-allow-app-egress"]["egress"]), 2)
first_pod = next(i for i, item in enumerate(items) if item["kind"] == "Deployment")
self.assertLess(max(i for i, item in enumerate(items) if item["kind"] == "NetworkPolicy"), first_pod)
def test_startup_guard_rejects_secret_uri_outside_batch_database(self):
items = render_environment(config())["items"]
api = next(x for x in items if x["kind"] == "Deployment" and x["metadata"]["name"].endswith("-api"))
guard = api["spec"]["template"]["spec"]["initContainers"][0]
suffix = next(item["value"] for item in guard["env"] if item["name"] == "EXPECTED_URI_SUFFIX")
def guard_accepts(uri):
run = subprocess.run(guard["command"], env={**os.environ, "MONGO_URI": uri, "EXPECTED_URI_SUFFIX": suffix},
capture_output=True, text=True, check=False)
return run.returncode == 0
self.assertTrue(guard_accepts("mongodb://tester:encoded-secret" + suffix))
self.assertFalse(guard_accepts("mongodb://tester:secret@prod.example.test:27017/droboticflow"))
self.assertFalse(guard_accepts("mongodb://tester:secret@prod.example.test:27017/other@" + suffix[1:]))
def test_processor_can_use_bounded_eight_gibibytes_without_raising_api_cap(self):
candidate = config()
candidate["resources"]["processor"]["limits"] = {"cpu": "4", "memory": "8Gi"}
self.assertEqual(validate_config(candidate)["resources"]["processor"]["limits"]["memory"], "8Gi")
candidate["resources"]["api"]["limits"]["memory"] = "8Gi"
with self.assertRaises(ValueError):
validate_config(candidate)
def test_forged_derived_names_and_aliases_are_rejected(self):
forged = config()
forged["databaseName"] = "customer_database"
with self.assertRaises(ValueError):
validate_config(forged)
aliased = config()
aliased["mongoUri"] = "mongodb://customer.example.test"
with self.assertRaises(ValueError):
validate_config(aliased)
if __name__ == "__main__":
unittest.main()