mirror of
https://github.com/kevinveenbirkenbach/computer-playbook.git
synced 2026-11-06 10:59:59 +00:00
kevinveenbirkenbachandClaude Opus 5
7162b7bf4c
834 commits from the Tor onion-service branch against 299 of ours, from merge base7b646bdece: 127 conflicted files, 3506 files changed. The two sides are largely orthogonal. Theirs adds svc-net-tor and a `tor` service across the role tree, plus two sweeping refactors: shipped scripts sorted by language (files/ruby/, files/python/, files/shell/, scripts/lint/*.sh) and the unit suite moved under tests/unit/python/. Ours is requirement 036, the native AI gateway, plus the MCP role work. Most conflicts were both sides appending to the same service map, resolved as unions. Resolutions that were not unions: Credentials moved namespace. Theirs renamed meta/schema.yml to meta/secrets.yml and re-addressed credentials as secrets.credentials.<name>. Git carried our litellm_api_key blocks through the rename, but every consumer we added still read 'credentials.<name>', which no longer resolves. All 45 call sites are migrated. plugins/filter/container_volumes.py is deleted by theirs and relocated to plugins/lookup/container_volumes.py, where it carries the same tmpfs defect ourf85996b43had just fixed: a hard-coded {"size": ...} that silently drops a per mount `mode`. The fix is re-applied in the relocated file, as that commit's merge note anticipated. compose.yml keeps only INFINITO_PLAYWRIGHT_REPORTS_BASE_DIR. Theirs also forwards INFINITO_PLAYWRIGHT_STAGE_BASE_DIR; that line is deliberately dropped, per the analysis recorded in45804e9ad-- STAGE has a drift-proof role-vars fallback, while forwarding it promotes a setdefault-pinnable .env value above that SPOT. tasks/stages/01_constructor.yml takes their include, ./tasks/utils/setup/group.yml, because their refactor removed tasks/groups/*-roles.yml, leaving our include target nonexistent. Our task name is kept, since svc-virt is in the loop. Makefile swarm-zombie is a union: their validate plus teardown, then our lab_subnet cleanup, which their side dropped while leaving lab_subnet.sh as the only orphaned reference in the file. 01_bootstrap.sh keeps our deterministic --ip pinning, which distinguishes an already-attached node from a real failure, over their `|| true`. Their language-sorted layout orphaned references our side still held: zammad's two scripts/apply/*.rb, jenkins' java-with-ca-trust.sh, and the notify topics their handlers renamed to hyphenated form. All corrected. roles/sys-svc-compose/files/shell/swarm/stack_ready.sh gains our latched-update block: paused, rollback_paused, rollback_started and rollback_completed exit 2 rather than polling a state that cannot resolve without another deploy. config_from_run is unioned to (title, logged, jobs); the production caller in trigger/__main__.py now passes jobs, without which our suite suppression would have been inert. READMEs are regenerated rather than hand-merged: 15 LiteLLM rows and 91 Tor rows now derive from the merged metadata, which is itself evidence the meta merge is coherent. Verified: 5161 unit tests pass. The single failure, test_query.py TestSortSpec, also fails on fork/feature/svc-net-tor atb51d2f9919, measured in a baseline worktree -- so this merge introduces no new unit-test failure. Two modules are excluded from that run because `baudolo`, a dependency their branch introduces, is not installed on this host. Not verified: no deploy has run against the merged tree, and make quality has not been run end to end here. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
117 lines
4.1 KiB
Python
117 lines
4.1 KiB
Python
import base64
|
|
import re
|
|
import unittest
|
|
|
|
from cryptography.hazmat.primitives.asymmetric import ec, rsa
|
|
from cryptography.hazmat.primitives.serialization import (
|
|
Encoding,
|
|
PublicFormat,
|
|
load_pem_private_key,
|
|
)
|
|
|
|
from utils.manager.value_generator import ValueGenerator
|
|
|
|
|
|
def _b64url_decode(value: str) -> bytes:
|
|
return base64.urlsafe_b64decode(value + "=" * (-len(value) % 4))
|
|
|
|
|
|
class TestValueGenerator(unittest.TestCase):
|
|
def setUp(self):
|
|
self.vg = ValueGenerator()
|
|
|
|
def test_generate_secure_alphanumeric(self):
|
|
s = self.vg.generate_secure_alphanumeric(64)
|
|
self.assertEqual(len(s), 64)
|
|
self.assertTrue(re.fullmatch(r"[A-Za-z0-9]{64}", s))
|
|
|
|
def test_generate_value_random_hex(self):
|
|
v = self.vg.generate_value("random_hex")
|
|
self.assertTrue(re.fullmatch(r"[0-9a-f]{128}", v))
|
|
|
|
def test_generate_value_random_hex_32(self):
|
|
v = self.vg.generate_value("random_hex_32")
|
|
self.assertTrue(re.fullmatch(r"[0-9a-f]{64}", v))
|
|
|
|
def test_generate_value_random_hex_16(self):
|
|
v = self.vg.generate_value("random_hex_16")
|
|
self.assertTrue(re.fullmatch(r"[0-9a-f]{32}", v))
|
|
|
|
def test_generate_value_sha256(self):
|
|
v = self.vg.generate_value("sha256")
|
|
self.assertTrue(re.fullmatch(r"[0-9a-f]{64}", v))
|
|
|
|
def test_generate_value_sha1(self):
|
|
v = self.vg.generate_value("sha1")
|
|
self.assertTrue(re.fullmatch(r"[0-9a-f]{40}", v))
|
|
|
|
def test_generate_value_sk_prefixed(self):
|
|
v = self.vg.generate_value("sk_prefixed")
|
|
self.assertTrue(v.startswith("sk-"))
|
|
self.assertTrue(re.fullmatch(r"[A-Za-z0-9]{48}", v.split("sk-", 1)[1]))
|
|
|
|
def test_generate_value_base64_prefixed_32(self):
|
|
v = self.vg.generate_value("base64_prefixed_32")
|
|
self.assertTrue(v.startswith("base64:"))
|
|
raw = v.split("base64:", 1)[1].encode()
|
|
decoded = base64.b64decode(raw)
|
|
self.assertEqual(len(decoded), 32)
|
|
|
|
def test_generate_value_alphanumeric(self):
|
|
v = self.vg.generate_value("alphanumeric")
|
|
self.assertEqual(len(v), 64)
|
|
self.assertTrue(re.fullmatch(r"[A-Za-z0-9]{64}", v))
|
|
|
|
def test_generate_value_bcrypt(self):
|
|
v = self.vg.generate_value("bcrypt")
|
|
self.assertNotIn("$", v)
|
|
self.assertGreater(len(v), 20)
|
|
|
|
def test_generate_value_unknown(self):
|
|
v = self.vg.generate_value("does_not_exist")
|
|
self.assertEqual(v, "undefined")
|
|
|
|
def test_generate_value_vapid_private(self):
|
|
v = self.vg.generate_value("vapid_private")
|
|
self.assertTrue(re.fullmatch(r"[-_A-Za-z0-9]{43}", v))
|
|
self.assertEqual(len(_b64url_decode(v)), 32)
|
|
|
|
def test_generate_value_vapid_public(self):
|
|
v = self.vg.generate_value("vapid_public")
|
|
self.assertTrue(re.fullmatch(r"[-_A-Za-z0-9]{87}", v))
|
|
point = _b64url_decode(v)
|
|
self.assertEqual(len(point), 65)
|
|
self.assertEqual(point[0], 0x04)
|
|
|
|
def test_generate_value_rsa_pem_2048(self):
|
|
v = self.vg.generate_value("rsa_pem_2048")
|
|
self.assertTrue(v.startswith("-----BEGIN RSA PRIVATE KEY-----"))
|
|
self.assertTrue(v.rstrip().endswith("-----END RSA PRIVATE KEY-----"))
|
|
key = load_pem_private_key(v.encode(), password=None)
|
|
self.assertIsInstance(key, rsa.RSAPrivateKey)
|
|
self.assertEqual(key.key_size, 2048)
|
|
|
|
def test_generate_value_rsa_pem_2048_is_not_cached(self):
|
|
self.assertNotEqual(
|
|
self.vg.generate_value("rsa_pem_2048"),
|
|
self.vg.generate_value("rsa_pem_2048"),
|
|
)
|
|
|
|
def test_vapid_keypair_is_cached(self):
|
|
self.assertEqual(
|
|
self.vg.generate_vapid_keypair(), self.vg.generate_vapid_keypair()
|
|
)
|
|
|
|
def test_vapid_private_and_public_are_linked(self):
|
|
private, public = self.vg.generate_vapid_keypair()
|
|
scalar = int.from_bytes(_b64url_decode(private), "big")
|
|
derived = ec.derive_private_key(scalar, ec.SECP256R1())
|
|
expected_point = derived.public_key().public_bytes(
|
|
Encoding.X962, PublicFormat.UncompressedPoint
|
|
)
|
|
self.assertEqual(_b64url_decode(public), expected_point)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|