fixup: canister query

Author: Hans Larsen

dfx/src/commands/call.rs

@@ -30,31 +30,24 @@ where
     let name = args.value_of(NAME_ARG).unwrap();
     let client = env.get_client();
 
-    let query = query(
-        client,
-        CanisterQueryCall {
-            canister_id: 42,
-            method_name: "greet".to_string(),
-            arg: Blob(Vec::from(name)),
-        },
-    )
-    .and_then(|r| match r {
-        ReadResponse::Pending => {
-            println!("Pending");
-            ok(())
-        }
-        ReadResponse::Replied {
-            reply: QueryResponseReply { arg: Blob(blob) },
-        } => {
-            println!("{}", String::from_utf8_lossy(&blob));
-            ok(())
-        }
-        ReadResponse::Rejected {
-            reject_code,
-            reject_message,
-        } => err(DfxError::ClientError(reject_code, reject_message)),
-        ReadResponse::Unknown => err(DfxError::Unknown("Unknown response".to_owned())),
-    });
+    let query =
+        query(client, 42, "greet".to_string(), Some(Blob(Vec::from(name)))).and_then(|r| match r {
+            ReadResponse::Pending => {
+                println!("Pending");
+                ok(())
+            }
+            ReadResponse::Replied {
+                reply: QueryResponseReply { arg: Blob(blob) },
+            } => {
+                println!("{}", String::from_utf8_lossy(&blob));
+                ok(())
+            }
+            ReadResponse::Rejected {
+                reject_code,
+                reject_message,
+            } => err(DfxError::ClientError(reject_code, reject_message)),
+            ReadResponse::Unknown => err(DfxError::Unknown("Unknown response".to_owned())),
+        });
 
     let mut runtime = Runtime::new().expect("Unable to create a runtime");
     runtime.block_on(query)

dfx/src/commands/canister/query.rs

@@ -1,4 +1,4 @@
-use crate::lib::api_client::{query, Blob, CanisterQueryCall, QueryResponseReply, ReadResponse};
+use crate::lib::api_client::{query, Blob, QueryResponseReply, ReadResponse};
 use crate::lib::env::ClientEnv;
 use crate::lib::error::{DfxError, DfxResult};
 use crate::lib::CanisterId;
@@ -41,13 +41,9 @@ where
     let client = env.get_client();
     let install = query(
         client,
-        CanisterQueryCall {
-            canister_id,
-            method_name: method_name.to_owned(),
-            arg: arguments
-                .map(|args| Blob(Vec::from(args[0])))
-                .unwrap_or_else(|| Blob(vec![])),
-        },
+        canister_id,
+        method_name.to_owned(),
+        arguments.map(|args| Blob(Vec::from(args[0]))),
     );
 
     let mut runtime = Runtime::new().expect("Unable to create a runtime");

dfx/src/lib/api_client.rs

@@ -176,9 +176,20 @@ fn submit(
 /// returns the canister’s response directly within the HTTP response.
 pub fn query(
     client: Client,
-    request: CanisterQueryCall,
+    canister_id: CanisterId,
+    method_name: String,
+    arg: Option<Blob>,
 ) -> impl Future<Item = ReadResponse<QueryResponseReply>, Error = DfxError> {
-    read(client, ReadRequest::Query { request })
+    read(
+        client,
+        ReadRequest::Query {
+            request: CanisterQueryCall {
+                canister_id,
+                method_name,
+                arg: arg.unwrap_or_else(|| Blob(vec![])),
+            },
+        },
+    )
 }
 
 /// Canister Install call
@@ -358,14 +369,7 @@ mod tests {
             url: mockito::server_url(),
         });
 
-        let query = query(
-            client,
-            CanisterQueryCall {
-                canister_id: 1,
-                method_name: "main".to_string(),
-                arg: Blob(vec![]),
-            },
-        );
+        let query = query(client, 1, "main".to_string(), Some(Blob(vec![])));
 
         let mut runtime = tokio::runtime::Runtime::new().expect("Unable to create a runtime");
         let result = runtime.block_on(query);
@@ -430,14 +434,7 @@ mod tests {
             url: mockito::server_url(),
         });
 
-        let query = query(
-            client,
-            CanisterQueryCall {
-                canister_id: 1,
-                method_name: "main".to_string(),
-                arg: Blob(vec![]),
-            },
-        );
+        let query = query(client, 1, "main".to_string(), Some(Blob(vec![])));
 
         let mut runtime = tokio::runtime::Runtime::new().expect("Unable to create a runtime");
         let result = runtime.block_on(query);