From 9e9778af742cd1919e5f0462e15cf4ac7c41f7ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=94=D0=BC=D0=B8=D1=82=D1=80=D0=B8=D0=B9?= Date: Sat, 24 Oct 2026 06:33:00 +0500 Subject: [PATCH] Keep external network gates reproducible and check all registry rulesets --- services/coa-control-e2e/Cargo.lock | 2 +- .../tests/registry_rulesets.rs | 68 +++++++++++++++++++ 2 files changed, 69 insertions(+), 1 deletion(-) create mode 100644 services/coa-control-e2e/tests/registry_rulesets.rs diff --git a/services/coa-control-e2e/Cargo.lock b/services/coa-control-e2e/Cargo.lock index aaeeb7e..638ece8 100644 --- a/services/coa-control-e2e/Cargo.lock +++ b/services/coa-control-e2e/Cargo.lock @@ -356,7 +356,7 @@ dependencies = [ [[package]] name = "coa-core" -version = "0.7.3" +version = "0.8.0" dependencies = [ "base64 0.22.1", "chrono", diff --git a/services/coa-control-e2e/tests/registry_rulesets.rs b/services/coa-control-e2e/tests/registry_rulesets.rs new file mode 100644 index 0000000..7e8a10e --- /dev/null +++ b/services/coa-control-e2e/tests/registry_rulesets.rs @@ -0,0 +1,68 @@ +use coa_core::realm_registry::client::RegistryClient; +use coa_registry_proto::caps::*; +use coa_registry_proto::sign::encode_public_key; +use coa_registry_proto::*; +use ed25519_dalek::SigningKey; +use uuid::Uuid; + +fn now() -> i64 { + std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs() as i64 +} + +fn random_key() -> SigningKey { + let mut seed = [0u8; 32]; + seed[..16].copy_from_slice(Uuid::new_v4().as_bytes()); + seed[16..].copy_from_slice(Uuid::new_v4().as_bytes()); + SigningKey::from_bytes(&seed) +} + +fn base_url() -> Option { + std::env::var("REGISTRY_URL").ok().filter(|u| !u.is_empty()) +} + +fn sample_caps(max_level: u32) -> AdvertisedCapabilities { + let content = ContentProfile { + ruleset: Ruleset::Coa, + character_formats: CharacterFormats { readable: FormatRange { min: 1, max: 2 }, writable: FormatRange { min: 2, max: 2 } }, + online_import_job_formats: vec![2], + session_protocol: 2, + collection_protocol: 1, + features: [Feature::RuntimeSessions, Feature::Wardrobe, Feature::LevelProjection].into_iter().collect(), + collection_kinds: ["coa:appearance".to_string()].into_iter().collect(), + extensions: vec![ExtensionSupport { namespace: "coa".into(), module_version: "1".into(), formats: FormatRange { min: 1, max: 1 } }], + client_catalog: [("Appearances.dbc".to_string(), CatalogEntry { sha256: "a".repeat(64), records: 5 })].into_iter().collect(), + }; + let content_profile_hash = content.hash(); + AdvertisedCapabilities { + profile_version: 2, + core: Some(CoreIdentity { commit: "abc123".into(), branch: "main".into(), date: "2026-10-01".into() }), + content, + content_profile_hash, + progression: Some(Progression { max_player_level: max_level, projection_protocol: 1, projection_policy_version: 1, progression_signature: "b".repeat(64), scaling_enabled: false }), + } +} + +#[test] +#[ignore = "Uses temporary public Registry entries, removed after each assertion"] +fn registry_accepts_all_three_rulesets() { + let base = base_url().expect("REGISTRY_URL"); + let client = RegistryClient::new(&base).unwrap(); + for ruleset in [Ruleset::Coa, Ruleset::Wildcard, Ruleset::Reborn] { + let realm = RealmId::new(); + let key = random_key(); + let mut caps = sample_caps(80); + caps.content.ruleset = ruleset; + caps.content.features.clear(); + caps.content.collection_kinds.clear(); + caps.content.extensions.clear(); + caps.content.client_catalog.clear(); + caps.content_profile_hash = caps.content.hash(); + caps.progression = None; + let listing = Listing { display_name: "Candidate Ruleset Gate".into(), description: "Temporary compatibility test".into(), language: "en".into(), region: None, rates: Rates::default(), modules: vec![], account_provisioning: AccountProvisioning { automatic: false, existing_only: true }, manager_version: "0.8.0".into() }; + let req = RegisterRequest { protocol_version: REGISTRY_PROTOCOL_VERSION, realm_id: realm, public_key: encode_public_key(&key.verifying_key()), listing_hash: listing.hash(), listing, capabilities_hash: caps.advert_hash(), capabilities: caps, population: Population { players: 0, bots: 0, capacity: None } }; + let result = client.register(&key, &req, now()); + if result.is_ok() { client.unpublish(&key, &realm, now()+1).unwrap(); } + assert!(result.is_ok(), "Registry rejected {ruleset:?}: {result:?}"); + println!("Public Registry accepted and removed {ruleset:?} test realm"); + } +}