This is an automated email from the ASF dual-hosted git repository.

orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git


The following commit(s) were added to refs/heads/main by this push:
     new 5a19cc6  (chores) camel-couchdb: cleanup integration tests (#6310)
5a19cc6 is described below

commit 5a19cc6b8276a652ee0c77945ac2e819256338b2
Author: Otavio Rodolfo Piske <[email protected]>
AuthorDate: Wed Oct 20 16:01:22 2021 +0200

    (chores) camel-couchdb: cleanup integration tests (#6310)
---
 .../couchdb/integration/CouchDbCrudIT.java         | 384 ++++++++++++---------
 1 file changed, 229 insertions(+), 155 deletions(-)

diff --git 
a/components/camel-couchdb/src/test/java/org/apache/camel/component/couchdb/integration/CouchDbCrudIT.java
 
b/components/camel-couchdb/src/test/java/org/apache/camel/component/couchdb/integration/CouchDbCrudIT.java
index 6bdfc2c..9307f2e 100644
--- 
a/components/camel-couchdb/src/test/java/org/apache/camel/component/couchdb/integration/CouchDbCrudIT.java
+++ 
b/components/camel-couchdb/src/test/java/org/apache/camel/component/couchdb/integration/CouchDbCrudIT.java
@@ -29,18 +29,21 @@ import org.apache.camel.builder.RouteBuilder;
 import org.apache.camel.component.couchdb.CouchDbConstants;
 import org.apache.camel.component.couchdb.CouchDbOperations;
 import org.apache.camel.component.mock.MockEndpoint;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.TestInstance.Lifecycle;
 import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
-@TestMethodOrder(OrderAnnotation.class)
 @TestInstance(Lifecycle.PER_CLASS)
 public class CouchDbCrudIT extends CouchDbTestSupport {
 
@@ -68,167 +71,238 @@ public class CouchDbCrudIT extends CouchDbTestSupport {
         };
     }
 
-    @Order(1)
-    @Test
-    void jsonObjectDocumentCrudShouldTriggerUpdateAndDeleteNotifications() 
throws InterruptedException {
-        JsonObject testDocument
-                = new Gson().fromJson("{ \"randomString\" : 
\"36e8807f-0810-4b80-9ca9-b20859433034\" }", JsonObject.class);
-
-        // Creating a document should trigger an update notification
-        
mockUpdateNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"UPDATE");
-        mockUpdateNotifications.expectedMessageCount(1);
-        Exchange createExchange = template.request(couchDbIn, e -> {
-            e.getMessage().setBody(testDocument);
-        });
-        final String createdDocumentId = 
createExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_ID, 
String.class);
-        final String createdDocumentRevision
-                = 
createExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_REV, 
String.class);
-        assertNotNull(createdDocumentId);
-        assertNotNull(createdDocumentRevision);
-        mockUpdateNotifications.assertIsSatisfied();
-
-        // Consulting a created document should succeed
-        Map<String, Object> retrieveExchangeHeaders = new HashMap<>();
-        retrieveExchangeHeaders.put(CouchDbConstants.HEADER_DOC_ID, 
createdDocumentId);
-        retrieveExchangeHeaders.put(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.GET);
-        String retrievedDocumentString
-                = template.requestBodyAndHeaders(couchDbIn, testDocument, 
retrieveExchangeHeaders, String.class);
-        assertNotNull(retrievedDocumentString);
-        JsonObject retrievedDocument = new 
Gson().fromJson(retrievedDocumentString, JsonObject.class);
-        assertEquals("36e8807f-0810-4b80-9ca9-b20859433034", 
retrievedDocument.get("randomString").getAsString());
-        assertEquals(createdDocumentId, 
retrievedDocument.get("_id").getAsString());
-        assertEquals(createdDocumentRevision, 
retrievedDocument.get("_rev").getAsString());
-
-        // Updating a document should trigger a second update notification
-        mockUpdateNotifications.reset();
-        
mockUpdateNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"UPDATE");
-        mockUpdateNotifications.expectedMessageCount(1);
-        retrievedDocument.addProperty("randomString", 
"36e8807f-0810-4b80-9ca9-b20859433035");
-        Exchange updateExchange = template.request(couchDbIn, e -> {
-            e.getMessage().setBody(retrievedDocument);
-        });
-        final String updatedDocumentId = 
updateExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_ID, 
String.class);
-        final String updatedDocumentRevision
-                = 
updateExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_REV, 
String.class);
-        assertEquals(createdDocumentId, updatedDocumentId);
-        assertNotEquals(createdDocumentRevision, updatedDocumentRevision);
-        mockUpdateNotifications.assertIsSatisfied();
-
-        // Consulting an updated document should succeed
-        Map<String, Object> retrieveUpdatedExchangeHeaders = new HashMap<>();
-        retrieveUpdatedExchangeHeaders.put(CouchDbConstants.HEADER_DOC_ID, 
updatedDocumentId);
-        retrieveUpdatedExchangeHeaders.put(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.GET);
-        String retrievedUpdatedDocumentString
-                = template.requestBodyAndHeaders(couchDbIn, retrievedDocument, 
retrieveUpdatedExchangeHeaders, String.class);
-        assertNotNull(retrievedUpdatedDocumentString);
-        JsonObject retrievedUpdatedDocument = new 
Gson().fromJson(retrievedUpdatedDocumentString, JsonObject.class);
-        final String retrievedUpdatedDocumentId = 
retrievedUpdatedDocument.get("_id").getAsString();
-        final String retrievedUpdatedDocumentRevision = 
retrievedUpdatedDocument.get("_rev").getAsString();
-        assertEquals("36e8807f-0810-4b80-9ca9-b20859433035", 
retrievedUpdatedDocument.get("randomString").getAsString());
-        assertEquals(updatedDocumentId, retrievedUpdatedDocumentId);
-        assertEquals(updatedDocumentRevision, 
retrievedUpdatedDocumentRevision);
-
-        // Deleting a retrieved document should trigger a delete notification
-        
mockDeleteNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"DELETE");
-        mockDeleteNotifications.expectedMessageCount(1);
-        Exchange deleteExchange = template.request(couchDbIn, e -> {
-            e.getMessage().setBody(retrievedUpdatedDocument);
-            e.getMessage().setHeader(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.DELETE);
-        });
-        final String deletedDocumentId = 
deleteExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_ID, 
String.class);
-        final String deletedDocumentRevision
-                = 
deleteExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_REV, 
String.class);
-        assertEquals(retrievedUpdatedDocumentId, deletedDocumentId);
-        assertNotEquals(retrievedUpdatedDocumentRevision, 
deletedDocumentRevision);
-        mockDeleteNotifications.assertIsSatisfied();
+    private String getDocumentRevision(Exchange createExchange) {
+        return 
createExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_REV, 
String.class);
     }
 
