fix(mock): port MockPlatform + through-core tests onto rewritten #104

Adapt the mock platform to #104's async_trait capability traits and
truapi::latest types: add #[async_trait] to each capability impl, flatten
feature_supported to bare v01 request/response types, update
CoreStorageKey::PermissionAuthorization to { product_id, request }, and add
JsonRpcConnection::close.

Fix the through-core preimage + storage-fault tests to assert the Result
discriminant at wire byte 1: the versioned envelope is
[version_index, result_discriminant, ..inner], and V1's version index is 0,
so the Ok/Err distinction lives at byte 1, not byte 0.

Author: decrypto21

rust/crates/truapi-platform/src/mock.rs

@@ -29,8 +29,8 @@ use futures::StreamExt;
 use futures::stream::{self, BoxStream};
 
 use truapi::v01;
-use truapi::versioned::system::{HostFeatureSupportedRequest, HostFeatureSupportedResponse};
 
+use crate::async_trait;
 use crate::{
     AuthPresenter, AuthState, ChainProvider, CoreStorage, CoreStorageKey, Features,
     JsonRpcConnection, Navigation, Notifications, Permissions, PreimageHost, ProductStorage,
@@ -254,9 +254,10 @@ fn core_key(key: &CoreStorageKey) -> String {
     match key {
         CoreStorageKey::AuthSession => "core:auth-session".to_string(),
         CoreStorageKey::PairingDeviceIdentity => "core:pairing-device-identity".to_string(),
-        CoreStorageKey::PermissionAuthorization { storage_key } => {
-            format!("core:permission:{storage_key}")
-        }
+        CoreStorageKey::PermissionAuthorization {
+            product_id,
+            request,
+        } => format!("core:permission:{product_id}:{request:?}"),
     }
 }
 
@@ -268,6 +269,7 @@ fn preimage_key(value: &[u8]) -> Vec<u8> {
     hasher.finish().to_le_bytes().to_vec()
 }
 
+#[async_trait]
 impl ProductStorage for MockPlatform {
     async fn read(&self, key: String) -> Result<Option<Vec<u8>>, v01::HostLocalStorageReadError> {
         if let Some(reason) = &self.config.faults.storage_error {
@@ -314,6 +316,7 @@ impl ProductStorage for MockPlatform {
     }
 }
 
+#[async_trait]
 impl CoreStorage for MockPlatform {
     async fn read_core_storage(
         &self,
@@ -363,6 +366,7 @@ impl CoreStorage for MockPlatform {
     }
 }
 
+#[async_trait]
 impl Navigation for MockPlatform {
     async fn navigate_to(&self, url: String) -> Result<(), v01::HostNavigateToError> {
         if let Some(reason) = &self.config.faults.navigate_error {
@@ -378,6 +382,7 @@ impl Navigation for MockPlatform {
     }
 }
 
+#[async_trait]
 impl Notifications for MockPlatform {
     async fn push_notification(
         &self,
@@ -405,6 +410,7 @@ impl Notifications for MockPlatform {
     }
 }
 
+#[async_trait]
 impl Permissions for MockPlatform {
     async fn device_permission(
         &self,
@@ -425,17 +431,15 @@ impl Permissions for MockPlatform {
     }
 }
 
+#[async_trait]
 impl Features for MockPlatform {
     async fn feature_supported(
         &self,
-        request: HostFeatureSupportedRequest,
-    ) -> Result<HostFeatureSupportedResponse, v01::GenericError> {
-        let HostFeatureSupportedRequest::V1(_) = request;
-        Ok(HostFeatureSupportedResponse::V1(
-            v01::HostFeatureSupportedResponse {
-                supported: self.config.feature_supported,
-            },
-        ))
+        _request: v01::HostFeatureSupportedRequest,
+    ) -> Result<v01::HostFeatureSupportedResponse, v01::GenericError> {
+        Ok(v01::HostFeatureSupportedResponse {
+            supported: self.config.feature_supported,
+        })
     }
 }
 
@@ -457,8 +461,11 @@ impl JsonRpcConnection for MockConnection {
             Some(frames) => Box::pin(stream::iter(frames.clone())),
         }
     }
+
+    fn close(&self) {}
 }
 
+#[async_trait]
 impl ChainProvider for MockPlatform {
     async fn connect(
         &self,
@@ -493,6 +500,7 @@ impl AuthPresenter for MockPlatform {
     }
 }
 
+#[async_trait]
 impl UserConfirmation for MockPlatform {
     async fn confirm_user_action(
         &self,
@@ -519,6 +527,7 @@ impl ThemeHost for MockPlatform {
     }
 }
 
+#[async_trait]
 impl PreimageHost for MockPlatform {
     async fn submit_preimage(&self, value: Vec<u8>) -> Result<Vec<u8>, v01::PreimageSubmitError> {
         if let Some(reason) = &self.config.faults.preimage_submit_error {
@@ -610,12 +619,7 @@ mod tests {
         // ...and a product key must not be visible through core storage.
         block_on(p.write("x".into(), vec![2])).unwrap();
         assert_eq!(
-            block_on(
-                p.read_core_storage(CoreStorageKey::PermissionAuthorization {
-                    storage_key: "x".into()
-                })
-            )
-            .unwrap(),
+            block_on(p.read_core_storage(CoreStorageKey::PairingDeviceIdentity)).unwrap(),
             None
         );
     }
@@ -744,11 +748,11 @@ mod tests {
             feature_supported: false,
             ..Default::default()
         });
-        let HostFeatureSupportedResponse::V1(response) = block_on(p.feature_supported(
-            HostFeatureSupportedRequest::V1(v01::HostFeatureSupportedRequest::Chain {
+        let response = block_on(
+            p.feature_supported(v01::HostFeatureSupportedRequest::Chain {
                 genesis_hash: vec![0; 32],
             }),
-        ))
+        )
         .unwrap();
         assert!(!response.supported);
     }

rust/crates/truapi-server/src/core.rs

@@ -509,16 +509,22 @@ mod tests {
         use truapi::versioned::preimage::RemotePreimageSubmitRequest;
         use truapi_platform::mock::MockConfig;
 
-        // Default mock auto-confirms: submit succeeds (Ok disc 0x00).
+        // Versioned envelope layout is [version_index, result_discriminant, ..].
+        // For a V1 response the version index is 0, so the Ok/Err distinction
+        // lives at byte index 1: 0x00 = Ok, 0x01 = Err.
+
+        // Default mock auto-confirms: submit succeeds (V1 index 0x00, Ok 0x00).
         let confirmed = make_mock_core(MockConfig::default());
         let ok_payload = run_request(
             &confirmed,
             "preimage_submit",
             RemotePreimageSubmitRequest::V1(vec![1, 2, 3]).encode(),
         );
         assert_eq!(ok_payload.first(), Some(&0x00));
+        assert_eq!(ok_payload.get(1), Some(&0x00));
 
-        // confirm_user_actions = false: the core rejects before the platform (Err disc 0x01).
+        // confirm_user_actions = false: the core rejects before the platform
+        // (V1 index 0x00, Err 0x01).
         let rejected = make_mock_core(MockConfig {
             confirm_user_actions: false,
             ..Default::default()
@@ -528,7 +534,8 @@ mod tests {
             "preimage_submit",
             RemotePreimageSubmitRequest::V1(vec![1, 2, 3]).encode(),
         );
-        assert_eq!(err_payload.first(), Some(&0x01));
+        assert_eq!(err_payload.first(), Some(&0x00));
+        assert_eq!(err_payload.get(1), Some(&0x01));
     }
 
     /// A MockPlatform storage fault surfaces through the real core as a wire
@@ -546,9 +553,11 @@ mod tests {
         });
         let read =
             HostLocalStorageReadRequest::V1(v01::HostLocalStorageReadRequest { key: "k".into() });
-        // Err envelope: Result discriminant 0x01 (vs 0x00 Ok in the happy-path test).
+        // Versioned wire layout is [version_index=0x00 (V1)][result_index][inner];
+        // the Err discriminant is byte 1, not byte 0 (byte 0 is the V1 version index).
         let payload = run_request(&core, "local_storage_read", read.encode());
-        assert_eq!(payload.first(), Some(&0x01));
+        assert_eq!(payload.first(), Some(&0x00)); // V1 version index
+        assert_eq!(payload.get(1), Some(&0x01)); // Result::Err discriminant
     }
 
     #[test]