Add test for single item update action cache

Cargo.toml

@@ -22,6 +22,7 @@ clap = "2.33.3"
 stdext = "0.2.1"
 prost-build = "0.6.1"
 tonic-build = "0.3.1"
+pretty_assertions = "0.6.1"
 rustfmt-nightly = "1.4.21"
 futures-core = "0.3.8"
 

cas/grpc_service/BUILD

@@ -63,6 +63,7 @@ rust_test(
         "//proto",
         "//third_party:tonic",
         "//third_party:tokio",
+        "//third_party:pretty_assertions",
     ],
 )
 
@@ -77,5 +78,6 @@ rust_test(
         "//third_party:tonic",
         "//third_party:tokio",
         "//third_party:prost",
+        "//third_party:pretty_assertions",
     ],
 )

cas/grpc_service/tests/ac_server_test.rs

@@ -15,26 +15,27 @@ use store::{create_store, Store, StoreType};
 const INSTANCE_NAME: &str = "foo";
 const HASH1: &str = "0123456789abcdef000000000000000000000000000000000123456789abcdef";
 
+async fn insert_into_store<T: Message>(
+    store: &dyn Store,
+    hash: &str,
+    action_result: &T,
+) -> Result<i64, Error> {
+    let mut store_data = Vec::new();
+    action_result.encode(&mut store_data)?;
+    let digest_size = store_data.len() as i64;
+    store
+        .update(&hash, store_data.len(), Box::new(Cursor::new(store_data)))
+        .await?;
+    Ok(digest_size)
+}
+
 #[cfg(test)]
 mod get_action_results {
     use super::*;
+    use pretty_assertions::assert_eq; // Must be declared in every module.
 
     use proto::build::bazel::remote::execution::v2::GetActionResultRequest;
 
-    async fn insert_into_store<T: Message>(
-        store: &dyn Store,
-        hash: &str,
-        action_result: &T,
-    ) -> Result<i64, Error> {
-        let mut store_data = Vec::new();
-        action_result.encode(&mut store_data)?;
-        let digest_size = store_data.len() as i64;
-        store
-            .update(&hash, store_data.len(), Box::new(Cursor::new(store_data)))
-            .await?;
-        Ok(digest_size)
-    }
-
     async fn get_action_result(
         ac_server: &AcServer,
         hash: &str,
@@ -105,3 +106,70 @@ mod get_action_results {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod update_action_result {
+    use super::*;
+    use pretty_assertions::assert_eq; // Must be declared in every module.
+
+    use proto::build::bazel::remote::execution::v2::UpdateActionResultRequest;
+
+    fn get_encoded_proto_size<T: Message>(proto: &T) -> Result<usize, Error> {
+        let mut store_data = Vec::new();
+        proto.encode(&mut store_data)?;
+        Ok(store_data.len())
+    }
+
+    async fn update_action_result(
+        ac_server: &AcServer,
+        digest: Digest,
+        action_result: ActionResult,
+    ) -> Result<Response<ActionResult>, Status> {
+        ac_server
+            .update_action_result(Request::new(UpdateActionResultRequest {
+                instance_name: INSTANCE_NAME.to_string(),
+                action_digest: Some(digest),
+                action_result: Some(action_result),
+                results_cache_policy: None,
+            }))
+            .await
+    }
+
+    #[tokio::test]
+    #[ignore]
+    async fn one_item_update_test() -> Result<(), Error> {
+        let ac_store = create_store(&StoreType::Memory);
+        let ac_server = AcServer::new(ac_store.clone(), create_store(&StoreType::Memory));
+
+        let mut action_result = ActionResult::default();
+        action_result.exit_code = 45;
+
+        let size_bytes = get_encoded_proto_size(&action_result)?;
+
+        let raw_response = update_action_result(
+            &ac_server,
+            Digest {
+                hash: HASH1.to_string(),
+                size_bytes: size_bytes as i64,
+            },
+            action_result.clone(),
+        )
+        .await;
+
+        assert!(
+            raw_response.is_ok(),
+            "Expected success, got error {:?}",
+            raw_response
+        );
+        assert_eq!(raw_response.unwrap().into_inner(), action_result);
+
+        let mut raw_data = Vec::new();
+        ac_store
+            .get(&HASH1, size_bytes, &mut Cursor::new(&mut raw_data))
+            .await?;
+
+        let decoded_action_result = ActionResult::decode(Cursor::new(&raw_data))?;
+        assert_eq!(decoded_action_result, action_result);
+        Ok(())
+    }
+}

cas/grpc_service/tests/cas_server_test.rs

@@ -19,6 +19,7 @@ const BAD_HASH: &str = "BAD_HASH";
 #[cfg(test)]
 mod find_missing_blobs {
     use super::*;
+    use pretty_assertions::assert_eq; // Must be declared in every module.
 
     use std::io::Cursor;
 
@@ -113,6 +114,7 @@ mod find_missing_blobs {
 #[cfg(test)]
 mod batch_update_blobs {
     use super::*;
+    use pretty_assertions::assert_eq; // Must be declared in every module.
 
     use std::io::Cursor;
 
@@ -178,6 +180,7 @@ mod batch_update_blobs {
 #[cfg(test)]
 mod batch_read_blobs {
     use super::*;
+    use pretty_assertions::assert_eq; // Must be declared in every module.
 
     use std::io::Cursor;
 
@@ -268,6 +271,7 @@ mod batch_read_blobs {
 #[cfg(test)]
 mod end_to_end {
     use super::*;
+    use pretty_assertions::assert_eq; // Must be declared in every module.
 
     use proto::build::bazel::remote::execution::v2::{
         batch_update_blobs_request, batch_update_blobs_response, BatchUpdateBlobsRequest,

cas/store/BUILD

@@ -46,5 +46,6 @@ rust_test(
         ":traits",
         "//third_party:tokio",
         "//third_party:tokio_test",
+        "//third_party:pretty_assertions",
     ],
 )

cas/store/tests/memory_store_test.rs

@@ -2,6 +2,8 @@
 
 #[cfg(test)]
 mod memory_store_tests {
+    use pretty_assertions::assert_eq; // Must be declared in every module.
+
     use std::io::Cursor;
     use tokio::io::Error;
     use tokio_test::assert_err;

third_party/BUILD.bazel

@@ -57,6 +57,15 @@ alias(
     ],
 )
 
+alias(
+    name = "pretty_assertions",
+    actual = "@raze__pretty_assertions__0_6_1//:pretty_assertions",
+    tags = [
+        "cargo-raze",
+        "manual",
+    ],
+)
+
 alias(
     name = "prost",
     actual = "@raze__prost__0_6_1//:prost",