-    @Order(2)
-    @Test
-    void jsonStringDocumentCrudShouldTriggerUpdateAndDeleteNotifications() 
throws InterruptedException {
-        JsonObject testDocument
-                = new Gson().fromJson("{ \"randomString\" : 
\"36e8807f-0810-4b80-9ca9-b20859433044\" }", JsonObject.class);
-
-        // Creating a document should trigger an update notification
-        
mockUpdateNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"UPDATE");
-        mockUpdateNotifications.expectedMessageCount(1);
-        Exchange createExchange = template.request(couchDbIn, e -> {
-            e.getMessage().setBody(testDocument.toString());
-        });
-        final String createdDocumentId = 
createExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_ID, 
String.class);
-        final String createdDocumentRevision
-                = 
createExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_REV, 
String.class);
-        assertNotNull(createdDocumentId);
-        assertNotNull(createdDocumentRevision);
-        mockUpdateNotifications.assertIsSatisfied();
-
-        // Consulting a created document should succeed
-        Map<String, Object> retrieveExchangeHeaders = new HashMap<>();
-        retrieveExchangeHeaders.put(CouchDbConstants.HEADER_DOC_ID, 
createdDocumentId);
-        retrieveExchangeHeaders.put(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.GET);
-        String retrievedDocumentString = 
template.requestBodyAndHeaders(couchDbIn, "", retrieveExchangeHeaders, 
String.class);
-        assertNotNull(retrievedDocumentString);
-        JsonObject retrievedDocument = new 
Gson().fromJson(retrievedDocumentString, JsonObject.class);
-        assertEquals("36e8807f-0810-4b80-9ca9-b20859433044", 
retrievedDocument.get("randomString").getAsString());
-        assertEquals(createdDocumentId, 
retrievedDocument.get("_id").getAsString());
-        assertEquals(createdDocumentRevision, 
retrievedDocument.get("_rev").getAsString());
-
-        // Updating a document should trigger a second update notification
-        mockUpdateNotifications.reset();
-        
mockUpdateNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"UPDATE");
-        mockUpdateNotifications.expectedMessageCount(1);
-        retrievedDocument.addProperty("randomString", 
"36e8807f-0810-4b80-9ca9-b20859433045");
-        Exchange updateExchange = template.request(couchDbIn, e -> {
-            e.getMessage().setBody(retrievedDocument.toString());
-        });
-        final String updatedDocumentId = 
updateExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_ID, 
String.class);
-        final String updatedDocumentRevision
-                = 
updateExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_REV, 
String.class);
-        assertEquals(createdDocumentId, updatedDocumentId);
-        assertNotEquals(createdDocumentRevision, updatedDocumentRevision);
-        mockUpdateNotifications.assertIsSatisfied();
-
-        // Consulting an updated document should succeed
-        Map<String, Object> retrieveUpdatedExchangeHeaders = new HashMap<>();
-        retrieveUpdatedExchangeHeaders.put(CouchDbConstants.HEADER_DOC_ID, 
updatedDocumentId);
-        retrieveUpdatedExchangeHeaders.put(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.GET);
-        String retrievedUpdatedDocumentString
-                = template.requestBodyAndHeaders(couchDbIn, "", 
retrieveUpdatedExchangeHeaders, String.class);
-        assertNotNull(retrievedUpdatedDocumentString);
-        JsonObject retrievedUpdatedDocument = new 
Gson().fromJson(retrievedUpdatedDocumentString, JsonObject.class);
-        final String retrievedUpdatedDocumentId = 
retrievedUpdatedDocument.get("_id").getAsString();
-        final String retrievedUpdatedDocumentRevision = 
retrievedUpdatedDocument.get("_rev").getAsString();
-        assertEquals("36e8807f-0810-4b80-9ca9-b20859433045", 
retrievedUpdatedDocument.get("randomString").getAsString());
-        assertEquals(updatedDocumentId, retrievedUpdatedDocumentId);
-        assertEquals(updatedDocumentRevision, 
retrievedUpdatedDocumentRevision);
-
-        // Deleting a retrieved document should trigger a delete notification
-        
mockDeleteNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"DELETE");
-        mockDeleteNotifications.expectedMessageCount(1);
-        Exchange deleteExchange = template.request(couchDbIn, e -> {
-            e.getMessage().setBody(retrievedUpdatedDocument.toString());
-            e.getMessage().setHeader(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.DELETE);
-        });
-        final String deletedDocumentId = 
deleteExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_ID, 
String.class);
-        final String deletedDocumentRevision
-                = 
deleteExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_REV, 
String.class);
-        assertEquals(retrievedUpdatedDocumentId, deletedDocumentId);
-        assertNotEquals(retrievedUpdatedDocumentRevision, 
deletedDocumentRevision);
-        mockDeleteNotifications.assertIsSatisfied();
+    private String getDocumentId(Exchange createExchange) {
+        return 
createExchange.getMessage().getHeader(CouchDbConstants.HEADER_DOC_ID, 
String.class);
     }
 
