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

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


The following commit(s) were added to refs/heads/main by this push:
     new 02ab637  Expand MongoDb test coverage #2622
02ab637 is described below

commit 02ab637a8d129bcc90b79d65290a8fd04acede46
Author: JiriOndrusek <[email protected]>
AuthorDate: Thu May 20 17:39:27 2021 +0200

    Expand MongoDb test coverage #2622
---
 .../mongodb/deployment/MongoDbProcessor.java       |   7 +
 integration-tests/mongodb/pom.xml                  |   5 +
 .../component/mongodb/it/MongoDbResource.java      | 107 +++++++++++-
 .../quarkus/component/mongodb/it/MongoDbRoute.java |  71 ++++++++
 .../quarkus/component/mongodb/it/MongoDbTest.java  | 187 ++++++++++++++++++++-
 .../component/mongodb/it/MongoDbTestResource.java  |  51 ++++++
 .../mongodb/src/test/resources/initMongodb.txt     |  34 ++++
 7 files changed, 455 insertions(+), 7 deletions(-)

diff --git 
a/extensions/mongodb/deployment/src/main/java/org/apache/camel/quarkus/component/mongodb/deployment/MongoDbProcessor.java
 
b/extensions/mongodb/deployment/src/main/java/org/apache/camel/quarkus/component/mongodb/deployment/MongoDbProcessor.java
index 8b5e5c6..58b131c 100644
--- 
a/extensions/mongodb/deployment/src/main/java/org/apache/camel/quarkus/component/mongodb/deployment/MongoDbProcessor.java
+++ 
b/extensions/mongodb/deployment/src/main/java/org/apache/camel/quarkus/component/mongodb/deployment/MongoDbProcessor.java
@@ -17,8 +17,10 @@
  */
 package org.apache.camel.quarkus.component.mongodb.deployment;
 
+import com.mongodb.client.model.changestream.ChangeStreamDocument;
 import io.quarkus.deployment.annotations.BuildStep;
 import io.quarkus.deployment.builditem.FeatureBuildItem;
