forked from longtao.wu/droboticflow
158 lines
9.1 KiB
Python
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()
|