-    @Order(3)
-    @Test
-    void aHundredDocumentCreationsShouldTriggerAHundredUpdateNotifications() 
throws InterruptedException {
-        final int messageCount = 100;
-        mockUpdateNotifications.expectedMessageCount(messageCount);
+    private JsonObject newJsonObject(String s) {
+        return new Gson().fromJson(s, JsonObject.class);
+    }
+
+    @DisplayName("When the body is an object")
+    @Nested
+    @TestMethodOrder(OrderAnnotation.class)
+    @TestInstance(Lifecycle.PER_CLASS)
+    class WhenObject {
+
+        private Exchange createExchange;
+        private String retrievedDocumentString;
+        private Exchange updateExchange;
+        private String retrievedUpdatedDocumentString;
+
+        @DisplayName("tests whether can create a document")
+        @Order(2)
+        @Test
+        void testCreate() throws InterruptedException {
+            JsonObject testDocument = newJsonObject("{ \"randomString\" : 
\"36e8807f-0810-4b80-9ca9-b20859433034\" }");
+
+            // Creating a document should trigger an update notification
+            
mockUpdateNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"UPDATE");
+            mockUpdateNotifications.expectedMessageCount(1);
+            createExchange = template.request(couchDbIn, e -> 
e.getMessage().setBody(testDocument));
+
+            assertNotNull(getDocumentId(createExchange));
+            assertNotNull(getDocumentRevision(createExchange));
+            mockUpdateNotifications.assertIsSatisfied();
+        }
+
+        @DisplayName("tests whether can consult the newly created document")
+        @Order(3)
+        @Test
+        void testConsult() {
+            JsonObject testDocument = newJsonObject("{ \"randomString\" : 
\"36e8807f-0810-4b80-9ca9-b20859433034\" }");
+
+            // Consulting a created document should succeed
+            Map<String, Object> retrieveExchangeHeaders = new HashMap<>();
+            retrieveExchangeHeaders.put(CouchDbConstants.HEADER_DOC_ID, 
getDocumentId(createExchange));
+            retrieveExchangeHeaders.put(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.GET);
+            retrievedDocumentString
+                    = template.requestBodyAndHeaders(couchDbIn, testDocument, 
retrieveExchangeHeaders, String.class);
+            assertNotNull(retrievedDocumentString);
+
+            JsonObject retrievedDocument = 
newJsonObject(retrievedDocumentString);
+            final String randomString = "36e8807f-0810-4b80-9ca9-b20859433034";
+            assertEquals(randomString, 
retrievedDocument.get("randomString").getAsString());
+            assertEquals(getDocumentId(createExchange), 
retrievedDocument.get("_id").getAsString());
+            assertEquals(getDocumentRevision(createExchange), 
retrievedDocument.get("_rev").getAsString());
+        }
+
+        @DisplayName("tests whether can update a document")
+        @Order(4)
+        @Test
+        void testUpdateDocument() throws InterruptedException {
+            JsonObject retrievedDocument = 
newJsonObject(retrievedDocumentString);
+
+            // Updating a document should trigger a second update notification
+            mockUpdateNotifications.reset();
+            
mockUpdateNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"UPDATE");
+            mockUpdateNotifications.expectedMessageCount(1);
+            retrievedDocument.addProperty("randomString", 
"36e8807f-0810-4b80-9ca9-b20859433035");
+            updateExchange = template.request(couchDbIn, e -> {
+                e.getMessage().setBody(retrievedDocument);
+            });
+            assertEquals(getDocumentId(createExchange), 
getDocumentId(updateExchange));
+            assertNotEquals(getDocumentRevision(createExchange), 
getDocumentRevision(updateExchange));
+            mockUpdateNotifications.assertIsSatisfied();
+        }
+
+        @DisplayName("tests whether can consult the updated document")
+        @Order(5)
+        @Test
+        void testConsultUpdated() {
+            JsonObject retrievedDocument = 
newJsonObject(retrievedDocumentString);
+
+            // Consulting an updated document should succeed
+            Map<String, Object> retrieveUpdatedExchangeHeaders = new 
HashMap<>();
+            retrieveUpdatedExchangeHeaders.put(CouchDbConstants.HEADER_DOC_ID, 
getDocumentId(updateExchange));
+            retrieveUpdatedExchangeHeaders.put(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.GET);
+            retrievedUpdatedDocumentString = 
template.requestBodyAndHeaders(couchDbIn, retrievedDocument,
+                    retrieveUpdatedExchangeHeaders, String.class);
+            assertNotNull(retrievedUpdatedDocumentString);
+            JsonObject retrievedUpdatedDocument = 
newJsonObject(retrievedUpdatedDocumentString);
+            assertEquals("36e8807f-0810-4b80-9ca9-b20859433035", 
retrievedUpdatedDocument.get("randomString").getAsString());
+            assertEquals(getDocumentId(updateExchange), 
retrievedUpdatedDocument.get("_id").getAsString());
+            assertEquals(getDocumentRevision(updateExchange), 
retrievedUpdatedDocument.get("_rev").getAsString());
+        }
+
+        @DisplayName("tests whether can delete the document")
+        @Order(6)
+        @Test
+        void testDelete() throws InterruptedException {
+            JsonObject retrievedUpdatedDocument = 
newJsonObject(retrievedUpdatedDocumentString);
+
+            // Deleting a retrieved document should trigger a delete 
notification
+            
mockDeleteNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"DELETE");
+            mockDeleteNotifications.expectedMessageCount(1);
+            Exchange deleteExchange = template.request(couchDbIn, e -> {
+                e.getMessage().setBody(retrievedUpdatedDocument);
+                e.getMessage().setHeader(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.DELETE);
+            });
+            assertEquals(retrievedUpdatedDocument.get("_id").getAsString(), 
getDocumentId(deleteExchange));
+            
assertNotEquals(retrievedUpdatedDocument.get("_rev").getAsString(), 
getDocumentRevision(deleteExchange));
+            mockDeleteNotifications.assertIsSatisfied();
+        }
+    }
+
+    @DisplayName("When the body is a string")
+    @Nested
+    @TestMethodOrder(OrderAnnotation.class)
+    @TestInstance(Lifecycle.PER_CLASS)
+    class WhenString {
+
+        private Exchange createExchange;
+        private String retrievedDocumentString;
+        private Exchange updateExchange;
+        private String retrievedUpdatedDocumentString;
+
+        @DisplayName("tests whether can create a document")
+        @Order(7)
+        @Test
+        void testCreate() throws InterruptedException {
+            JsonObject testDocument = newJsonObject("{ \"randomString\" : 
\"36e8807f-0810-4b80-9ca9-b20859433044\" }");
+
+            // Creating a document should trigger an update notification
+            
mockUpdateNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"UPDATE");
+            mockUpdateNotifications.expectedMessageCount(1);
+            createExchange = template.request(couchDbIn, e -> 
e.getMessage().setBody(testDocument.toString()));
+            assertNotNull(getDocumentId(createExchange));
+            assertNotNull(getDocumentRevision(createExchange));
+            mockUpdateNotifications.assertIsSatisfied();
+        }
+
+        @DisplayName("tests whether can consult the newly created document")
+        @Order(8)
+        @Test
+        void testConsult() {
+            // Consulting a created document should succeed
+            Map<String, Object> retrieveExchangeHeaders = new HashMap<>();
+            retrieveExchangeHeaders.put(CouchDbConstants.HEADER_DOC_ID, 
getDocumentId(createExchange));
+            retrieveExchangeHeaders.put(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.GET);
+            retrievedDocumentString = 
template.requestBodyAndHeaders(couchDbIn, "", retrieveExchangeHeaders, 
String.class);
+            assertNotNull(retrievedDocumentString);
+            JsonObject retrievedDocument = 
newJsonObject(retrievedDocumentString);
+            assertEquals("36e8807f-0810-4b80-9ca9-b20859433044", 
retrievedDocument.get("randomString").getAsString());
+            assertEquals(getDocumentId(createExchange), 
retrievedDocument.get("_id").getAsString());
+            assertEquals(getDocumentRevision(createExchange), 
retrievedDocument.get("_rev").getAsString());
+        }
+
+        @DisplayName("tests whether can update a document")
+        @Order(9)
+        @Test
+        void testUpdate() throws InterruptedException {
+            JsonObject retrievedDocument = 
newJsonObject(retrievedDocumentString);
+
+            // Updating a document should trigger a second update notification
+            mockUpdateNotifications.reset();
+            
mockUpdateNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"UPDATE");
+            mockUpdateNotifications.expectedMessageCount(1);
+            retrievedDocument.addProperty("randomString", 
"36e8807f-0810-4b80-9ca9-b20859433045");
+            updateExchange = template.request(couchDbIn, e -> {
+                e.getMessage().setBody(retrievedDocument.toString());
+            });
+            assertEquals(getDocumentId(createExchange), 
getDocumentId(updateExchange));
+            assertNotEquals(getDocumentRevision(createExchange), 
getDocumentRevision(updateExchange));
+            mockUpdateNotifications.assertIsSatisfied();
+        }
 
