Dataset Preview
The full dataset viewer is not available (click to read why). Only showing a preview of the rows.
The dataset generation failed
Error code: DatasetGenerationError
Exception: CastError
Message: Couldn't cast
id: string
input: string
instruction: string
output: string
source_id: string
task: string
source_test_id: string
to
{'id': Value('string'), 'input': Value('string'), 'instruction': Value('string'), 'output': Value('string'), 'source_test_id': Value('string'), 'task': Value('string')}
because column names don't match
Traceback: Traceback (most recent call last):
File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1827, in _prepare_split_single
for key, table in generator:
^^^^^^^^^
File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 613, in wrapped
for item in generator(*args, **kwargs):
~~~~~~~~~^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 343, in _generate_tables
self._cast_table(pa_table, json_field_paths=json_field_paths),
~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 132, in _cast_table
pa_table = table_cast(pa_table, self.info.features.arrow_schema)
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2378, in table_cast
return cast_table_to_schema(table, schema)
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2306, in cast_table_to_schema
raise CastError(
...<3 lines>...
)
datasets.table.CastError: Couldn't cast
id: string
input: string
instruction: string
output: string
source_id: string
task: string
source_test_id: string
to
{'id': Value('string'), 'input': Value('string'), 'instruction': Value('string'), 'output': Value('string'), 'source_test_id': Value('string'), 'task': Value('string')}
because column names don't match
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 1369, in compute_config_parquet_and_info_response
parquet_operations, partial, estimated_dataset_info = stream_convert_to_parquet(
~~~~~~~~~~~~~~~~~~~~~~~~~^
builder, max_dataset_size_bytes=max_dataset_size_bytes
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
)
^
File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 948, in stream_convert_to_parquet
builder._prepare_split(split_generator=splits_generators[split], file_format="parquet")
~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1694, in _prepare_split
for job_id, done, content in self._prepare_split_single(
~~~~~~~~~~~~~~~~~~~~~~~~~~^
gen_kwargs=gen_kwargs, job_id=job_id, **_prepare_split_args
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
):
^
File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1880, in _prepare_split_single
raise DatasetGenerationError("An error occurred while generating the dataset") from e
datasets.exceptions.DatasetGenerationError: An error occurred while generating the datasetNeed help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.
id string | input string | instruction string | output string | source_test_id string | task string |
|---|---|---|---|---|---|
cp-auth::account_store_authenticates_and_persists_encrypted::explain_behavior |
#[test]
fn account_store_authenticates_and_persists_encrypted() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("accounts")?;
let mut store = AccountStore::open(&dir, &key())?;
let account = store.create(create_owner(
"[REDACTED_EMAIL]",
"correct horse battery staple",
))... | Explain what the Rust test `account_store_authenticates_and_persists_encrypted` verifies. | The test `account_store_authenticates_and_persists_encrypted` verifies account store authenticates and persists encrypted. It belongs to cp-auth and covers domains: auth. Observed statuses: none; error codes: none; assertions: 5. | cp-auth::account_store_authenticates_and_persists_encrypted | behavior_explanation |
cp-auth::wrong_password_is_rejected::explain_behavior |
#[test]
fn wrong_password_is_rejected() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("wrong-password")?;
let mut store = AccountStore::open(&dir, &key())?;
store.create(create_owner("owner", "correct horse battery staple"))?;
assert!(
store
.authenticate("owner", "... | Explain what the Rust test `wrong_password_is_rejected` verifies. | The test `wrong_password_is_rejected` verifies wrong password is rejected. It belongs to cp-auth and covers domains: auth. Observed statuses: none; error codes: none; assertions: 1. | cp-auth::wrong_password_is_rejected | behavior_explanation |
cp-auth::disabled_account_is_rejected::explain_behavior |
#[test]
fn disabled_account_is_rejected() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("disabled-account")?;
let mut store = AccountStore::open(&dir, &key())?;
let account = store.create(create_owner("owner", "correct horse battery staple"))?;
store.disable(&account.account_id)?;
... | Explain what the Rust test `disabled_account_is_rejected` verifies. | The test `disabled_account_is_rejected` verifies disabled account is rejected. It belongs to cp-auth and covers domains: auth. Observed statuses: none; error codes: none; assertions: 1. | cp-auth::disabled_account_is_rejected | behavior_explanation |
cp-auth::session_create_verify_refresh_and_revoke::explain_behavior |
#[test]
fn session_create_verify_refresh_and_revoke() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("sessions")?;
let mut accounts = AccountStore::open(&dir, &key())?;
let account = accounts.create(create_owner("owner", "correct horse battery staple"))?;
let mut sessions = SessionStore... | Explain what the Rust test `session_create_verify_refresh_and_revoke` verifies. | The test `session_create_verify_refresh_and_revoke` verifies session create verify refresh and revoke. It belongs to cp-auth and covers domains: auth. Observed statuses: none; error codes: none; assertions: 6. | cp-auth::session_create_verify_refresh_and_revoke | behavior_explanation |
cp-auth::local_auth_still_works_without_idp::explain_behavior |
#[test]
fn local_auth_still_works_without_idp() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("local-without-idp")?;
let mut accounts = AccountStore::open(&dir, &key())?;
accounts.create(create_owner("owner", "correct horse battery staple"))?;
let authed = accounts.authenticate("owner"... | Explain what the Rust test `local_auth_still_works_without_idp` verifies. | The test `local_auth_still_works_without_idp` verifies local auth still works without idp. It belongs to cp-auth and covers domains: auth. Observed statuses: none; error codes: none; assertions: 2. | cp-auth::local_auth_still_works_without_idp | behavior_explanation |
cp-auth::oidc_claims_map_to_workspace_role::explain_behavior |
#[test]
fn oidc_claims_map_to_workspace_role() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("oidc")?;
let mut store = EnterpriseAuthStore::open(&dir, &key())?;
store.upsert_oidc_provider(OidcProviderConfig {
provider_id: "okta".to_owned(),
issuer: "https://idp.example.test... | Explain what the Rust test `oidc_claims_map_to_workspace_role` verifies. | The test `oidc_claims_map_to_workspace_role` verifies oidc claims map to workspace role. It belongs to cp-auth and covers domains: auth. Observed statuses: none; error codes: none; assertions: 2. | cp-auth::oidc_claims_map_to_workspace_role | behavior_explanation |
cp-auth::saml_subject_maps_to_account::explain_behavior |
#[test]
fn saml_subject_maps_to_account() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("saml")?;
let mut accounts = AccountStore::open(&dir, &key())?;
let account = accounts.create(create_owner("owner", "correct horse battery staple"))?;
let mut store = EnterpriseAuthStore::open(&dir,... | Explain what the Rust test `saml_subject_maps_to_account` verifies. | The test `saml_subject_maps_to_account` verifies saml subject maps to account. It belongs to cp-auth and covers domains: auth. Observed statuses: none; error codes: none; assertions: 1. | cp-auth::saml_subject_maps_to_account | behavior_explanation |
cp-auth::mfa_required_account_gets_challenge::explain_behavior |
#[test]
fn mfa_required_account_gets_challenge() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("mfa")?;
let mut accounts = AccountStore::open(&dir, &key())?;
let account = accounts.create(create_owner("owner", "correct horse battery staple"))?;
let mut store = EnterpriseAuthStore::open... | Explain what the Rust test `mfa_required_account_gets_challenge` verifies. | The test `mfa_required_account_gets_challenge` verifies mfa required account gets challenge. It belongs to cp-auth and covers domains: auth. Observed statuses: none; error codes: none; assertions: 3. | cp-auth::mfa_required_account_gets_challenge | behavior_explanation |
cp-auth::revoked_session_rejected_on_all_nodes::explain_behavior |
#[test]
fn revoked_session_rejected_on_all_nodes() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("revoked-cross-node")?;
let mut accounts = AccountStore::open(&dir, &key())?;
let account = accounts.create(create_owner("owner", "correct horse battery staple"))?;
let mut node_a_sessions ... | Explain what the Rust test `revoked_session_rejected_on_all_nodes` verifies. | The test `revoked_session_rejected_on_all_nodes` verifies revoked session rejected on all nodes. It belongs to cp-auth and covers domains: auth. Observed statuses: none; error codes: none; assertions: 2. | cp-auth::revoked_session_rejected_on_all_nodes | behavior_explanation |
cp-auth::service_account_key_authenticates_and_rotates::explain_behavior |
#[test]
fn service_account_key_authenticates_and_rotates() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("service")?;
let mut store = ServiceAccountStore::open(&dir, &key())?;
let (account, key_one) = store.create(CreateServiceAccountRequest {
display_name: "CI".to_owned(),
... | Explain what the Rust test `service_account_key_authenticates_and_rotates` verifies. | The test `service_account_key_authenticates_and_rotates` verifies service account key authenticates and rotates. It belongs to cp-auth and covers domains: auth, backup. Observed statuses: none; error codes: none; assertions: 5. | cp-auth::service_account_key_authenticates_and_rotates | behavior_explanation |
cp-auth::service_account_scope_enforced::explain_behavior |
#[test]
fn service_account_scope_enforced() -> Result<(), Box<dyn std::error::Error>> {
let dir = temp_dir("service-scope")?;
let mut store = ServiceAccountStore::open(&dir, &key())?;
let (_, api_key) = store.create(CreateServiceAccountRequest {
display_name: "Backup".to_owned(),
org_id: Or... | Explain what the Rust test `service_account_scope_enforced` verifies. | The test `service_account_scope_enforced` verifies service account scope enforced. It belongs to cp-auth and covers domains: auth, backup. Observed statuses: none; error codes: none; assertions: 2. | cp-auth::service_account_scope_enforced | behavior_explanation |
cp-backup::key_round_trips_hex::explain_behavior |
#[test]
fn key_round_trips_hex() -> Result<(), Box<dyn std::error::Error>> {
let key = BackupKeyMaterial::new([7; 32], [9; 12]);
assert_eq!(BackupKeyMaterial::from_hex(&key.to_hex())?, key);
Ok(())
} | Explain what the Rust test `key_round_trips_hex` verifies. | The test `key_round_trips_hex` verifies key round trips hex. It belongs to cp-backup and covers domains: backup. Observed statuses: none; error codes: none; assertions: 1. | cp-backup::key_round_trips_hex | behavior_explanation |
cp-backup::export_and_verify_roundtrip::explain_behavior |
#[test]
fn export_and_verify_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
let bus_path = temp_path("roundtrip-bus", "jsonl")?;
let backup_path = temp_path("roundtrip-backup", "cpb")?;
let bus = bus_with_records(&bus_path)?;
let manifest = export_event_stream(&bus, &backup_path, &key(), iden... | Explain what the Rust test `export_and_verify_roundtrip` verifies. | The test `export_and_verify_roundtrip` verifies export and verify roundtrip. It belongs to cp-backup and covers domains: backup, event. Observed statuses: none; error codes: none; assertions: 5. | cp-backup::export_and_verify_roundtrip | behavior_explanation |
cp-backup::verify_detects_tampered_record::explain_behavior |
#[test]
fn verify_detects_tampered_record() -> Result<(), Box<dyn std::error::Error>> {
let bus_path = temp_path("tamper-bus", "jsonl")?;
let backup_path = temp_path("tamper-backup", "cpb")?;
let bus = bus_with_records(&bus_path)?;
export_event_stream(&bus, &backup_path, &key(), identity()?)?;
let ... | Explain what the Rust test `verify_detects_tampered_record` verifies. | The test `verify_detects_tampered_record` verifies verify detects tampered record. It belongs to cp-backup and covers domains: backup, event. Observed statuses: none; error codes: none; assertions: 1. | cp-backup::verify_detects_tampered_record | behavior_explanation |
cp-backup::restore_reproduces_bus::explain_behavior |
#[test]
fn restore_reproduces_bus() -> Result<(), Box<dyn std::error::Error>> {
let bus_path = temp_path("restore-source", "jsonl")?;
let backup_path = temp_path("restore-backup", "cpb")?;
let restore_path = temp_path("restore-dest", "jsonl")?;
let bus = bus_with_records(&bus_path)?;
export_event_s... | Explain what the Rust test `restore_reproduces_bus` verifies. | The test `restore_reproduces_bus` verifies restore reproduces bus. It belongs to cp-backup and covers domains: backup, event. Observed statuses: none; error codes: none; assertions: 3. | cp-backup::restore_reproduces_bus | behavior_explanation |
cp-backup::restore_refuses_invalid_backup::explain_behavior |
#[test]
fn restore_refuses_invalid_backup() -> Result<(), Box<dyn std::error::Error>> {
let bus_path = temp_path("restore-refuse-source", "jsonl")?;
let backup_path = temp_path("restore-refuse-backup", "cpb")?;
let restore_path = temp_path("restore-refuse-dest", "jsonl")?;
let bus = bus_with_records(&b... | Explain what the Rust test `restore_refuses_invalid_backup` verifies. | The test `restore_refuses_invalid_backup` verifies restore refuses invalid backup. It belongs to cp-backup and covers domains: backup, event. Observed statuses: none; error codes: none; assertions: 2. | cp-backup::restore_refuses_invalid_backup | behavior_explanation |
cp-backup::rebuild_projections_reports_count::explain_behavior |
#[test]
fn rebuild_projections_reports_count() -> Result<(), Box<dyn std::error::Error>> {
let bus_path = temp_path("projection-source", "jsonl")?;
let bus = bus_with_records(&bus_path)?;
let report = rebuild_projections(&bus)?;
assert_eq!(report.replayed_records, 2);
assert!(report.chain_verified... | Explain what the Rust test `rebuild_projections_reports_count` verifies. | The test `rebuild_projections_reports_count` verifies rebuild projections reports count. It belongs to cp-backup and covers domains: backup. Observed statuses: none; error codes: none; assertions: 2. | cp-backup::rebuild_projections_reports_count | behavior_explanation |
cp-bench::bench_report_meets_minimum_targets::explain_behavior |
#[test]
fn bench_report_meets_minimum_targets() -> Result<()> {
let report = run_benchmark(&BenchConfig::ci(unique_output_dir("report")))?;
assert!(report.passed);
assert!(report_meets_minimum_targets(&report));
Ok(())
} | Explain what the Rust test `bench_report_meets_minimum_targets` verifies. | The test `bench_report_meets_minimum_targets` verifies bench report meets minimum targets. It belongs to cp-bench and covers domains: general. Observed statuses: none; error codes: none; assertions: 2. | cp-bench::bench_report_meets_minimum_targets | behavior_explanation |
cp-bench::soak_test_preserves_hash_chain::explain_behavior |
#[test]
fn soak_test_preserves_hash_chain() -> Result<()> {
let dir = unique_output_dir("soak");
fs::create_dir_all(&dir)?;
let mut bus = StreamStore::open(dir.join("events.jsonl"))?;
append_fixture_events(&mut bus, 1_000)?;
assert_eq!(logical_soak(&bus, REQUIRED_SOAK_HO... | Explain what the Rust test `soak_test_preserves_hash_chain` verifies. | The test `soak_test_preserves_hash_chain` verifies soak test preserves hash chain. It belongs to cp-bench and covers domains: event. Observed statuses: none; error codes: none; assertions: 1. | cp-bench::soak_test_preserves_hash_chain | behavior_explanation |
cp-bench::network_churn_does_not_create_direct_backchannel::explain_behavior |
#[test]
fn network_churn_does_not_create_direct_backchannel() -> Result<()> {
assert!(!network_churn_direct_backchannel_detected()?);
Ok(())
} | Explain what the Rust test `network_churn_does_not_create_direct_backchannel` verifies. | The test `network_churn_does_not_create_direct_backchannel` verifies network churn does not create direct backchannel. It belongs to cp-bench and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-bench::network_churn_does_not_create_direct_backchannel | behavior_explanation |
cp-bench::relay_load_keeps_payloads_encrypted::explain_behavior |
#[test]
fn relay_load_keeps_payloads_encrypted() -> Result<()> {
let (frames, encrypted) = relay_load_payloads_encrypted(256)?;
assert_eq!(frames, 256);
assert!(encrypted);
Ok(())
} | Explain what the Rust test `relay_load_keeps_payloads_encrypted` verifies. | The test `relay_load_keeps_payloads_encrypted` verifies relay load keeps payloads encrypted. It belongs to cp-bench and covers domains: general. Observed statuses: none; error codes: none; assertions: 2. | cp-bench::relay_load_keeps_payloads_encrypted | behavior_explanation |
cp-bus::ack_cannot_advance_past_delivery::explain_behavior |
#[test]
fn ack_cannot_advance_past_delivery() {
let mut cursor = ConsumerCursor::new("consumer-a");
assert!(!cursor.ack(5));
cursor.mark_delivered(5);
assert!(cursor.ack(5));
assert_eq!(cursor.last_acked_sequence, 5);
} | Explain what the Rust test `ack_cannot_advance_past_delivery` verifies. | The test `ack_cannot_advance_past_delivery` verifies ack cannot advance past delivery. It belongs to cp-bus and covers domains: general. Observed statuses: none; error codes: none; assertions: 3. | cp-bus::ack_cannot_advance_past_delivery | behavior_explanation |
cp-bus::migration_registry_rejects_gaps::explain_behavior |
#[test]
fn migration_registry_rejects_gaps() {
let registry = MigrationRegistry::new(vec![
MigrationManifest::new(
EventSchemaVersion::new(1, 0),
EventSchemaVersion::new(1, 1),
"first",
true,
),
Migratio... | Explain what the Rust test `migration_registry_rejects_gaps` verifies. | The test `migration_registry_rejects_gaps` verifies migration registry rejects gaps. It belongs to cp-bus and covers domains: event. Observed statuses: none; error codes: none; assertions: 1. | cp-bus::migration_registry_rejects_gaps | behavior_explanation |
cp-bus::record_requires_mechanism_of_action::explain_behavior |
#[test]
fn record_requires_mechanism_of_action() -> Result<(), Box<dyn std::error::Error>> {
let record = BusRecord::build(BusRecordInput {
sequence: 1,
created_at_ms: 0,
subject: Subject::new("task.created")?,
event_type: EventType::new("task.created")?,... | Explain what the Rust test `record_requires_mechanism_of_action` verifies. | The test `record_requires_mechanism_of_action` verifies record requires mechanism of action. It belongs to cp-bus and covers domains: task, event, agent. Observed statuses: none; error codes: none; assertions: 1. | cp-bus::record_requires_mechanism_of_action | behavior_explanation |
cp-bus::append_persists_and_reopens_with_verified_chain::explain_behavior |
#[test]
fn append_persists_and_reopens_with_verified_chain() -> Result<(), Box<dyn std::error::Error>> {
let path = temp_path("reopen");
let mut store = StreamStore::open(&path)?;
assert_eq!(store.schema_version(), CURRENT_EVENT_SCHEMA_VERSION);
append_task(&mut store, "t1")?;
... | Explain what the Rust test `append_persists_and_reopens_with_verified_chain` verifies. | The test `append_persists_and_reopens_with_verified_chain` verifies append persists and reopens with verified chain. It belongs to cp-bus and covers domains: task, event. Observed statuses: none; error codes: none; assertions: 3. | cp-bus::append_persists_and_reopens_with_verified_chain | behavior_explanation |
cp-bus::store_rejects_future_schema_version::explain_behavior |
#[test]
fn store_rejects_future_schema_version() -> Result<(), Box<dyn std::error::Error>> {
let path = temp_path("future-schema");
write_schema_version(&path, EventSchemaVersion::new(2, 0))?;
let err = StreamStore::open(&path)
.err()
.ok_or("future schema versio... | Explain what the Rust test `store_rejects_future_schema_version` verifies. | The test `store_rejects_future_schema_version` verifies store rejects future schema version. It belongs to cp-bus and covers domains: event. Observed statuses: none; error codes: none; assertions: 1. | cp-bus::store_rejects_future_schema_version | behavior_explanation |
cp-bus::subscription_read_requires_ack_to_advance::explain_behavior |
#[test]
fn subscription_read_requires_ack_to_advance() -> Result<(), Box<dyn std::error::Error>> {
let path = temp_path("cursor");
let mut store = StreamStore::open(&path)?;
append_task(&mut store, "t1")?;
append_task(&mut store, "t2")?;
let sub = Subscription::new(
... | Explain what the Rust test `subscription_read_requires_ack_to_advance` verifies. | The test `subscription_read_requires_ack_to_advance` verifies subscription read requires ack to advance. It belongs to cp-bus and covers domains: task. Observed statuses: none; error codes: none; assertions: 6. | cp-bus::subscription_read_requires_ack_to_advance | behavior_explanation |
cp-bus::tampered_payload_fails_reopen_verification::explain_behavior |
#[test]
fn tampered_payload_fails_reopen_verification() -> Result<(), Box<dyn std::error::Error>> {
let path = temp_path("tamper");
let mut store = StreamStore::open(&path)?;
append_task(&mut store, "t1")?;
let mut text = fs::read_to_string(&path)?;
text = text.replace("... | Explain what the Rust test `tampered_payload_fails_reopen_verification` verifies. | The test `tampered_payload_fails_reopen_verification` verifies tampered payload fails reopen verification. It belongs to cp-bus and covers domains: task. Observed statuses: none; error codes: none; assertions: 1. | cp-bus::tampered_payload_fails_reopen_verification | behavior_explanation |
cp-bus::nack_redelivers_record::explain_behavior |
#[test]
fn nack_redelivers_record() -> Result<(), Box<dyn std::error::Error>> {
let path = temp_path("nack-redelivery");
let mut store = StreamStore::open(&path)?;
append_task(&mut store, "t1")?;
let sub = Subscription::new(
SubscriptionId::new("sub-a")?,
... | Explain what the Rust test `nack_redelivers_record` verifies. | The test `nack_redelivers_record` verifies nack redelivers record. It belongs to cp-bus and covers domains: task. Observed statuses: none; error codes: none; assertions: 4. | cp-bus::nack_redelivers_record | behavior_explanation |
cp-bus::replay_from_cursor_verifies_hash_chain::explain_behavior |
#[test]
fn replay_from_cursor_verifies_hash_chain() -> Result<(), Box<dyn std::error::Error>> {
let path = temp_path("verified-replay");
let mut store = StreamStore::open(&path)?;
append_task(&mut store, "t1")?;
append_task(&mut store, "t2")?;
let replayed = store.replay... | Explain what the Rust test `replay_from_cursor_verifies_hash_chain` verifies. | The test `replay_from_cursor_verifies_hash_chain` verifies replay from cursor verifies hash chain. It belongs to cp-bus and covers domains: task. Observed statuses: none; error codes: none; assertions: 4. | cp-bus::replay_from_cursor_verifies_hash_chain | behavior_explanation |
cp-bus::wildcard_filter_matches_child_subjects::explain_behavior |
#[test]
fn wildcard_filter_matches_child_subjects() -> Result<(), Box<dyn std::error::Error>> {
let filter = SubjectFilter::new("task.*")?;
assert!(filter.matches(&Subject::new("task.created")?));
assert!(!filter.matches(&Subject::new("trust.created")?));
assert!(!filter.matches... | Explain what the Rust test `wildcard_filter_matches_child_subjects` verifies. | The test `wildcard_filter_matches_child_subjects` verifies wildcard filter matches child subjects. It belongs to cp-bus and covers domains: task, trust. Observed statuses: none; error codes: none; assertions: 3. | cp-bus::wildcard_filter_matches_child_subjects | behavior_explanation |
cp-config::defaults_are_valid::explain_behavior |
#[test]
fn defaults_are_valid() -> Result<(), Box<dyn std::error::Error>> {
let config = ConfigLoader::load(&[ConfigLayer::CompiledDefaults])?;
assert_eq!(config.mode, RuntimeMode::LocalOnly);
assert_eq!(config.node_id.as_str(), "node-local");
assert!(config.data_dir.is_absolute... | Explain what the Rust test `defaults_are_valid` verifies. | The test `defaults_are_valid` verifies defaults are valid. It belongs to cp-config and covers domains: general. Observed statuses: none; error codes: none; assertions: 3. | cp-config::defaults_are_valid | behavior_explanation |
cp-config::layer_override_wins::explain_behavior |
#[test]
fn layer_override_wins() -> Result<(), Box<dyn std::error::Error>> {
let system = write_file("system", "node_id = \"node-system\"\n")?;
let local = write_file("local", "node_id = \"node-local-override\"\n")?;
let config = ConfigLoader::load(&[
ConfigLayer::CompiledDe... | Explain what the Rust test `layer_override_wins` verifies. | The test `layer_override_wins` verifies layer override wins. It belongs to cp-config and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-config::layer_override_wins | behavior_explanation |
cp-config::env_override_wins::explain_behavior |
#[test]
fn env_override_wins() -> Result<(), Box<dyn std::error::Error>> {
let file = write_file("env", "node_id = \"node-file\"\n")?;
let vars = BTreeMap::from([("CP_NODE_ID", "node-env".to_owned())]);
let env_partial = load_environment_from(|name| vars.get(name).cloned())?;
le... | Explain what the Rust test `env_override_wins` verifies. | The test `env_override_wins` verifies env override wins. It belongs to cp-config and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-config::env_override_wins | behavior_explanation |
cp-config::relay_server_config_loads_from_toml::explain_behavior |
#[test]
fn relay_server_config_loads_from_toml() -> Result<(), Box<dyn std::error::Error>> {
let file = write_file(
"relay-server",
r#"
node_id = "node-relay"
[relay_server]
listen_addr = "127.0.0.1:0"
peers = [
{ node_id = "node-peer-a", addr = "127.0.0.1:9001" },
{ node_i... | Explain what the Rust test `relay_server_config_loads_from_toml` verifies. | The test `relay_server_config_loads_from_toml` verifies relay server config loads from toml. It belongs to cp-config and covers domains: general. Observed statuses: none; error codes: none; assertions: 4. | cp-config::relay_server_config_loads_from_toml | behavior_explanation |
cp-config::relay_server_env_loads_peer_directory::explain_behavior |
#[test]
fn relay_server_env_loads_peer_directory() -> Result<(), Box<dyn std::error::Error>> {
let vars = BTreeMap::from([
("CP_RELAY_SERVER_LISTEN_ADDR", "127.0.0.1:7000".to_owned()),
(
"CP_RELAY_SERVER_PEERS",
"node-peer-a=127.0.0.1:9001,node-pe... | Explain what the Rust test `relay_server_env_loads_peer_directory` verifies. | The test `relay_server_env_loads_peer_directory` verifies relay server env loads peer directory. It belongs to cp-config and covers domains: general. Observed statuses: none; error codes: none; assertions: 4. | cp-config::relay_server_env_loads_peer_directory | behavior_explanation |
cp-config::relay_server_rejects_self_target::explain_behavior |
#[test]
fn relay_server_rejects_self_target() -> Result<(), Box<dyn std::error::Error>> {
let file = write_file(
"relay-server-self",
r#"
node_id = "node-relay"
[relay_server]
listen_addr = "127.0.0.1:0"
peers = [
{ node_id = "node-relay", addr = "127.0.0.1:9001" },
]
"#,
... | Explain what the Rust test `relay_server_rejects_self_target` verifies. | The test `relay_server_rejects_self_target` verifies relay server rejects self target. It belongs to cp-config and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-config::relay_server_rejects_self_target | behavior_explanation |
cp-config::environment_layer_loads_from_process_lookup::explain_behavior |
#[test]
fn environment_layer_loads_from_process_lookup() -> Result<(), Box<dyn std::error::Error>> {
let config =
ConfigLoader::load(&[ConfigLayer::CompiledDefaults, ConfigLayer::Environment])?;
assert!(config.data_dir.is_absolute());
Ok(())
} | Explain what the Rust test `environment_layer_loads_from_process_lookup` verifies. | The test `environment_layer_loads_from_process_lookup` verifies environment layer loads from process lookup. It belongs to cp-config and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-config::environment_layer_loads_from_process_lookup | behavior_explanation |
cp-config::secret_store_resolves_tokens::explain_behavior |
#[test]
fn secret_store_resolves_tokens() -> Result<(), Box<dyn std::error::Error>> {
let config_file = write_file("secret-config", "node_id = \"${secret:node_id}\"\n")?;
let secret_file = write_file("secret-store", "[secrets]\nnode_id = \"node-secret\"\n")?;
#[cfg(unix)]
chmod(... | Explain what the Rust test `secret_store_resolves_tokens` verifies. | The test `secret_store_resolves_tokens` verifies secret store resolves tokens. It belongs to cp-config and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-config::secret_store_resolves_tokens | behavior_explanation |
cp-config::secret_store_rejects_wrong_mode::explain_behavior | #[test]
fn secret_store_rejects_wrong_mode() -> Result<(), Box<dyn std::error::Error>> {
let secret_file = write_file("secret-bad-mode", "[secrets]\nnode_id = \"node-secret\"\n")?;
chmod(&secret_file, 0o644)?;
let result = ConfigLoader::load(&[
ConfigLayer::CompiledDefaults,
... | Explain what the Rust test `secret_store_rejects_wrong_mode` verifies. | The test `secret_store_rejects_wrong_mode` verifies secret store rejects wrong mode. It belongs to cp-config and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-config::secret_store_rejects_wrong_mode | behavior_explanation |
cp-config::missing_required_field_fails::explain_behavior |
#[test]
fn missing_required_field_fails() {
let result = ResolvedConfig::from_partial(PartialConfig::default());
assert!(matches!(
result,
Err(ConfigError::MissingRequired("node_id"))
));
} | Explain what the Rust test `missing_required_field_fails` verifies. | The test `missing_required_field_fails` verifies missing required field fails. It belongs to cp-config and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-config::missing_required_field_fails | behavior_explanation |
cp-core::object_keys_are_sorted::explain_behavior |
#[test]
fn object_keys_are_sorted() -> Result<(), CanonicalError> {
let mut map = CanonicalMap::new();
map.insert("z".to_string(), CanonicalValue::Integer(1));
map.insert("a".to_string(), CanonicalValue::Bool(true));
let encoded = CanonicalValue::Object(map).encode()?;
a... | Explain what the Rust test `object_keys_are_sorted` verifies. | The test `object_keys_are_sorted` verifies object keys are sorted. It belongs to cp-core and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-core::object_keys_are_sorted | behavior_explanation |
cp-core::strings_are_escaped::explain_behavior |
#[test]
fn strings_are_escaped() -> Result<(), CanonicalError> {
assert_eq!(
CanonicalValue::String("a\n\"b\"".to_string()).encode()?,
"\"a\\n\\\"b\\\"\""
);
Ok(())
} | Explain what the Rust test `strings_are_escaped` verifies. | The test `strings_are_escaped` verifies strings are escaped. It belongs to cp-core and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-core::strings_are_escaped | behavior_explanation |
cp-core::restricted_mode_blocks_new_orchestration::explain_behavior |
#[test]
fn restricted_mode_blocks_new_orchestration() {
let gate = EntitlementGate::new(EntitlementState::Restricted);
assert_eq!(
gate.evaluate(RestrictedCapability::StartWorkflow),
EntitlementDecision::DenyRestricted
);
assert_eq!(
gate.eval... | Explain what the Rust test `restricted_mode_blocks_new_orchestration` verifies. | The test `restricted_mode_blocks_new_orchestration` verifies restricted mode blocks new orchestration. It belongs to cp-core and covers domains: workflow, task, agent. Observed statuses: none; error codes: none; assertions: 2. | cp-core::restricted_mode_blocks_new_orchestration | behavior_explanation |
cp-core::restricted_mode_preserves_customer_data_access::explain_behavior |
#[test]
fn restricted_mode_preserves_customer_data_access() {
let gate = EntitlementGate::new(EntitlementState::Restricted);
assert_eq!(
gate.evaluate(RestrictedCapability::ExportData),
EntitlementDecision::Allow
);
assert_eq!(
gate.evaluate(R... | Explain what the Rust test `restricted_mode_preserves_customer_data_access` verifies. | The test `restricted_mode_preserves_customer_data_access` verifies restricted mode preserves customer data access. It belongs to cp-core and covers domains: general. Observed statuses: none; error codes: none; assertions: 2. | cp-core::restricted_mode_preserves_customer_data_access | behavior_explanation |
cp-core::grace_mode_allows_operations::explain_behavior |
#[test]
fn grace_mode_allows_operations() {
let gate = EntitlementGate::new(EntitlementState::Grace);
assert_eq!(
gate.evaluate(RestrictedCapability::InstallPlugin),
EntitlementDecision::Allow
);
} | Explain what the Rust test `grace_mode_allows_operations` verifies. | The test `grace_mode_allows_operations` verifies grace mode allows operations. It belongs to cp-core and covers domains: plugin. Observed statuses: none; error codes: none; assertions: 1. | cp-core::grace_mode_allows_operations | behavior_explanation |
cp-core::validates_known_payload_keys::explain_behavior |
#[test]
fn validates_known_payload_keys() -> Result<(), PayloadValidationError> {
let report = validate_payload(
"authority.decision",
["agent_id", "action", "allowed", "reason"],
false,
)?;
assert!(report.valid);
assert!(report.spec.is_some()... | Explain what the Rust test `validates_known_payload_keys` verifies. | The test `validates_known_payload_keys` verifies validates known payload keys. It belongs to cp-core and covers domains: auth, event, agent. Observed statuses: none; error codes: none; assertions: 2. | cp-core::validates_known_payload_keys | behavior_explanation |
cp-core::rejects_missing_known_payload_keys::explain_behavior |
#[test]
fn rejects_missing_known_payload_keys() -> Result<(), String> {
let err = match validate_payload("task.created", ["task_id"], false) {
Ok(_) => return Err("task.created without goal should fail validation".to_string()),
Err(err) => err,
};
assert_eq!(
... | Explain what the Rust test `rejects_missing_known_payload_keys` verifies. | The test `rejects_missing_known_payload_keys` verifies rejects missing known payload keys. It belongs to cp-core and covers domains: task, event. Observed statuses: none; error codes: none; assertions: 1. | cp-core::rejects_missing_known_payload_keys | behavior_explanation |
cp-core::allows_unknown_event_by_default::explain_behavior |
#[test]
fn allows_unknown_event_by_default() -> Result<(), PayloadValidationError> {
let report = validate_payload("tenant.custom.event", ["anything"], false)?;
assert!(report.valid);
assert!(report.spec.is_none());
Ok(())
} | Explain what the Rust test `allows_unknown_event_by_default` verifies. | The test `allows_unknown_event_by_default` verifies allows unknown event by default. It belongs to cp-core and covers domains: event, tenant. Observed statuses: none; error codes: none; assertions: 2. | cp-core::allows_unknown_event_by_default | behavior_explanation |
cp-core::event_specs_are_unique_and_sorted_enough_for_lookup::explain_behavior |
#[test]
fn event_specs_are_unique_and_sorted_enough_for_lookup() {
let mut seen = BTreeSet::new();
for spec in CORE_EVENT_SPECS {
assert!(
seen.insert(spec.event_type),
"duplicate {}",
spec.event_type
);
assert!... | Explain what the Rust test `event_specs_are_unique_and_sorted_enough_for_lookup` verifies. | The test `event_specs_are_unique_and_sorted_enough_for_lookup` verifies event specs are unique and sorted enough for lookup. It belongs to cp-core and covers domains: event. Observed statuses: none; error codes: none; assertions: 3. | cp-core::event_specs_are_unique_and_sorted_enough_for_lookup | behavior_explanation |
cp-core::tenant_event_specs_are_registered::explain_behavior |
#[test]
fn tenant_event_specs_are_registered() -> Result<(), PayloadValidationError> {
let report = validate_payload(
"tenant.agent.replacement_needed",
["tenant_id", "agent_id", "role", "reason"],
true,
)?;
assert!(report.valid);
assert_eq!(r... | Explain what the Rust test `tenant_event_specs_are_registered` verifies. | The test `tenant_event_specs_are_registered` verifies tenant event specs are registered. It belongs to cp-core and covers domains: event, agent, tenant. Observed statuses: none; error codes: none; assertions: 2. | cp-core::tenant_event_specs_are_registered | behavior_explanation |
cp-core::forward_compatible_minor_upgrade::explain_behavior |
#[test]
fn forward_compatible_minor_upgrade() {
assert!(CompatibilityCheck::is_forward_compatible(
EventSchemaVersion::new(1, 0),
EventSchemaVersion::new(1, 1)
));
} | Explain what the Rust test `forward_compatible_minor_upgrade` verifies. | The test `forward_compatible_minor_upgrade` verifies forward compatible minor upgrade. It belongs to cp-core and covers domains: upgrade, event. Observed statuses: none; error codes: none; assertions: 1. | cp-core::forward_compatible_minor_upgrade | behavior_explanation |
cp-core::major_version_mismatch_rejects::explain_behavior |
#[test]
fn major_version_mismatch_rejects() {
assert!(!CompatibilityCheck::is_forward_compatible(
EventSchemaVersion::new(1, 0),
EventSchemaVersion::new(2, 0)
));
} | Explain what the Rust test `major_version_mismatch_rejects` verifies. | The test `major_version_mismatch_rejects` verifies major version mismatch rejects. It belongs to cp-core and covers domains: event. Observed statuses: none; error codes: none; assertions: 1. | cp-core::major_version_mismatch_rejects | behavior_explanation |
cp-core::fnv1a_empty_matches_reference::explain_behavior |
#[test]
fn fnv1a_empty_matches_reference() {
assert_eq!(fnv1a_64_hex(b""), "cbf29ce484222325");
} | Explain what the Rust test `fnv1a_empty_matches_reference` verifies. | The test `fnv1a_empty_matches_reference` verifies fnv1a empty matches reference. It belongs to cp-core and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-core::fnv1a_empty_matches_reference | behavior_explanation |
cp-core::fnv1a_known_value_matches_reference::explain_behavior |
#[test]
fn fnv1a_known_value_matches_reference() {
assert_eq!(fnv1a_64_hex(b"hello"), "a430d84680aabd0b");
} | Explain what the Rust test `fnv1a_known_value_matches_reference` verifies. | The test `fnv1a_known_value_matches_reference` verifies fnv1a known value matches reference. It belongs to cp-core and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-core::fnv1a_known_value_matches_reference | behavior_explanation |
cp-core::hex_encode_lowercase::explain_behavior |
#[test]
fn hex_encode_lowercase() {
assert_eq!(hex_encode(&[0x00, 0x0f, 0xa5, 0xff]), "000fa5ff");
} | Explain what the Rust test `hex_encode_lowercase` verifies. | The test `hex_encode_lowercase` verifies hex encode lowercase. It belongs to cp-core and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-core::hex_encode_lowercase | behavior_explanation |
cp-core::rejects_empty_identifier::explain_behavior |
#[test]
fn rejects_empty_identifier() {
assert_eq!(AgentId::new(" "), Err(IdError::Empty));
} | Explain what the Rust test `rejects_empty_identifier` verifies. | The test `rejects_empty_identifier` verifies rejects empty identifier. It belongs to cp-core and covers domains: agent. Observed statuses: none; error codes: none; assertions: 1. | cp-core::rejects_empty_identifier | behavior_explanation |
cp-core::rejects_control_characters::explain_behavior |
#[test]
fn rejects_control_characters() {
assert_eq!(NodeId::new("node\n1"), Err(IdError::ControlCharacter));
} | Explain what the Rust test `rejects_control_characters` verifies. | The test `rejects_control_characters` verifies rejects control characters. It belongs to cp-core and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-core::rejects_control_characters | behavior_explanation |
cp-core::accepts_displayable_identifier::explain_behavior |
#[test]
fn accepts_displayable_identifier() -> Result<(), IdError> {
let id = WorkflowId::new("workflow-alpha")?;
assert_eq!(id.as_str(), "workflow-alpha");
Ok(())
} | Explain what the Rust test `accepts_displayable_identifier` verifies. | The test `accepts_displayable_identifier` verifies accepts displayable identifier. It belongs to cp-core and covers domains: workflow. Observed statuses: none; error codes: none; assertions: 1. | cp-core::accepts_displayable_identifier | behavior_explanation |
cp-core::viewer_does_not_imply_admin::explain_behavior |
#[test]
fn viewer_does_not_imply_admin() {
assert!(!Role::Viewer.implies(Role::Admin));
} | Explain what the Rust test `viewer_does_not_imply_admin` verifies. | The test `viewer_does_not_imply_admin` verifies viewer does not imply admin. It belongs to cp-core and covers domains: rbac. Observed statuses: none; error codes: none; assertions: 1. | cp-core::viewer_does_not_imply_admin | behavior_explanation |
cp-core::accepts_saas_ready_scope_ids::explain_behavior |
#[test]
fn accepts_saas_ready_scope_ids() {
assert!(OrgId::new("org-acme_01").is_ok());
assert!(WorkspaceId::new("prod.us-east").is_ok());
} | Explain what the Rust test `accepts_saas_ready_scope_ids` verifies. | The test `accepts_saas_ready_scope_ids` verifies accepts saas ready scope ids. It belongs to cp-core and covers domains: general. Observed statuses: none; error codes: none; assertions: 2. | cp-core::accepts_saas_ready_scope_ids | behavior_explanation |
cp-core::rejects_ambiguous_scope_ids::explain_behavior |
#[test]
fn rejects_ambiguous_scope_ids() {
assert_eq!(
OrgId::new("bad org"),
Err(ScopeError::InvalidCharacter(' '))
);
} | Explain what the Rust test `rejects_ambiguous_scope_ids` verifies. | The test `rejects_ambiguous_scope_ids` verifies rejects ambiguous scope ids. It belongs to cp-core and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-core::rejects_ambiguous_scope_ids | behavior_explanation |
cp-daemon::parses_transport_manifest_operator_flags::explain_behavior |
#[test]
fn parses_transport_manifest_operator_flags() -> Result<(), Box<dyn std::error::Error>> {
let args = CliArgs::parse([
"--node-id".to_string(),
"node-cli".to_string(),
"--transport-handoff-json".to_string(),
"--transport-handoff-audit-json".to_stri... | Explain what the Rust test `parses_transport_manifest_operator_flags` verifies. | The test `parses_transport_manifest_operator_flags` verifies parses transport manifest operator flags. It belongs to cp-daemon and covers domains: transport. Observed statuses: none; error codes: none; assertions: 5. | cp-daemon::parses_transport_manifest_operator_flags | behavior_explanation |
cp-daemon::parses_config_file_flags::explain_behavior |
#[test]
fn parses_config_file_flags() -> Result<(), Box<dyn std::error::Error>> {
let args = CliArgs::parse([
"--config-file".to_string(),
"/tmp/cp.toml".to_string(),
"--secret-store".to_string(),
"/tmp/cp-secrets.toml".to_string(),
])?;
... | Explain what the Rust test `parses_config_file_flags` verifies. | The test `parses_config_file_flags` verifies parses config file flags. It belongs to cp-daemon and covers domains: general. Observed statuses: none; error codes: none; assertions: 2. | cp-daemon::parses_config_file_flags | behavior_explanation |
cp-daemon::parses_bootstrap_owner_flags::explain_behavior |
#[test]
fn parses_bootstrap_owner_flags() -> Result<(), Box<dyn std::error::Error>> {
let args = CliArgs::parse([
"--bootstrap-owner-username".to_string(),
"owner".to_string(),
"--bootstrap-owner-password-file".to_string(),
"/tmp/cp-owner-password".to_str... | Explain what the Rust test `parses_bootstrap_owner_flags` verifies. | The test `parses_bootstrap_owner_flags` verifies parses bootstrap owner flags. It belongs to cp-daemon and covers domains: auth. Observed statuses: none; error codes: none; assertions: 3. | cp-daemon::parses_bootstrap_owner_flags | behavior_explanation |
cp-daemon::bootstrap_owner_creates_first_owner_account::explain_behavior |
#[test]
fn bootstrap_owner_creates_first_owner_account() -> Result<(), Box<dyn std::error::Error>> {
let data_dir = temp_data_dir("bootstrap-owner")?;
let key = BackupKeyMaterial::new([7; 32], [9; 12]);
let key_hex = key.to_hex();
let args = CliArgs::parse([
"--data-... | Explain what the Rust test `bootstrap_owner_creates_first_owner_account` verifies. | The test `bootstrap_owner_creates_first_owner_account` verifies bootstrap owner creates first owner account. It belongs to cp-daemon and covers domains: auth, backup. Observed statuses: none; error codes: none; assertions: 4. | cp-daemon::bootstrap_owner_creates_first_owner_account | behavior_explanation |
cp-daemon::bootstrap_owner_refuses_existing_accounts::explain_behavior |
#[test]
fn bootstrap_owner_refuses_existing_accounts() -> Result<(), Box<dyn std::error::Error>> {
let data_dir = temp_data_dir("bootstrap-existing")?;
let key = BackupKeyMaterial::new([11; 32], [13; 12]);
let key_hex = key.to_hex();
let mut envs = BTreeMap::from([
(... | Explain what the Rust test `bootstrap_owner_refuses_existing_accounts` verifies. | The test `bootstrap_owner_refuses_existing_accounts` verifies bootstrap owner refuses existing accounts. It belongs to cp-daemon and covers domains: auth, backup. Observed statuses: none; error codes: none; assertions: 1. | cp-daemon::bootstrap_owner_refuses_existing_accounts | behavior_explanation |
cp-daemon::config_file_builds_daemon_config::explain_behavior |
#[test]
fn config_file_builds_daemon_config() -> Result<(), Box<dyn std::error::Error>> {
let data_dir = env::temp_dir().join("cp-daemon-config-file-data");
let config_path = temp_config_path("config-file")?;
fs::write(
&config_path,
format!(
"nod... | Explain what the Rust test `config_file_builds_daemon_config` verifies. | The test `config_file_builds_daemon_config` verifies config file builds daemon config. It belongs to cp-daemon and covers domains: general. Observed statuses: none; error codes: none; assertions: 7. | cp-daemon::config_file_builds_daemon_config | behavior_explanation |
cp-daemon::parses_transport_peer_mutation_flags::explain_behavior |
#[test]
fn parses_transport_peer_mutation_flags() -> Result<(), Box<dyn std::error::Error>> {
let args = CliArgs::parse([
"--transport-add-peer".to_string(),
"node-peer".to_string(),
"--transport-peer-disabled".to_string(),
"--egress-batch-limit".to_strin... | Explain what the Rust test `parses_transport_peer_mutation_flags` verifies. | The test `parses_transport_peer_mutation_flags` verifies parses transport peer mutation flags. It belongs to cp-daemon and covers domains: transport. Observed statuses: none; error codes: none; assertions: 3. | cp-daemon::parses_transport_peer_mutation_flags | behavior_explanation |
cp-daemon::rejects_conflicting_transport_peer_mutation_flags::explain_behavior |
#[test]
fn rejects_conflicting_transport_peer_mutation_flags() -> Result<(), Box<dyn std::error::Error>>
{
let args = CliArgs::parse([
"--transport-add-peer".to_string(),
"node-peer-a".to_string(),
"--transport-remove-peer".to_string(),
"node-peer-b".... | Explain what the Rust test `rejects_conflicting_transport_peer_mutation_flags` verifies. | The test `rejects_conflicting_transport_peer_mutation_flags` verifies rejects conflicting transport peer mutation flags. It belongs to cp-daemon and covers domains: transport. Observed statuses: none; error codes: none; assertions: 1. | cp-daemon::rejects_conflicting_transport_peer_mutation_flags | behavior_explanation |
cp-daemon::help_documents_transport_manifest_operator_flags::explain_behavior |
#[test]
fn help_documents_transport_manifest_operator_flags() {
assert!(HELP.contains("--config-file"));
assert!(HELP.contains("--secret-store"));
assert!(HELP.contains("[relay_server]"));
assert!(HELP.contains("CP_RELAY_SERVER_LISTEN_ADDR"));
assert!(HELP.contains("CP_R... | Explain what the Rust test `help_documents_transport_manifest_operator_flags` verifies. | The test `help_documents_transport_manifest_operator_flags` verifies help documents transport manifest operator flags. It belongs to cp-daemon and covers domains: transport. Observed statuses: none; error codes: none; assertions: 11. | cp-daemon::help_documents_transport_manifest_operator_flags | behavior_explanation |
cp-entitlement::entitlement_client_never_sends_event_payloads::explain_behavior |
#[test]
fn entitlement_client_never_sends_event_payloads() -> Result<(), Box<dyn std::error::Error>> {
let client = OutboundEntitlementClient::new(EntitlementCheckConfig {
enabled: true,
endpoint: "https://vendor.example/entitlement/check".to_owned(),
offline_grace_s... | Explain what the Rust test `entitlement_client_never_sends_event_payloads` verifies. | The test `entitlement_client_never_sends_event_payloads` verifies entitlement client never sends event payloads. It belongs to cp-entitlement and covers domains: workflow, credential, event. Observed statuses: none; error codes: none; assertions: 6. | cp-entitlement::entitlement_client_never_sends_event_payloads | behavior_explanation |
cp-entitlement::valid_license_allows_orchestration::explain_behavior |
#[test]
fn valid_license_allows_orchestration() -> Result<(), Box<dyn std::error::Error>> {
let token = LicenseToken::signed(claims(1_000, 2_000), b"vendor-key")?;
assert_eq!(
LicenseVerifier::verify(&token, b"vendor-key", 500),
EntitlementDecision::Active
);
... | Explain what the Rust test `valid_license_allows_orchestration` verifies. | The test `valid_license_allows_orchestration` verifies valid license allows orchestration. It belongs to cp-entitlement and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-entitlement::valid_license_allows_orchestration | behavior_explanation |
cp-entitlement::grace_expired_enters_restricted_mode::explain_behavior |
#[test]
fn grace_expired_enters_restricted_mode() -> Result<(), Box<dyn std::error::Error>> {
let token = LicenseToken::signed(claims(1_000, 2_000), b"vendor-key")?;
assert_eq!(
LicenseVerifier::verify(&token, b"vendor-key", 2_001),
EntitlementDecision::Restricted
... | Explain what the Rust test `grace_expired_enters_restricted_mode` verifies. | The test `grace_expired_enters_restricted_mode` verifies grace expired enters restricted mode. It belongs to cp-entitlement and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-entitlement::grace_expired_enters_restricted_mode | behavior_explanation |
cp-entitlement::restricted_mode_preserves_data_export::explain_behavior |
#[test]
fn restricted_mode_preserves_data_export() {
let policy = RestrictedModePolicy::new(EntitlementState::Restricted);
for action in [
RestrictedModeAction::ReadCustomerData,
RestrictedModeAction::ExportCustomerData,
RestrictedModeAction::Backup,
... | Explain what the Rust test `restricted_mode_preserves_data_export` verifies. | The test `restricted_mode_preserves_data_export` verifies restricted mode preserves data export. It belongs to cp-entitlement and covers domains: backup, support. Observed statuses: none; error codes: none; assertions: 1. | cp-entitlement::restricted_mode_preserves_data_export | behavior_explanation |
cp-entitlement::restricted_mode_blocks_new_orchestration::explain_behavior |
#[test]
fn restricted_mode_blocks_new_orchestration() {
let policy = RestrictedModePolicy::new(EntitlementState::Restricted);
for action in [
RestrictedModeAction::NewOrchestration,
RestrictedModeAction::NewParticipantRegistration,
RestrictedModeAction::NewPl... | Explain what the Rust test `restricted_mode_blocks_new_orchestration` verifies. | The test `restricted_mode_blocks_new_orchestration` verifies restricted mode blocks new orchestration. It belongs to cp-entitlement and covers domains: credential, plugin. Observed statuses: none; error codes: none; assertions: 1. | cp-entitlement::restricted_mode_blocks_new_orchestration | behavior_explanation |
cp-governance::shortest_path_finds_directed_route::explain_behavior |
#[test]
fn shortest_path_finds_directed_route() -> Result<(), Box<dyn std::error::Error>> {
let mut graph = Cartographer::new();
graph.merge_node("a", GraphNodeType::Agent, "A", json!({}), 1)?;
graph.merge_node("b", GraphNodeType::Task, "B", json!({}), 1)?;
graph.merge_node("c",... | Explain what the Rust test `shortest_path_finds_directed_route` verifies. | The test `shortest_path_finds_directed_route` verifies shortest path finds directed route. It belongs to cp-governance and covers domains: task, agent. Observed statuses: none; error codes: none; assertions: 1. | cp-governance::shortest_path_finds_directed_route | behavior_explanation |
cp-governance::projection_indexes_task_event_entities::explain_behavior |
#[test]
fn projection_indexes_task_event_entities() -> Result<(), Box<dyn std::error::Error>> {
let mut graph = Cartographer::new();
let event = AcceptedEvent::new(
EntryId::new("event-a")?,
EventType::new("task.completed")?,
"kernel.task",
json!(... | Explain what the Rust test `projection_indexes_task_event_entities` verifies. | The test `projection_indexes_task_event_entities` verifies projection indexes task event entities. It belongs to cp-governance and covers domains: task, event, agent. Observed statuses: none; error codes: none; assertions: 4. | cp-governance::projection_indexes_task_event_entities | behavior_explanation |
cp-governance::connected_components_split_isolated_graphs::explain_behavior |
#[test]
fn connected_components_split_isolated_graphs() -> Result<(), Box<dyn std::error::Error>> {
let mut graph = Cartographer::new();
graph.merge_node("a", GraphNodeType::Agent, "A", json!({}), 1)?;
graph.merge_node("b", GraphNodeType::Task, "B", json!({}), 1)?;
graph.merge_n... | Explain what the Rust test `connected_components_split_isolated_graphs` verifies. | The test `connected_components_split_isolated_graphs` verifies connected components split isolated graphs. It belongs to cp-governance and covers domains: task, agent. Observed statuses: none; error codes: none; assertions: 1. | cp-governance::connected_components_split_isolated_graphs | behavior_explanation |
cp-governance::lifecycle_reaches_graduated::explain_behavior |
#[test]
fn lifecycle_reaches_graduated() -> Result<(), Box<dyn std::error::Error>> {
let mut nursery = nursery_with_candidate()?;
nursery.start_training("candidate-a", 1_001)?;
nursery.complete_evaluation(
"eval-a",
"candidate-a",
"scenario-a",
... | Explain what the Rust test `lifecycle_reaches_graduated` verifies. | The test `lifecycle_reaches_graduated` verifies lifecycle reaches graduated. It belongs to cp-governance and covers domains: agent. Observed statuses: none; error codes: none; assertions: 2. | cp-governance::lifecycle_reaches_graduated | behavior_explanation |
cp-governance::critical_failure_blocks_graduation::explain_behavior |
#[test]
fn critical_failure_blocks_graduation() -> Result<(), Box<dyn std::error::Error>> {
let mut nursery = nursery_with_candidate()?;
nursery.start_training("candidate-a", 1_001)?;
nursery.complete_evaluation(
"eval-a",
"candidate-a",
"scenario-a",... | Explain what the Rust test `critical_failure_blocks_graduation` verifies. | The test `critical_failure_blocks_graduation` verifies critical failure blocks graduation. It belongs to cp-governance and covers domains: agent. Observed statuses: none; error codes: none; assertions: 1. | cp-governance::critical_failure_blocks_graduation | behavior_explanation |
cp-governance::snapshot_round_trip_preserves_candidate::explain_behavior |
#[test]
fn snapshot_round_trip_preserves_candidate() -> Result<(), Box<dyn std::error::Error>> {
let nursery = nursery_with_candidate()?;
let restored = Nursery::from_snapshot(nursery.snapshot())?;
assert!(restored.candidate("candidate-a").is_some());
Ok(())
} | Explain what the Rust test `snapshot_round_trip_preserves_candidate` verifies. | The test `snapshot_round_trip_preserves_candidate` verifies snapshot round trip preserves candidate. It belongs to cp-governance and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-governance::snapshot_round_trip_preserves_candidate | behavior_explanation |
cp-governance::failed_noncritical_scenario_lowers_only_exercised_capability::explain_behavior |
#[test]
fn failed_noncritical_scenario_lowers_only_exercised_capability()
-> Result<(), Box<dyn std::error::Error>> {
let mut nursery = nursery_with_candidate()?;
add_scenario(&mut nursery, "scenario-b", "shell.exec", false)?;
nursery.start_training("candidate-a", 1_001)?;
n... | Explain what the Rust test `failed_noncritical_scenario_lowers_only_exercised_capability` verifies. | The test `failed_noncritical_scenario_lowers_only_exercised_capability` verifies failed noncritical scenario lowers only exercised capability. It belongs to cp-governance and covers domains: general. Observed statuses: none; error codes: none; assertions: 3. | cp-governance::failed_noncritical_scenario_lowers_only_exercised_capability | behavior_explanation |
cp-governance::graduation_excludes_failed_and_untested_declared_capabilities::explain_behavior |
#[test]
fn graduation_excludes_failed_and_untested_declared_capabilities()
-> Result<(), Box<dyn std::error::Error>> {
let mut nursery = nursery_with_candidate()?;
add_scenario(&mut nursery, "scenario-b", "shell.exec", false)?;
nursery.start_training("candidate-a", 1_001)?;
... | Explain what the Rust test `graduation_excludes_failed_and_untested_declared_capabilities` verifies. | The test `graduation_excludes_failed_and_untested_declared_capabilities` verifies graduation excludes failed and untested declared capabilities. It belongs to cp-governance and covers domains: agent. Observed statuses: none; error codes: none; assertions: 1. | cp-governance::graduation_excludes_failed_and_untested_declared_capabilities | behavior_explanation |
cp-governance::global_readiness_does_not_grant_failed_capability::explain_behavior |
#[test]
fn global_readiness_does_not_grant_failed_capability() -> Result<(), Box<dyn std::error::Error>>
{
let mut nursery = nursery_with_candidate()?;
add_scenario(&mut nursery, "scenario-b", "shell.exec", false)?;
nursery.start_training("candidate-a", 1_001)?;
nursery.comp... | Explain what the Rust test `global_readiness_does_not_grant_failed_capability` verifies. | The test `global_readiness_does_not_grant_failed_capability` verifies global readiness does not grant failed capability. It belongs to cp-governance and covers domains: agent. Observed statuses: none; error codes: none; assertions: 2. | cp-governance::global_readiness_does_not_grant_failed_capability | behavior_explanation |
cp-governance::projection_lag_gauge_decreases_after_rebuild::explain_behavior |
#[test]
fn projection_lag_gauge_decreases_after_rebuild() -> Result<(), Box<dyn std::error::Error>> {
let metrics = std::sync::Arc::new(std::sync::Mutex::new(MetricsRegistry::new()));
let mut projection = TestProjection::default();
record_projection_lag(&metrics, &projection, 3);
... | Explain what the Rust test `projection_lag_gauge_decreases_after_rebuild` verifies. | The test `projection_lag_gauge_decreases_after_rebuild` verifies projection lag gauge decreases after rebuild. It belongs to cp-governance and covers domains: metrics, event. Observed statuses: none; error codes: none; assertions: 2. | cp-governance::projection_lag_gauge_decreases_after_rebuild | behavior_explanation |
cp-governance::lineage_chain_is_verified::explain_behavior |
#[test]
fn lineage_chain_is_verified() -> Result<(), Box<dyn std::error::Error>> {
let mut scribe = Scribe::new();
scribe.insert_node(ProvenanceNodeInput {
node_id: "source".to_string(),
entity_type: "dataset".to_string(),
entity_id: "d1".to_string(),
... | Explain what the Rust test `lineage_chain_is_verified` verifies. | The test `lineage_chain_is_verified` verifies lineage chain is verified. It belongs to cp-governance and covers domains: event. Observed statuses: none; error codes: none; assertions: 2. | cp-governance::lineage_chain_is_verified | behavior_explanation |
cp-governance::projection_indexes_parent_child_event::explain_behavior |
#[test]
fn projection_indexes_parent_child_event() -> Result<(), Box<dyn std::error::Error>> {
let mut scribe = Scribe::new();
let parent = AcceptedEvent::new(
EntryId::new("event-a")?,
EventType::new("task.created")?,
"task",
json!({"task_id":"ta... | Explain what the Rust test `projection_indexes_parent_child_event` verifies. | The test `projection_indexes_parent_child_event` verifies projection indexes parent child event. It belongs to cp-governance and covers domains: task, event, agent. Observed statuses: none; error codes: none; assertions: 1. | cp-governance::projection_indexes_parent_child_event | behavior_explanation |
cp-installer::parses_non_interactive_flags::explain_behavior |
#[test]
fn parses_non_interactive_flags() -> Result<(), Box<dyn std::error::Error>> {
let args = CliArgs::parse([
"--node-id".to_owned(),
"node-cli".to_owned(),
"--listen-addr".to_owned(),
"0.0.0.0:7400".to_owned(),
"--data-dir".to_owned(),
... | Explain what the Rust test `parses_non_interactive_flags` verifies. | The test `parses_non_interactive_flags` verifies parses non interactive flags. It belongs to cp-installer and covers domains: general. Observed statuses: none; error codes: none; assertions: 9. | cp-installer::parses_non_interactive_flags | behavior_explanation |
cp-installer::rejects_direct_password_flag::explain_behavior |
#[test]
fn rejects_direct_password_flag() -> Result<(), Box<dyn std::error::Error>> {
let error = CliArgs::parse(["--owner-password".to_owned(), "do-not-allow".to_owned()])
.err()
.ok_or("direct password flag must be rejected")?;
assert!(matches!(error, CliError::Unknow... | Explain what the Rust test `rejects_direct_password_flag` verifies. | The test `rejects_direct_password_flag` verifies rejects direct password flag. It belongs to cp-installer and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-installer::rejects_direct_password_flag | behavior_explanation |
cp-installer::interactive_setup_uses_prompted_values::explain_behavior |
#[test]
fn interactive_setup_uses_prompted_values() -> Result<(), Box<dyn std::error::Error>> {
let root = temp_root("interactive-values")?;
let data_dir = root.join("data");
let config_dir = root.join("config");
let args = CliArgs::parse(["--install-service".to_owned()])?;
... | Explain what the Rust test `interactive_setup_uses_prompted_values` verifies. | The test `interactive_setup_uses_prompted_values` verifies interactive setup uses prompted values. It belongs to cp-installer and covers domains: general. Observed statuses: none; error codes: none; assertions: 5. | cp-installer::interactive_setup_uses_prompted_values | behavior_explanation |
cp-installer::interactive_setup_rejects_password_confirmation_mismatch::explain_behavior |
#[test]
fn interactive_setup_rejects_password_confirmation_mismatch()
-> Result<(), Box<dyn std::error::Error>> {
let root = temp_root("interactive-mismatch")?;
let input = format!(
"\n{}\n{}\n0.0.0.0:7400\nlan=udp://192.0.2.20:7400\n\nowner\nn\n",
root.join("data").... | Explain what the Rust test `interactive_setup_rejects_password_confirmation_mismatch` verifies. | The test `interactive_setup_rejects_password_confirmation_mismatch` verifies interactive setup rejects password confirmation mismatch. It belongs to cp-installer and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-installer::interactive_setup_rejects_password_confirmation_mismatch | behavior_explanation |
cp-installer::linux_plan_validates_default_layout::explain_behavior |
#[test]
fn linux_plan_validates_default_layout() -> Result<(), Box<dyn std::error::Error>> {
let plan = plan()?;
plan.validate()?;
assert_eq!(plan.platform, InstallPlatform::LinuxSystemd);
assert_eq!(plan.actions.len(), 11);
assert!(plan.env_file.contains("CP_NODE_ID=co... | Explain what the Rust test `linux_plan_validates_default_layout` verifies. | The test `linux_plan_validates_default_layout` verifies linux plan validates default layout. It belongs to cp-installer and covers domains: general. Observed statuses: none; error codes: none; assertions: 5. | cp-installer::linux_plan_validates_default_layout | behavior_explanation |
cp-installer::macos_plan_builds_valid_plist::explain_behavior |
#[test]
fn macos_plan_builds_valid_plist() -> Result<(), Box<dyn std::error::Error>> {
let plan = MacOsPlan::build(MacOsInstallConfig::default_for_source_binary(
"target/release/cp-daemon",
))?;
plan.validate()?;
assert_eq!(plan.platform, InstallPlatform::MacOsLaunc... | Explain what the Rust test `macos_plan_builds_valid_plist` verifies. | The test `macos_plan_builds_valid_plist` verifies macos plan builds valid plist. It belongs to cp-installer and covers domains: general. Observed statuses: none; error codes: none; assertions: 7. | cp-installer::macos_plan_builds_valid_plist | behavior_explanation |
cp-installer::macos_plan_stages_files::explain_behavior |
#[test]
fn macos_plan_stages_files() -> Result<(), Box<dyn std::error::Error>> {
let dir = test_dir("macos-stage")?;
let source = dir.join("cp-daemon-source");
fs::create_dir_all(&dir)?;
write_linux_source_binaries(&source)?;
let plan = MacOsPlan::build(MacOsInstallConfi... | Explain what the Rust test `macos_plan_stages_files` verifies. | The test `macos_plan_stages_files` verifies macos plan stages files. It belongs to cp-installer and covers domains: general. Observed statuses: none; error codes: none; assertions: 6. | cp-installer::macos_plan_stages_files | behavior_explanation |
cp-installer::macos_launchd_plan_validates_absolute_paths::explain_behavior |
#[test]
fn macos_launchd_plan_validates_absolute_paths() {
let mut config = MacOsInstallConfig::default_for_source_binary("target/release/cp-daemon");
config.launchd_plist_dir = PathBuf::from("Library/LaunchDaemons");
assert!(matches!(
MacOsPlan::build(config),
... | Explain what the Rust test `macos_launchd_plan_validates_absolute_paths` verifies. | The test `macos_launchd_plan_validates_absolute_paths` verifies macos launchd plan validates absolute paths. It belongs to cp-installer and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-installer::macos_launchd_plan_validates_absolute_paths | behavior_explanation |
cp-installer::windows_plan_stages_files::explain_behavior |
#[test]
fn windows_plan_stages_files() -> Result<(), Box<dyn std::error::Error>> {
let dir = test_dir("windows-stage")?;
let source = dir.join("cp-daemon-source.exe");
fs::create_dir_all(&dir)?;
fs::write(&source, b"binary")?;
let plan = WindowsPlan::build(WindowsInstall... | Explain what the Rust test `windows_plan_stages_files` verifies. | The test `windows_plan_stages_files` verifies windows plan stages files. It belongs to cp-installer and covers domains: general. Observed statuses: none; error codes: none; assertions: 6. | cp-installer::windows_plan_stages_files | behavior_explanation |
cp-installer::dpapi_unavailable_on_non_windows::explain_behavior | #[test]
fn dpapi_unavailable_on_non_windows() {
let store = DpapiStore::new();
assert!(matches!(
store.protect(b"secret-value"),
Err(DpapiError::PlatformUnsupported)
));
assert!(matches!(
store.unprotect(b"ciphertext"),
Err(DpapiEr... | Explain what the Rust test `dpapi_unavailable_on_non_windows` verifies. | The test `dpapi_unavailable_on_non_windows` verifies dpapi unavailable on non windows. It belongs to cp-installer and covers domains: support. Observed statuses: none; error codes: none; assertions: 2. | cp-installer::dpapi_unavailable_on_non_windows | behavior_explanation |
cp-installer::windows_plan_validates_paths::explain_behavior |
#[test]
fn windows_plan_validates_paths() {
let mut config =
WindowsInstallConfig::default_for_source_binary("target/release/cp-daemon.exe");
config.install_prefix = PathBuf::from("Program Files\\Context Primitive");
assert!(matches!(
WindowsPlan::build(config),... | Explain what the Rust test `windows_plan_validates_paths` verifies. | The test `windows_plan_validates_paths` verifies windows plan validates paths. It belongs to cp-installer and covers domains: general. Observed statuses: none; error codes: none; assertions: 1. | cp-installer::windows_plan_validates_paths | behavior_explanation |
cp-installer::keychain_unavailable_on_non_macos::explain_behavior | #[test]
fn keychain_unavailable_on_non_macos() -> Result<(), Box<dyn std::error::Error>> {
let store = KeychainStore::new("context-primitive-test")?;
assert!(matches!(
store.store_node_secret("node-local", "secret-value"),
Err(KeychainError::PlatformUnsupported)
... | Explain what the Rust test `keychain_unavailable_on_non_macos` verifies. | The test `keychain_unavailable_on_non_macos` verifies keychain unavailable on non macos. It belongs to cp-installer and covers domains: support. Observed statuses: none; error codes: none; assertions: 3. | cp-installer::keychain_unavailable_on_non_macos | behavior_explanation |
End of preview.
Context Primitive Code-Agent Pack v0 — Free Funnel
Free product-specific instruction / Q&A seed material from Primitive Origins’ Context Primitive / Foundry tests.
This is a marketing / companion corpus for the Context Primitive stack — not a general public code-agent marketplace hero SKU.
What’s inside
JSONL splits under data/:
behavior_qa.train.jsonl/.eval.jsonlinstruction_test_generation.train.jsonl/.eval.jsonlfoundry/python_test_generation.*foundry/symbol_explanations.*rbac_matrix.jsonl
License
Custom commercial AI training license (LICENSE):
- Train / fine-tune / eval / commercial models: YES
- Dataset redistrib / resale / re-host: NO
- South Carolina, USA
Related
- Paid lead SKU sample: CP Agent Failure & Recovery v0.3.1 (Free Sample)
- Sibling free: Vigil Governance Traces v0 · AML Routing Benchmark v0 · OriginsLynk RealWork v1 (Sample)
Limitations
- Tied to Context Primitive / Foundry implementation details.
- Scrubbed owner material; not a multi-repo SWE-bench replacement.
- Prefer the CP failure/recovery pack for general agent reliability experiments.
Citation
Context Primitive Code-Agent Pack v0, Primitive Origins LLC.
- Downloads last month
- 23