Ma question est une variante de celle-ci .

Étant donné que mon projet d'application Web Java nécessite beaucoup de filtres / requêtes de lecture et d'interfaces avec des outils tels que GridFS, j'ai du mal à trouver un moyen judicieux d'utiliser MongoDB de la manière suggérée par la solution ci-dessus.

Par conséquent, j'envisage d'exécuter une instance intégrée de MongoDB parallèlement à mes tests d'intégration. J'aimerais qu'il démarre automatiquement (soit pour chaque test, soit pour toute la suite), vider la base de données pour chaque test et s'arrêter à la fin. Ces tests peuvent être exécutés sur des machines de développement ainsi que sur le serveur CI, donc ma solution devra également être portable .

Quelqu'un avec plus de connaissances sur MongoDB peut-il m'aider à avoir une idée de la faisabilité de cette approche, et / ou peut-être suggérer un matériel de lecture qui pourrait m'aider à démarrer?

Je suis également ouvert à d'autres suggestions que les gens pourraient avoir sur la façon dont je pourrais aborder ce problème ...

Voici une version mise à jour (pour 2019) de la réponse acceptée de @rozky (beaucoup de choses ont été modifiées dans les bibliothèques Mongo et Embedded MongoDB).

package com.example.mongo;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import de.flapdoodle.embed.mongo.MongodExecutable;
import de.flapdoodle.embed.mongo.MongodProcess;
import de.flapdoodle.embed.mongo.MongodStarter;
import de.flapdoodle.embed.mongo.config.IMongodConfig;
import de.flapdoodle.embed.mongo.config.MongodConfigBuilder;
import de.flapdoodle.embed.mongo.config.Net;
import de.flapdoodle.embed.mongo.distribution.Version;
import de.flapdoodle.embed.process.runtime.Network;
import java.util.Date;
import org.junit.After;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;

public class EmbeddedMongoTest
{
    private static final String DATABASE_NAME = "embedded";

    private MongodExecutable mongodExe;
    private MongodProcess mongod;
    private MongoClient mongo;

    @Before
    public void beforeEach() throws Exception {
        MongodStarter starter = MongodStarter.getDefaultInstance();
        String bindIp = "localhost";
        int port = 12345;
        IMongodConfig mongodConfig = new MongodConfigBuilder()
        .version(Version.Main.PRODUCTION)
        .net(new Net(bindIp, port, Network.localhostIsIPv6()))
        .build();
        this.mongodExe = starter.prepare(mongodConfig);
        this.mongod = mongodExe.start();
        this.mongo = new MongoClient(bindIp, port);
    }

    @After
    public void afterEach() throws Exception {
        if (this.mongod != null) {
            this.mongod.stop();
            this.mongodExe.stop();
        }
    }

    @Test
    public void shouldCreateNewObjectInEmbeddedMongoDb() {
        // given
        MongoDatabase db = mongo.getDatabase(DATABASE_NAME);
        db.createCollection("testCollection");
        MongoCollection<BasicDBObject> col = db.getCollection("testCollection", BasicDBObject.class);

        // when
        col.insertOne(new BasicDBObject("testDoc", new Date()));

        // then
        assertEquals(1L, col.countDocuments());
    }

}

J'ai trouvé la bibliothèque Embedded MongoDB qui semble assez prometteuse et fait ce que vous avez demandé.

Prend actuellement en charge les versions MongoDB: 1.6.5to 3.1.6, à condition que les binaires soient toujours disponibles à partir du miroir configuré.

Voici un petit exemple d'utilisation, que je viens d'essayer et qui fonctionne parfaitement:

public class EmbeddedMongoTest {
    private static final String DATABASE_NAME = "embedded";

    private MongodExecutable mongodExe;
    private MongodProcess mongod;
    private Mongo mongo;

    @Before
    public void beforeEach() throws Exception {
        MongoDBRuntime runtime = MongoDBRuntime.getDefaultInstance();
        mongodExe = runtime.prepare(new MongodConfig(Version.V2_3_0, 12345, Network.localhostIsIPv6()));
        mongod = mongodExe.start();
        mongo = new Mongo("localhost", 12345);
    }