-        for (int messageNumber = 0; messageNumber < messageCount; 
messageNumber++) {
-            JsonObject document = new Gson().fromJson("{ \"randomString\" : 
\"" + UUID.randomUUID() + "\" }", JsonObject.class);
-            template.requestBody(couchDbIn, document);
+        @DisplayName("tests whether can consult the updated document")
+        @Order(10)
+        @Test
+        void testConsultUpdated() {
+            // Consulting an updated document should succeed
+            Map<String, Object> retrieveUpdatedExchangeHeaders = new 
HashMap<>();
+            retrieveUpdatedExchangeHeaders.put(CouchDbConstants.HEADER_DOC_ID, 
getDocumentId(updateExchange));
+            retrieveUpdatedExchangeHeaders.put(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.GET);
+            retrievedUpdatedDocumentString
+                    = template.requestBodyAndHeaders(couchDbIn, "", 
retrieveUpdatedExchangeHeaders, String.class);
+            assertNotNull(retrievedUpdatedDocumentString);
+            JsonObject retrievedUpdatedDocument = 
newJsonObject(retrievedUpdatedDocumentString);
+            assertEquals("36e8807f-0810-4b80-9ca9-b20859433045", 
retrievedUpdatedDocument.get("randomString").getAsString());
+            assertEquals(getDocumentId(updateExchange), 
retrievedUpdatedDocument.get("_id").getAsString());
+            assertEquals(getDocumentRevision(updateExchange), 
retrievedUpdatedDocument.get("_rev").getAsString());
         }
 
-        mockUpdateNotifications.assertIsSatisfied();
+        @DisplayName("tests whether can delete the document")
+        @Order(11)
+        @Test
+        void testDelete() throws InterruptedException {
+            JsonObject retrievedUpdatedDocument = 
newJsonObject(retrievedUpdatedDocumentString);
+
+            // Deleting a retrieved document should trigger a delete 
notification
+            
mockDeleteNotifications.expectedHeaderReceived(CouchDbConstants.HEADER_METHOD, 
"DELETE");
+            mockDeleteNotifications.expectedMessageCount(1);
+            Exchange deleteExchange = template.request(couchDbIn, e -> {
+                e.getMessage().setBody(retrievedUpdatedDocument.toString());
+                e.getMessage().setHeader(CouchDbConstants.HEADER_METHOD, 
CouchDbOperations.DELETE);
+            });
+            assertEquals(retrievedUpdatedDocument.get("_id").getAsString(), 
getDocumentId(deleteExchange));
+            
assertNotEquals(retrievedUpdatedDocument.get("_rev").getAsString(), 
getDocumentRevision(deleteExchange));
+            mockDeleteNotifications.assertIsSatisfied();
+        }
+    }
+
+    @Nested
+    @TestInstance(Lifecycle.PER_CLASS)
+    class UpdateNotifications {
+
+        @DisplayName("Tests whether creating a given number of documents 
results in the same number of update notifications")
+        @ParameterizedTest
+        @ValueSource(ints = { 10, 50, 100 })
+        void testUpdateNotifications(int messageCount) throws 
InterruptedException {
+            mockUpdateNotifications.expectedMessageCount(messageCount);
+
+            for (int messageNumber = 0; messageNumber < messageCount; 
messageNumber++) {
+                JsonObject document
+                        = new Gson().fromJson("{ \"randomString\" : \"" + 
UUID.randomUUID() + "\" }", JsonObject.class);
+                template.requestBody(couchDbIn, document);
+            }
+
+            mockUpdateNotifications.assertIsSatisfied();
+        }
     }
 
 }

Reply via email to