Fix integration tests, CI (#206)

Author: giarc3

.github/workflows/rust-daily.yaml

@@ -3,8 +3,12 @@ on:
   schedule:
     - cron: 0 14 * * 1-5
   workflow_dispatch:
+  # rust-daily does a more thorough check of all features and all targets.
+  # Without this, we would miss checking the tests with the `integration_tests` feature
+  # flag, which we don't run because it requires a running TSP.
+  pull_request: null
 
 jobs:
   rust-daily:
-    uses: IronCoreLabs/workflows/.github/workflows/rust-daily.yaml@rust-daily-v0
+    uses: IronCoreLabs/workflows/.github/workflows/rust-daily.yaml@rust-daily-v1
     secrets: inherit

tests/deterministic.rs

@@ -85,7 +85,7 @@ mod tests {
             .deterministic()
             .encrypt_batch(fields, &metadata)
             .await?;
-        assert_eq!(encrypted.successes.len(), 2);
+        assert_eq!(encrypted.successes.0.len(), 2);
         assert_eq!(encrypted.failures.len(), 0);
         let bad_encrypted = EncryptedField {
             encrypted_field: vec![1, 1, 1].into(),
@@ -94,14 +94,14 @@ mod tests {
         };
         let encrypted_fields = EncryptedFields(
             iter::once((FieldId("bad_doc".to_string()), bad_encrypted))
-                .chain(encrypted.successes)
+                .chain(encrypted.successes.0)
                 .collect(),
         );
         let decrypted = get_client()
             .deterministic()
             .decrypt_batch(encrypted_fields, &metadata)
             .await?;
-        assert_eq!(decrypted.successes.len(), 2);
+        assert_eq!(decrypted.successes.0.len(), 2);
         assert_eq!(decrypted.failures.len(), 1);
         assert!(matches!(
             decrypted
@@ -113,6 +113,7 @@ mod tests {
         assert_eq!(
             decrypted
                 .successes
+                .0
                 .get(&FieldId("field".to_string()))
                 .unwrap()
                 .plaintext_field,

tests/standard.rs

@@ -134,7 +134,7 @@ mod tests {
             .standard()
             .encrypt_batch(documents, &metadata)
             .await?;
-        assert_eq!(encrypted.successes.len(), 1);
+        assert_eq!(encrypted.successes.0.len(), 1);
         assert_eq!(encrypted.failures.len(), 0);
         let second_document = get_v3_ciphertext();
         let bad_document = EncryptedDocument {
@@ -144,6 +144,7 @@ mod tests {
         let new_encrypted = EncryptedDocuments(
             encrypted
                 .successes
+                .0
                 .into_iter()
                 .chain([
                     (DocumentId("v3_doc".to_string()), second_document),
@@ -155,18 +156,20 @@ mod tests {
             .standard()
             .decrypt_batch(new_encrypted, &metadata)
             .await?;
-        assert_eq!(decrypted.successes.len(), 2);
+        assert_eq!(decrypted.successes.0.len(), 2);
         assert_eq!(decrypted.failures.len(), 1);
         assert_eq!(
             decrypted
                 .successes
+                .0
                 .get(&DocumentId("doc".to_string()))
                 .unwrap(),
             &get_plaintext()
         );
         let decrypted_v3 = from_utf8(
             &decrypted
                 .successes
+                .0
                 .get(&DocumentId("v3_doc".to_string()))
                 .unwrap()
                 .0
@@ -234,13 +237,14 @@ mod tests {
             .standard()
             .encrypt_with_existing_edek_batch(plaintexts, &metadata)
             .await?;
-        assert_eq!(batch_encrypted.successes.len(), 1);
+        assert_eq!(batch_encrypted.successes.0.len(), 1);
         assert_eq!(batch_encrypted.failures.len(), 0);
         let decrypted = get_client()
             .standard()
             .decrypt(
                 batch_encrypted
                     .successes
+                    .0
                     .remove(&DocumentId("doc".to_string()))
                     .unwrap(),
                 &metadata,

tests/standard_attached.rs

@@ -103,29 +103,33 @@ mod tests {
         let plaintext = get_plaintext();
         let metadata = get_metadata();
         let documents: PlaintextAttachedDocuments =
-            [(DocumentId("doc".to_string()), plaintext)].into();
+            PlaintextAttachedDocuments([(DocumentId("doc".to_string()), plaintext)].into());
         let encrypted = get_client()
             .standard_attached()
             .encrypt_batch(documents, &metadata)
             .await?;
-        assert_eq!(encrypted.successes.len(), 1);
+        assert_eq!(encrypted.successes.0.len(), 1);
         assert_eq!(encrypted.failures.len(), 0);
         let bad_document =
             EncryptedAttachedDocument(EncryptedBytes(vec![0, 0, 1, 255, 2, 0, 0, 2, 10, 36]));
-        let new_encrypted: EncryptedAttachedDocuments = encrypted
-            .successes
-            .into_iter()
-            .chain([(DocumentId("bad_doc".to_string()), bad_document)])
-            .collect();
+        let new_encrypted: EncryptedAttachedDocuments = EncryptedAttachedDocuments(
+            encrypted
+                .successes
+                .0
+                .into_iter()
+                .chain([(DocumentId("bad_doc".to_string()), bad_document)])
+                .collect(),
+        );
         let decrypted = get_client()
             .standard_attached()
             .decrypt_batch(new_encrypted, &metadata)
             .await?;
-        assert_eq!(decrypted.successes.len(), 1);
+        assert_eq!(decrypted.successes.0.len(), 1);
         assert_eq!(decrypted.failures.len(), 1);
         assert_eq!(
             decrypted
                 .successes
+                .0
                 .get(&DocumentId("doc".to_string()))
                 .unwrap(),
             &get_plaintext()
@@ -212,7 +216,7 @@ mod tests {
     async fn standard_attached_rekey_v5_edek_works() -> TestResult {
         let metadata = get_metadata();
         let doc = get_ciphertext();
-        let docs = [(DocumentId("doc".to_string()), doc)].into();
+        let docs = EncryptedAttachedDocuments([(DocumentId("doc".to_string()), doc)].into());
         let mut all_rekeyed = get_client()
             .standard_attached()
             .rekey_documents(docs, &metadata, None)
@@ -243,7 +247,7 @@ mod tests {
     async fn standard_attached_rekey_new_tenant_edek_works() -> TestResult {
         let metadata = get_metadata();
         let doc = get_ciphertext();
-        let docs = [(DocumentId("doc".to_string()), doc)].into();
+        let docs = EncryptedAttachedDocuments([(DocumentId("doc".to_string()), doc)].into());
         let new_tenant = TenantId("tenant-aws".to_string());
         let mut all_rekeyed = get_client()
             .standard_attached()

tests/vector.rs

@@ -92,7 +92,7 @@ mod tests {
             .vector()
             .encrypt_batch(vectors, &metadata)
             .await?;
-        assert_eq!(encrypted.successes.len(), 2);
+        assert_eq!(encrypted.successes.0.len(), 2);
         assert_eq!(encrypted.failures.len(), 0);
         let bad_encrypted = EncryptedVector {
             encrypted_vector: vec![1.0, 1.0, 1.0],
@@ -102,14 +102,14 @@ mod tests {
         };
         let encrypted_vectors = EncryptedVectors(
             iter::once((VectorId("bad_vector".to_string()), bad_encrypted))
-                .chain(encrypted.successes)
+                .chain(encrypted.successes.0)
                 .collect(),
         );
         let decrypted = get_client()
             .vector()
             .decrypt_batch(encrypted_vectors, &metadata)
             .await?;
-        assert_eq!(decrypted.successes.len(), 2);
+        assert_eq!(decrypted.successes.0.len(), 2);
         assert_eq!(decrypted.failures.len(), 1);
         assert!(matches!(
             decrypted
@@ -120,6 +120,7 @@ mod tests {
         ));
         let result = decrypted
             .successes
+            .0
             .get(&VectorId("vector".to_string()))
             .unwrap()
             .plaintext_vector