+import io.quarkus.deployment.builditem.nativeimage.ReflectiveClassBuildItem;
 
 class MongoDbProcessor {
 
@@ -28,4 +30,9 @@ class MongoDbProcessor {
     FeatureBuildItem feature() {
         return new FeatureBuildItem(FEATURE);
     }
+
+    @BuildStep
+    ReflectiveClassBuildItem reflectiveClass() {
+        return new ReflectiveClassBuildItem(true, false, 
ChangeStreamDocument.class);
+    }
 }
diff --git a/integration-tests/mongodb/pom.xml 
b/integration-tests/mongodb/pom.xml
index bbc34b1..0933781 100644
--- a/integration-tests/mongodb/pom.xml
+++ b/integration-tests/mongodb/pom.xml
@@ -63,6 +63,11 @@
             <artifactId>testcontainers</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <scope>test</scope>
+        </dependency>
 
         <!-- The following dependencies guarantee that this module is built 
after them. You can update them by running `mvn process-resources -Pformat -N` 
from the source tree root directory -->
         <dependency>
diff --git 
a/integration-tests/mongodb/src/main/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbResource.java
 
b/integration-tests/mongodb/src/main/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbResource.java
index 43abfe3..fd0c3f9 100644
--- 
a/integration-tests/mongodb/src/main/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbResource.java
+++ 
b/integration-tests/mongodb/src/main/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbResource.java
@@ -18,9 +18,12 @@ package org.apache.camel.quarkus.component.mongodb.it;
 
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.util.List;
+import java.util.Map;
 
 import javax.enterprise.context.ApplicationScoped;
 import javax.inject.Inject;
+import javax.inject.Named;
 import javax.json.Json;
 import javax.json.JsonArray;
 import javax.json.JsonArrayBuilder;
@@ -35,11 +38,13 @@ import javax.ws.rs.Produces;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
 
-import com.mongodb.client.MongoClient;
 import com.mongodb.client.MongoCursor;
 import com.mongodb.client.MongoIterable;
-import io.quarkus.mongodb.MongoClientName;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import org.apache.camel.CamelContext;
 import org.apache.camel.ProducerTemplate;
+import org.apache.camel.component.mongodb.MongoDbConstants;
+import org.apache.camel.util.CollectionHelper;
 import org.bson.Document;
 
 @Path("/mongodb")
@@ -50,11 +55,14 @@ public class MongoDbResource {
     static final String NAMED_MONGO_CLIENT_NAME = "myMongoClient";
 
     @Inject
-    @MongoClientName(value = NAMED_MONGO_CLIENT_NAME)
-    MongoClient namedMongoClient;
+    ProducerTemplate producerTemplate;
 
     @Inject
-    ProducerTemplate producerTemplate;
+    CamelContext camelContext;
+
+    @Inject
+    @Named("results")
+    Map<String, List<Document>> results;
 
     @POST
     @Path("/collection/{collectionName}")
@@ -97,4 +105,93 @@ public class MongoDbResource {
 
         return arrayBuilder.build();
     }
+
+    @POST
+    @Path("/collection/dynamic/{collectionName}")
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Object dynamic(@PathParam("collectionName") String collectionName, 
String content,
+            @HeaderParam("mongoClientName") String mongoClientName,
+            @HeaderParam("dynamicOperation") String operation)
+            throws URISyntaxException {
+
+        Object result = producerTemplate.requestBodyAndHeader(
+                
String.format("mongodb:%s?database=test&collection=%s&operation=insert&dynamicity=true",
+                        mongoClientName, collectionName),
+                content, MongoDbConstants.OPERATION_HEADER, operation);
+
+        return result;
+    }
+
+    @GET
+    @Path("/route/{routeId}/{operation}")
+    @Produces(MediaType.TEXT_PLAIN)
+    public String restartRoute(@PathParam("routeId") String routeId, 
@PathParam("operation") String operation)
+            throws Exception {
+        switch (operation) {
+        case "stop":
+            camelContext.getRouteController().stopRoute(routeId);
+            break;
+        case "start":
+            camelContext.getRouteController().startRoute(routeId);
+            break;
+        case "status":
+            return 
camelContext.getRouteController().getRouteStatus(routeId).name();
+
+        }
+
+        return null;
+    }
+
+    @GET
+    @Path("/resultsReset/{resultId}")
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map getResultsAndReset(@PathParam("resultId") String resultId) {
+        int size = results.get(resultId).size();
+        Document last = null;
+        if (!results.get(resultId).isEmpty()) {
+            last = results.get(resultId).get(size - 1);
+            results.get(resultId).clear();
+        }
+        return CollectionHelper.mapOf("size", size, "last", last);
+    }
+
+    @Path("/convertMapToDocument")
+    @POST
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map convertMapToDocument(Map input) {
+        Document doc = 
camelContext.getTypeConverter().convertTo(Document.class, input);
+        doc.put("clazz", doc.getClass().getName());
+        return doc;
+    }
+
+    @Path("/convertAnyObjectToDocument")
+    @POST
+    @Consumes(MediaType.TEXT_PLAIN)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Map convertMapToDocument(String input) {
+
+        Document doc = 
camelContext.getTypeConverter().convertTo(Document.class, new 
SimplePojo(input));
+        doc.put("clazz", doc.getClass().getName());
+        return doc;
+    }
+
+    @RegisterForReflection
+    private static class SimplePojo {
+        private String value;
+
+        public SimplePojo(String value) {
+            this.value = value;
+        }
+
+        public String getValue() {
+            return value;
+        }
+
+        public void setValue(String value) {
+            this.value = value;
+        }
+    }
+
 }
diff --git 
a/integration-tests/mongodb/src/main/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbRoute.java
 
b/integration-tests/mongodb/src/main/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbRoute.java
new file mode 100644
index 0000000..2f0085c
--- /dev/null
+++ 
b/integration-tests/mongodb/src/main/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbRoute.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.quarkus.component.mongodb.it;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.inject.Produces;
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.apache.camel.builder.RouteBuilder;
+import org.bson.Document;
+
+@ApplicationScoped
+public class MongoDbRoute extends RouteBuilder {
+
+    public static String COLLECTION_TAILING = "tailingCollection";
+    public static String COLLECTION_PERSISTENT_TAILING = 
"persistentTailingCollection";
+    public static String COLLECTION_STREAM_CHANGES = 
"streamChangesgCollection";
+
+    @Inject
+    @Named("results")
+    Map<String, List<Document>> results;
+
+    @Override
+    public void configure() {
+        
from(String.format("mongodb:%s?database=test&collection=%s&tailTrackIncreasingField=increasing",
+                MongoDbResource.DEFAULT_MONGO_CLIENT_NAME, COLLECTION_TAILING))
+                        .process(e -> 
results.get(COLLECTION_TAILING).add(e.getMessage().getBody(Document.class)));
+
+        from(String.format(
+                
"mongodb:%s?database=test&collection=%s&tailTrackIncreasingField=increasing&persistentTailTracking=true&persistentId=darwin",
+                MongoDbResource.DEFAULT_MONGO_CLIENT_NAME, 
COLLECTION_PERSISTENT_TAILING))
+                        .id(COLLECTION_PERSISTENT_TAILING)
+                        .process(e -> 
results.get(COLLECTION_PERSISTENT_TAILING).add(e.getMessage().getBody(Document.class)));
+
+        
from(String.format("mongodb:%s?database=test&collection=%s&consumerType=changeStreams",
+                MongoDbResource.DEFAULT_MONGO_CLIENT_NAME, 
COLLECTION_STREAM_CHANGES))
+                        .routeProperty("streamFilter", 
"{'$match':{'$or':[{'fullDocument.string': 'value2'}]}}")
+                        .process(e -> 
results.get(COLLECTION_STREAM_CHANGES).add(e.getMessage().getBody(Document.class)));
+    }
+
+    @Produces
+    @ApplicationScoped
+    @Named("results")
+    Map<String, List<Document>> results() {
+        Map<String, List<Document>> result = new HashMap<>();
+        result.put(COLLECTION_TAILING, new CopyOnWriteArrayList<>());
+        result.put(COLLECTION_PERSISTENT_TAILING, new 
CopyOnWriteArrayList<>());
+        result.put(COLLECTION_STREAM_CHANGES, new CopyOnWriteArrayList<>());
+        return result;
+    }
+}
diff --git 
a/integration-tests/mongodb/src/test/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbTest.java
 
b/integration-tests/mongodb/src/test/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbTest.java
index d30e40e..dc51562 100644
--- 
a/integration-tests/mongodb/src/test/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbTest.java
+++ 
b/integration-tests/mongodb/src/test/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbTest.java
@@ -16,22 +16,66 @@
  */
 package org.apache.camel.quarkus.component.mongodb.it;
 
+import java.sql.SQLException;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
 import io.quarkus.test.common.QuarkusTestResource;
 import io.quarkus.test.junit.QuarkusTest;
 import io.restassured.RestAssured;
 import io.restassured.http.ContentType;
 import io.restassured.path.json.JsonPath;
+import org.apache.camel.ServiceStatus;
+import org.apache.camel.util.CollectionHelper;
+import org.bson.Document;
+import org.eclipse.microprofile.config.ConfigProvider;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
+import static 
org.apache.camel.quarkus.component.mongodb.it.MongoDbRoute.COLLECTION_PERSISTENT_TAILING;
+import static 
org.apache.camel.quarkus.component.mongodb.it.MongoDbRoute.COLLECTION_STREAM_CHANGES;
+import static 
org.apache.camel.quarkus.component.mongodb.it.MongoDbRoute.COLLECTION_TAILING;
+import static org.awaitility.Awaitility.await;
+import static org.hamcrest.Matchers.is;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 @QuarkusTest
 @QuarkusTestResource(MongoDbTestResource.class)
 class MongoDbTest {
+    public static final String MSG = "Hello Camel Quarkus Mongo DB";
+    public static final int CAP_NUMBER = 1000;
+
+    private static MongoClient mongoClient;
+
+    private static MongoDatabase db;
+
+    @BeforeAll
+    public static void setUp() throws SQLException {
+        final String mongoUrl = "mongodb://" + 
ConfigProvider.getConfig().getValue("quarkus.mongodb.hosts", String.class);
+
+        if (mongoUrl != null) {
+            mongoClient = MongoClients.create(mongoUrl);
+        }
+
+        db = mongoClient.getDatabase("test");
+    }
+
+    @AfterAll
+    public static void cleanUp() throws SQLException {
+        if (mongoClient != null) {
+            mongoClient.close();
+        }
+    }
+
     @ParameterizedTest
     @ValueSource(strings = { MongoDbResource.DEFAULT_MONGO_CLIENT_NAME, 
MongoDbResource.NAMED_MONGO_CLIENT_NAME })
     public void testMongoDbComponent(String namedClient) {
@@ -41,7 +85,7 @@ class MongoDbTest {
         // Write to collection
         RestAssured.given()
                 .contentType(ContentType.JSON)
-                .body("{message:\"Hello Camel Quarkus Mongo DB\"}")
+                .body("{message:\"" + MSG + "\"}")
                 .header("mongoClientName", namedClient)
                 .post("/mongodb/collection/" + collectionName)
                 .then()
@@ -63,6 +107,145 @@ class MongoDbTest {
         assertEquals(1, documents.size());
 
         Map<String, String> document = documents.get(0);
-        assertEquals("Hello Camel Quarkus Mongo DB", document.get("message"));
+        assertEquals(MSG, document.get("message"));
+    }
+
+    @Test
+    public void testDynamicOperation() {
+        String collectionName = "dynamicCamelTest";
+
+        // Write to collection
+        RestAssured.given()
+                .contentType(ContentType.JSON)
+                .body("{message:\"" + MSG + "\"}")
+                .header("mongoClientName", 
MongoDbResource.DEFAULT_MONGO_CLIENT_NAME)
+                .post("/mongodb/collection/dynamic/" + collectionName)
+                .then()
+                .statusCode(200)
+                .body("message", is(MSG));
+
+        //count results with dynamic operation
+        RestAssured.given()
+                .contentType(ContentType.JSON)
+                .body("{message:\"" + MSG + "\"}")
+                .header("mongoClientName", 
MongoDbResource.DEFAULT_MONGO_CLIENT_NAME)
+                .header("dynamicOperation", "count")
+                .post("/mongodb/collection/dynamic/" + collectionName)
+                .then()
+                .statusCode(200)
+                .body(is("1"));
+
+    }
+
+    @Test
+    public void testTailingConsumer() throws Exception {
+        MongoCollection collection = db.getCollection(COLLECTION_TAILING, 
Document.class);
+
+        for (int i = 1; i <= (10 * CAP_NUMBER); i++) {
+            collection.insertOne(new Document("increasing", 
i).append("string", "value" + i));
+
+            //verify continuously
+            if (i % CAP_NUMBER == 0) {
+                waitForTailingResults(CAP_NUMBER, "value" + i, 
COLLECTION_TAILING);
+            }
+        }
+    }
+
+    @Test
+    public void testPersistentTailingConsumer() throws Exception {
+        MongoCollection collection = 
db.getCollection(COLLECTION_PERSISTENT_TAILING, Document.class);
+
+        for (int i = 1; i <= (3 * CAP_NUMBER); i++) {
+            collection.insertOne(new Document("increasing", 
i).append("string", "value" + i));
+
+            //verify continuously
+            if (i % CAP_NUMBER == 0) {
+                waitForTailingResults(CAP_NUMBER, "value" + i, 
COLLECTION_PERSISTENT_TAILING);
+            }
+        }
+
+        //restart route
+        routeController(COLLECTION_PERSISTENT_TAILING, "stop", null);
+        routeController(COLLECTION_PERSISTENT_TAILING, "status", 
ServiceStatus.Stopped.name());
+        routeController(COLLECTION_PERSISTENT_TAILING, "start", null);
+        routeController(COLLECTION_PERSISTENT_TAILING, "status", 
ServiceStatus.Started.name());
+
+        for (int i = (3 * CAP_NUMBER + 1); i <= (6 * CAP_NUMBER); i++) {
+            collection.insertOne(new Document("increasing", 
i).append("string", "value" + i));
+
+            //verify continuously
+            if (i % CAP_NUMBER == 0) {
+                waitForTailingResults(CAP_NUMBER, "value" + i, 
COLLECTION_PERSISTENT_TAILING);
+            }
+        }
+    }
+
+    private String routeController(String routeId, String operation, String 
expectedResult) {
+        if (expectedResult == null) {
+            RestAssured.given()
+                    .get("/mongodb/route/" + routeId + "/" + operation)
+                    .then().statusCode(204);
+        } else {
+            await().atMost(5, TimeUnit.SECONDS).until(() -> {
+                // Read the file
+                String status = RestAssured
+                        .get("/mongodb/route/" + routeId + "/" + operation)
+                        .then()
+                        .statusCode(200)
+                        .extract().asString();
+
+                return status != null && status.equals(expectedResult);
+            });
+        }
+
+        return null;
+    }
+
+    @Test
+    public void testStreamConsumerWithFilter() throws Exception {
+        MongoCollection collection = 
db.getCollection(COLLECTION_STREAM_CHANGES, Document.class);
+
+        for (int i = 1; i <= 10; i++) {
+            collection.insertOne(new Document("increasing", 
i).append("string", "value" + i));
+        }
+
+        waitForTailingResults(1, "value2", COLLECTION_STREAM_CHANGES);
+    }
+
+    @Test
+    public void testConvertMapToDocument() {
+        RestAssured.given()
+                .contentType(ContentType.JSON)
+                .body(CollectionHelper.mapOf("key1", "val1", "key2", "val2"))
+                .post("/mongodb/convertMapToDocument")
+                .then()
+                .statusCode(200)
+                .body("clazz", is(Document.class.getName()), "key1", 
is("val1"), "key2", is("val2"));
+    }
+
+    @Test
+    public void testConvertAnyObjectToDocument() {
+        RestAssured.given()
+                .body("Hello!")
+                .post("/mongodb/convertAnyObjectToDocument")
+                .then()
+                .statusCode(200)
+                .body("clazz", is(Document.class.getName()), "value", 
is("Hello!"));
+    }
+
+    private void waitForTailingResults(int expectedSize, String laststring, 
String resultId) {
+        AtomicInteger size = new AtomicInteger();
+        await().atMost(2, TimeUnit.SECONDS).until(() -> {
+            Map record = RestAssured
+                    .given().contentType(ContentType.JSON)
+                    .get("/mongodb/resultsReset/" + resultId)
+                    .then()
+                    .statusCode(200)
+                    .extract().as(Map.class);
+
+            size.addAndGet((int) record.get("size"));
+
+            return size.get() == expectedSize && laststring.equals(((Map) 
record.get("last")).get("string"));
+        });
     }
 }
diff --git 
a/integration-tests/mongodb/src/test/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbTestResource.java
 
b/integration-tests/mongodb/src/test/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbTestResource.java
index c245260..cce87fb 100644
--- 
a/integration-tests/mongodb/src/test/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbTestResource.java
+++ 
b/integration-tests/mongodb/src/test/java/org/apache/camel/quarkus/component/mongodb/it/MongoDbTestResource.java
@@ -17,20 +17,30 @@
 
 package org.apache.camel.quarkus.component.mongodb.it;
 
+import java.nio.charset.StandardCharsets;
 import java.util.Map;
 
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.model.CreateCollectionOptions;
 import io.quarkus.test.common.QuarkusTestResourceLifecycleManager;
 import org.apache.camel.util.CollectionHelper;
+import org.apache.commons.io.IOUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.Container;
 import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.Network;
 import org.testcontainers.containers.wait.strategy.Wait;
 import org.testcontainers.utility.TestcontainersConfiguration;
 
 public class MongoDbTestResource implements 
QuarkusTestResourceLifecycleManager {
     private static final Logger LOGGER = 
LoggerFactory.getLogger(MongoDbTestResource.class);
+
     private static final int MONGODB_PORT = 27017;
     private static final String MONGO_IMAGE = "mongo:4.0";
+    private static final String PRIVATE_HOST = "mongodb_private";
 
     private GenericContainer container;
 
@@ -41,10 +51,17 @@ public class MongoDbTestResource implements 
QuarkusTestResourceLifecycleManager
         try {
             container = new GenericContainer(MONGO_IMAGE)
                     .withExposedPorts(MONGODB_PORT)
+                    .withCommand("--replSet", "my-mongo-set")
+                    .withNetwork(Network.newNetwork())
+                    .withNetworkAliases(PRIVATE_HOST)
                     .waitingFor(Wait.forListeningPort());
 
             container.start();
 
+            execScriptInContainer("initMongodb.txt");
+
+            setUpDb();
+
             return CollectionHelper.mapOf(
                     "quarkus.mongodb.hosts",
                     container.getContainerIpAddress() + ":" + 
container.getMappedPort(MONGODB_PORT).toString(),
@@ -55,6 +72,40 @@ public class MongoDbTestResource implements 
QuarkusTestResourceLifecycleManager
         }
     }
 
+    void setUpDb() {
+        final String mongoUrl = "mongodb://" + 
container.getContainerIpAddress() + ":"
+                + container.getMappedPort(MONGODB_PORT).toString();
+
+        MongoClient mongoClient = null;
+        try {
+            mongoClient = MongoClients.create(mongoUrl);
+
+            MongoDatabase db = mongoClient.getDatabase("test");
+            db.createCollection(MongoDbRoute.COLLECTION_TAILING,
+                    new 
CreateCollectionOptions().capped(true).sizeInBytes(1000000000).maxDocuments(MongoDbTest.CAP_NUMBER));
+            db.createCollection(MongoDbRoute.COLLECTION_PERSISTENT_TAILING,
+                    new 
CreateCollectionOptions().capped(true).sizeInBytes(1000000000).maxDocuments(MongoDbTest.CAP_NUMBER));
+            db.createCollection(MongoDbRoute.COLLECTION_STREAM_CHANGES);
+
+        } finally {
+            if (mongoClient != null) {
+                mongoClient.close();
+            }
+        }
+    }
+
+    private void execScriptInContainer(String script) throws Exception {
+        String cmd = IOUtils.toString(getClass().getResource("/" + script), 
StandardCharsets.UTF_8);
+        String[] cmds = cmd.split("\\n\\n");
+
+        for (int i = 0; i < cmds.length; i++) {
+            Container.ExecResult er = container.execInContainer(new String[] { 
"mongo", "--eval", cmds[i] });
+            if (er.getExitCode() != 0) {
+                throw new IllegalStateException("Exec exit code " + 
er.getExitCode() + ". " + er.getStderr());
+            }
+        }
+    }
+
     @Override
     public void stop() {
         try {
diff --git a/integration-tests/mongodb/src/test/resources/initMongodb.txt 
b/integration-tests/mongodb/src/test/resources/initMongodb.txt
new file mode 100644
index 0000000..4d128a0
--- /dev/null
+++ b/integration-tests/mongodb/src/test/resources/initMongodb.txt
@@ -0,0 +1,34 @@
+rs.initiate( {
+    '_id' : 'my-mongo-set',
+    'members' : [{
+        '_id' : 0,
+        'host' : 'mongodb_private:27017',
+        'priority': 2}]
+    });
+
+db.getSiblingDB('admin').runCommand( {
+    createRole: 'listDatabases',
+    privileges: [ {
+        resource: { cluster : true },
+        actions: [ 'listDatabases']
+    } ] ,
+    roles: []
+});
+
+db.getSiblingDB('admin').createUser({
+    user: "debezium",
+    pwd:"dbz",
+    roles: [  {
+        role: "userAdminAnyDatabase",
+        db: "admin"
+    }, {
+        role: "dbAdminAnyDatabase",
+        db: "admin"
+    },  {
+        role: "readWriteAnyDatabase",
+        db:"admin"
+    },  {
+        role: "clusterAdmin",
+        db: "admin"
+    }]
+});
\ No newline at end of file

Reply via email to