Fix #1265

golem-worker-executor-base/tests/rust_rpc_stubless.rs

@@ -1143,3 +1143,65 @@ async fn ephemeral_worker_invocation_via_rpc1(
         _ => panic!("Unexpected result value"),
     }
 }
+
+#[test]
+#[tracing::instrument]
+async fn golem_bug_1265_test(
+    last_unique_id: &LastUniqueId,
+    deps: &WorkerExecutorTestDependencies,
+    _tracing: &Tracing,
+) {
+    let context = TestContext::new(last_unique_id);
+    let executor = start(deps, &context).await.unwrap();
+
+    let counters_component_id = executor.store_component("counters").await;
+    let caller_component_id = executor
+        .store_component_with_dynamic_linking(
+            "caller",
+            &[
+                (
+                    "rpc:counters-client/counters-client",
+                    DynamicLinkedInstance::WasmRpc(DynamicLinkedWasmRpc {
+                        target_interface_name: HashMap::from_iter(vec![
+                            ("api".to_string(), "rpc:counters-exports/api".to_string()),
+                            (
+                                "counter".to_string(),
+                                "rpc:counters-exports/api".to_string(),
+                            ),
+                        ]),
+                    }),
+                ),
+                (
+                    "rpc:ephemeral-client/ephemeral-client",
+                    DynamicLinkedInstance::WasmRpc(DynamicLinkedWasmRpc {
+                        target_interface_name: HashMap::from_iter(vec![(
+                            "api".to_string(),
+                            "rpc:ephemeral-exports/api".to_string(),
+                        )]),
+                    }),
+                ),
+            ],
+        )
+        .await;
+
+    let mut env = HashMap::new();
+    env.insert(
+        "COUNTERS_COMPONENT_ID".to_string(),
+        counters_component_id.to_string(),
+    );
+    let caller_worker_id = executor
+        .start_worker_with(&caller_component_id, "rpc-counters-bug1265", vec![], env)
+        .await;
+
+    let result = executor
+        .invoke_and_await(
+            &caller_worker_id,
+            "rpc:caller-exports/caller-inline-functions.{bug-golem1265}",
+            vec![Value::String("test".to_string())],
+        )
+        .await;
+
+    drop(executor);
+
+    check!(result == Ok(vec![Value::Result(Ok(None))]));
+}

test-components/rpc/caller/src/lib.rs

@@ -116,6 +116,17 @@ impl Guest for Component {
 
         vec![(name1, key1), (name2, key2), (name3, key3)]
     }
+
+    fn bug_golem1265(s: String) -> Result<(), String> {
+        println!("Reproducer for golem issue #1265");
+        let component_id =
+            env::var("COUNTERS_COMPONENT_ID").expect("COUNTERS_COMPONENT_ID not set");
+        let counters_uri = Uri {
+            value: format!("urn:worker:{component_id}/bug1265"),
+        };
+        let api = Api::new(&counters_uri);
+        api.blocking_bug_golem1265(&s)
+    }
 }
 
 fn create_use_and_drop_counters(counters_uri: &Uri) {

test-components/rpc/caller/wit/caller.wit

@@ -12,4 +12,6 @@ world caller {
   export bug-wasm-rpc-i32: func(in: timeline-node) -> timeline-node;
 
   export ephemeral-test1: func() -> list<tuple<string, string>>;
+
+  export bug-golem1265: func(s: string) -> result<_, string>;
 }

test-components/rpc/counters/src/lib.rs

@@ -42,6 +42,11 @@ impl Guest for Component {
     fn bug_wasm_rpc_i32(in_: TimelineNode) -> TimelineNode {
         in_
     }
+
+    fn bug_golem1265(s: String) -> Result<(), String> {
+        eprintln!("Got {s}");
+        Ok(())
+    }
 }
 
 pub struct Counter {

test-components/rpc/counters/wit/counters.wit

@@ -20,6 +20,8 @@ interface api {
   }
 
   bug-wasm-rpc-i32: func(in: timeline-node) -> timeline-node;
+
+  bug-golem1265: func(s: string) -> result<_, string>;
 }
 
 world counters {

wasm-rpc/src/wasmtime.rs

@@ -348,14 +348,21 @@ async fn decode_param_impl(
         Type::Result(ty) => match param {
             Value::Result(result) => match result {
                 Ok(value) => {
-                    let ok_ty = ty.ok().ok_or(EncodingError::ValueMismatch {
-                        details: format!("in {context} could not get ok type"),
-                    })?;
                     let decoded_value = match value {
-                        Some(v) => Some(
-                            decode_param_impl(v, &ok_ty, resource_store, &format!("{context}.ok"))
+                        Some(v) => {
+                            let ok_ty = ty.ok().ok_or(EncodingError::ValueMismatch {
+                                details: format!("in {context} could not get ok type"),
+                            })?;
+                            Some(
+                                decode_param_impl(
+                                    v,
+                                    &ok_ty,
+                                    resource_store,
+                                    &format!("{context}.ok"),
+                                )
                                 .await?,
-                        ),
+                            )
+                        }
                         None => None,
                     };
                     match decoded_value {
@@ -367,19 +374,21 @@ async fn decode_param_impl(
                     }
                 }
                 Err(value) => {
-                    let err_ty = ty.err().ok_or(EncodingError::ValueMismatch {
-                        details: format!("in {context} could not get err type"),
-                    })?;
                     let decoded_value = match value {
-                        Some(v) => Some(
-                            decode_param_impl(
-                                v,
-                                &err_ty,
-                                resource_store,
-                                &format!("{context}.err"),
+                        Some(v) => {
+                            let err_ty = ty.err().ok_or(EncodingError::ValueMismatch {
+                                details: format!("in {context} could not get err type"),
+                            })?;
+                            Some(
+                                decode_param_impl(
+                                    v,
+                                    &err_ty,
+                                    resource_store,
+                                    &format!("{context}.err"),
+                                )
+                                .await?,
                             )
-                            .await?,
-                        ),
+                        }
                         None => None,
                     };