    @After
    public void afterEach() throws Exception {
        if (this.mongod != null) {
            this.mongod.stop();
            this.mongodExe.stop();
        }
    }

    @Test
    public void shouldCreateNewObjectInEmbeddedMongoDb() {
        // given
        DB db = mongo.getDB(DATABASE_NAME);
        DBCollection col = db.createCollection("testCollection", new BasicDBObject());

        // when
        col.save(new BasicDBObject("testDoc", new Date()));

        // then
        assertThat(col.getCount(), Matchers.is(1L));
    }
}

Il existe un produit Foursquare Fongo . Fongo est une implémentation java en mémoire de mongo. Il intercepte les appels au pilote standard mongo-java pour les recherches, les mises à jour, les inserts, les suppressions et d'autres méthodes. L'utilisation principale est pour les tests unitaires légers où vous ne voulez pas lancer un processus mongo.

Si vous utilisez Maven, vous serez peut-être intéressé par un plugin que j'ai créé qui encapsule l' API `` mongo embarquée '' de flapdoodle.de :

embedmongo-maven-plugin

Il fournit un startobjectif que vous pouvez utiliser pour démarrer n'importe quelle version de MongoDB que vous voulez (par exemple pendant pre-integration-test), et un stopobjectif qui arrêtera MongoDB (par exemple pendantpost-integration-test ).

Le véritable avantage de l'utilisation de ce plugin par rapport aux autres est qu'il n'est pas nécessaire d'installer MongoDB au préalable. Les binaires MongoDB sont téléchargés et stockés ~/.embedmongopour les futures versions.

Si vous utilisez sbt et specs2, j'ai écrit le même type de wrapper pour embedmongo

https://github.com/athieriot/specs2-embedmongo

avec spring-boot 1.3, vous pouvez utiliser EmbeddedMongoAutoConfiguration

pom.xml

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.3.2.RELEASE</version>
</parent>
 ...
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <dependency>
        <groupId>de.flapdoodle.embed</groupId>
        <artifactId>de.flapdoodle.embed.mongo</artifactId>
        <version>${embedded-mongo.version}</version>
    </dependency>

MongoConfig

@Configuration
@EnableAutoConfiguration(exclude = { EmbeddedMongoAutoConfiguration.class })
public class MongoConfig{
}

Vous pouvez exécuter MongoDB en mémoire à partir de la version 3.2.6. Depuis le site :

À partir de MongoDB Enterprise version 3.2.6, le moteur de stockage en mémoire fait partie de la disponibilité générale (GA) dans les versions 64 bits. Hormis certaines métadonnées et données de diagnostic, le moteur de stockage en mémoire ne conserve aucune donnée sur disque, y compris les données de configuration, les index, les informations d'identification de l'utilisateur, etc.

Pas seulement pour les tests unitaires, mais a également expliqué comment utiliser mongodb en mémoire avec l'api de repos.

dépendance maven:

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>

        <dependency>
            <groupId>de.flapdoodle.embed</groupId>
            <artifactId>de.flapdoodle.embed.mongo</artifactId>
        </dependency>

=================================================== ============================

application.properties

server.port = 8080
spring.data.mongodb.database=user_db
spring.data.mongodb.port=27017
spring.data.mongodb.host=localhost

=================================================== ============================

UserRepository.java

interface publique UserRepository étend MongoRepository {

}

pour référence et tout le code java, utilisez le lien ci-dessous: (explication étape par étape)

https://www.youtube.com/watch?v=2Tq2Q7EzhSA&t=7s

Les performances sont meilleures lors de l'exécution mongodavecstorageEngine='ephemeralForTest'

new MongodConfigBuilder()
    .version(Version.Main.PRODUCTION)
    .cmdOptions(new MongoCmdOptionsBuilder()
         .useStorageEngine("ephemeralForTest")
         .build())
    .net(new Net("localhost", port, Network.localhostIsIPv6()))
    .build()

En production, vous utiliserez une vraie base de données.

Si vous souhaitez que vos tests reflètent le comportement de votre produit en production, utilisez une instance réelle de Mongo.

Une fausse implémentation peut ne pas se comporter exactement comme une vraie. Lors du test, vous devez vous efforcer d'obtenir l'exactitude. La vitesse d'exécution vient en second.