Mòdul MongoDB

    <dependency>
      <groupId>cat.gencat.ctti</groupId>
      <artifactId>canigo.persistence.mongodb</artifactId>
      <version>${canigo.persistence.mongodb.version}</version>
      <exclusions>
        <exclusion>
          <artifactId>bson</artifactId>
          <groupId>org.mongodb</groupId>
        </exclusion>
        <exclusion>
          <artifactId>mongodb-driver-core</artifactId>
          <groupId>org.mongodb</groupId>
        </exclusion>
        <exclusion>
          <artifactId>mongodb-driver-async</artifactId>
          <groupId>org.mongodb</groupId>
        </exclusion>
      </exclusions>
    </dependency>

<build>
   ...
   <plugins>
      ...
      <plugin>
         <groupId>com.mysema.maven</groupId>
         <artifactId>apt-maven-plugin</artifactId>
         <version>1.1.3</version>
         <executions>
         ...
                    <execution>
                        <id>org.springframework.data.mongodb.repository.support.MongoAnnotationProcessor</id>
                        <goals>
                          <goal>process</goal>
                        </goals>
                        <configuration>
                          <outputDirectory>target/generated-sources/java</outputDirectory>
                          <processor>org.springframework.data.mongodb.repository.support.MongoAnnotationProcessor</processor>
                        </configuration>
                    </execution>
         ...
         </executions>
      </plugin>
      ...
   </plugins>
   ...
</build>

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

    <embedmongo-spring.version>1.3.1</embedmongo-spring.version>
    <dependency>
      <groupId>de.flapdoodle.embed</groupId>
      <artifactId>de.flapdoodle.embed.mongo</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>cz.jirutka.spring</groupId>
      <artifactId>embedmongo-spring</artifactId>
      <version>${embedmongo-spring.version}</version>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <artifactId>mongo-java-driver</artifactId>
          <groupId>org.mongodb</groupId>
        </exclusion>
      </exclusions>
    </dependency>

    <mongo-java-driver.version>3.12.10</mongo-java-driver.version>
    <dependency>
      <groupId>org.mongodb</groupId>
      <artifactId>bson</artifactId>
    </dependency>
    <dependency>
      <groupId>org.mongodb</groupId>
      <artifactId>mongodb-driver-sync</artifactId>
    </dependency>
    <dependency>
      <groupId>org.mongodb</groupId>
      <artifactId>mongo-java-driver</artifactId>
      <version>${mongo-java-driver.version}</version>
    </dependency>

     <dependency>
      <groupId>org.mongodb</groupId>
      <artifactId>mongodb-driver-reactivestreams</artifactId>
    </dependency>
    <dependency>
      <groupId>io.projectreactor</groupId>
      <artifactId>reactor-core</artifactId>
    </dependency>
    <dependency>
      <groupId>io.projectreactor</groupId>
      <artifactId>reactor-test</artifactId>
    </dependency>

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/*database*
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.mongodb.MongoClientSettings;

import cat.gencat.demo.mongodb.model.repository.MongoEquipamentListener;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.config.MongoCoreConfig;

/**
 * Class EquipamentMongoConfig.
 *
 * @author cscanigo
 */
@Configuration
public class EquipamentMongoConfig extends MongoCoreConfig {

  /**
   * Inicialitza equipament mongo config.
   */
  public EquipamentMongoConfig() {
    super(MongoClientSettings.builder().build());
  }

  /**
   * Mongo equipament listener.
   *
   * @return mongo equipament listener
   */
  @Bean
  public MongoEquipamentListener mongoEquipamentListener() {
    return new MongoEquipamentListener();
  }

}

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/*database*

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import cat.gencat.demo.mongodb.model.repository.MongoEquipamentListener;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.config.ReactiveMongoCoreConfig;

/**
 * Class EquipamentReactiveMongoConfig.
 *
 * @author cscanigo
 */
@Configuration
public class EquipamentReactiveMongoConfig extends ReactiveMongoCoreConfig {

  /**
   * Mongo equipament listener.
   *
   * @return mongo equipament listener
   */
  @Bean
  public MongoEquipamentListener mongoEquipamentListener() {
    return new MongoEquipamentListener();
  }

}

import jakarta.validation.constraints.NotNull;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "Equipament")
public class MongoEquipament {
   public static final String ID = "id";
   public static final String NOM = "nom";
   public static final String MUNICIPI = "municipi";

   @Id
   private Long id;

   @Indexed(unique = true)
   @NotNull(message = "MongoEquipament's nom must not be null")
   private String nom;

   private String municipi;

   public Long getId() {
      return id;
   }
   public void setId(Long id) {
      this.id = id;
   }
   public String getNom() {
      return nom;
   }
   public void setNom(String nom) {
      this.nom = nom;
   }
   public String getMunicipi() {
      return municipi;
   }
   public void setMunicipi(String municipi) {
      this.municipi = municipi;
   }
}

package cat.gencat.demo.mongodb.model.repository;

import java.util.Random;
import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener;
import org.springframework.data.mongodb.core.mapping.event.BeforeConvertEvent;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.model.MongoEquipament;

/**
 * Equivalent of a domain method annotated by <code>PrePersist</code>.
 * @see MongoEquipamentEvent
 */
public class MongoEquipamentListener extends AbstractMongoEventListener<MongoEquipament> {
   /**
    * On before convert.
    * @param event
    */
   @Override
   public void onBeforeConvert(BeforeConvertEvent<MongoEquipament> event) {
      MongoEquipament mongoEquipament = event.getSource();
      if (mongoEquipament.getId() == null) {
         mongoEquipament.setId(new Random().nextLong());
      }
   }
}

/**
 * Interface EquipamentMongoRepository.
 * @author cscanigo
 */
public interface EquipamentMongoRepository extends MongoGenericRepository<MongoEquipament, Long> {
   
   /**
      * Find by nom query.
      *
      * @param nom nom
      * @return list
      */
   @Query("{ nom: ?0 }")
   List<MongoEquipament> queryFindByNom(String nom);

    /**
     * Find by nom like.
     * @param nom  nom
     * @param sort sort
     * @return list
     */
    List<MongoEquipament> findByNomLike(String nom, Sort sort);
}

import java.util.List;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.repository.Query;
import org.springframework.data.mongodb.repository.ReactiveMongoRepository;
import org.springframework.stereotype.Repository;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.model.MongoEquipament;

/**
 * Interface EquipamentReactiveMongoRepository.
 * @author cscanigo
 */
@Repository
public interface EquipamentReactiveMongoRepository extends ReactiveMongoRepository<MongoEquipament, Long> {
    /**
     * Find by nom query.
     * @param nom nom
     * @return list
     */
    @Query("{ nom: ?0 }")
    List<MongoEquipament> findByNomQuery(String nom);
    /**
     * Find by nom like.
     * @param nom  nom
     * @param sort sort
     * @return list
     */
    List<MongoEquipament> findByNomLike(String nom, Sort sort);
}

import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import jakarta.inject.Inject;
import jakarta.validation.ConstraintViolation;
import jakarta.validation.ConstraintViolationException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.runners.MethodSorters;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.data.querydsl.QSort;
import com.querydsl.core.types.Expression;
import com.querydsl.core.types.OrderSpecifier;
import com.querydsl.core.types.Path;
import com.querydsl.core.types.Predicate;
import com.querydsl.core.types.Projections;
import com.querydsl.core.types.dsl.BooleanExpression;
import cat.gencat.ctti.canigo.arch.persistence.core.querydsl.GenericPredicateBuilder;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.model.MongoEquipament;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.model.QMongoEquipament;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.repository.EquipamentMongoRepository;

/**
 * Test cases for the {@link EquipamentMongoRepository}.
 *
 * @author cscanigo
 */
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public abstract class EquipamentMongoRepositoryCoreTest {

  /** Constant MUNICIPI_DESC_SORT. */
  protected static final String MUNICIPI_DESC_SORT = Direction.DESC + MongoEquipament.MUNICIPI;

  /** repository. */
  @Inject
  private EquipamentMongoRepository repository;

  /**
   * Estableix up.
   */
  @BeforeEasch
  public void setUp() {
    assertNotNull(repository);
    repository.deleteAll();
  }

  /**
   * Test 01 CRUD operations.
   */
  @Test
  public void test01CRUDOperations() {

    // Test if table is empty
    assertTrue(repository.findAll().isEmpty());

    // Test save
    MongoEquipament mongoEquipament = new MongoEquipament();
    mongoEquipament.setNom("CAP La Pau");
    mongoEquipament.setMunicipi("Barcelona");
    repository.save(mongoEquipament);

    // Test insert and recover
    MongoEquipament mongoEquipament2 = new MongoEquipament();
    mongoEquipament2.setNom("CAP Santa Coloma");
    repository.save(mongoEquipament2);

    Optional<MongoEquipament> equipament3Optional = repository.findById(mongoEquipament2.getId());
    assertTrue(equipament3Optional.isPresent());

    MongoEquipament equipament3 = equipament3Optional.get();
    assertEquals(mongoEquipament2.getId(), equipament3.getId());
    assertEquals("CAP Santa Coloma", equipament3.getNom());

    BooleanExpression predicate = QMongoEquipament.mongoEquipament.municipi.eq(mongoEquipament.getMunicipi());

    Optional<MongoEquipament> equipament4Optional = repository.findOne(predicate);
    assertTrue(equipament4Optional.isPresent());

    Iterable<MongoEquipament> equipament5Iterable = repository.findAll(predicate);
    assertTrue(equipament5Iterable.iterator().hasNext());

    OrderSpecifier<String> orderSpecifier = new OrderSpecifier<>(com.querydsl.core.types.Order.ASC,
        QMongoEquipament.mongoEquipament.nom);

    Iterable<MongoEquipament> equipament6Iterable = repository.findAll(predicate, orderSpecifier);
    assertTrue(equipament6Iterable.iterator().hasNext());

    // Test delete all
    repository.deleteAll();
    assertTrue(repository.findAll().isEmpty());

  }

  /**
   * Test 02 multiple CRUD.
   */
  @Test
  public void test02MultipleCRUD() {
    List<MongoEquipament> list = new ArrayList<>();

    MongoEquipament mongoEquipament1 = new MongoEquipament();
    MongoEquipament mongoEquipament2 = new MongoEquipament();
    MongoEquipament mongoEquipament3 = new MongoEquipament();

    list.add(mongoEquipament1);
    list.add(mongoEquipament2);
    list.add(mongoEquipament3);

    // Test save
    mongoEquipament1.setNom("equipament1");
    mongoEquipament2.setNom("equipament2");
    mongoEquipament3.setNom("equipament3");
    repository.saveAll(list);
    assertEquals(list.size(), repository.findAll().size());

    // Test update
    mongoEquipament1.setNom("equipament1 updated!");
    mongoEquipament2.setNom("equipament2 updated!");
    mongoEquipament3.setNom("equipament3 updated!");
    repository.saveAll(list);
    assertEquals(list.size(), repository.findAll().size());

    List<MongoEquipament> elsMeusEquipaments = repository.findAll();
    assertEquals(mongoEquipament1.getId(), elsMeusEquipaments.get(0).getId());
    assertEquals(mongoEquipament1.getNom(), elsMeusEquipaments.get(0).getNom());
    assertEquals(mongoEquipament2.getId(), elsMeusEquipaments.get(1).getId());
    assertEquals(mongoEquipament2.getNom(), elsMeusEquipaments.get(1).getNom());
    assertEquals(mongoEquipament3.getId(), elsMeusEquipaments.get(2).getId());
    assertEquals(mongoEquipament3.getNom(), elsMeusEquipaments.get(2).getNom());

    // Test no exception launched
    repository.saveAll(new ArrayList<MongoEquipament>());
  }

  /**
   * Test 03 nom not null.
   */
  @Test
  public void test03NomNotNull() {
    MongoEquipament mongoEquipament = new MongoEquipament();
    mongoEquipament.setNom(null);
    try {
      repository.save(mongoEquipament);
    } catch (ConstraintViolationException e) {
      Set<ConstraintViolation<?>> violations = e.getConstraintViolations();
      assertEquals(1, violations.size());
      @SuppressWarnings("rawtypes")
      ConstraintViolation violation = violations.iterator().next();
      assertEquals("MongoEquipament's nom must not be null", violation.getMessageTemplate());
    }
  }

  /**
   * Test 04 find by nom query.
   */
  @Test
  public void test04FindByNomQuery() {
    String text = "findByNomQuery";
    MongoEquipament mongoEquipament = new MongoEquipament();
    mongoEquipament.setNom(text);
    mongoEquipament.setMunicipi(text);
    repository.save(mongoEquipament);

    List<MongoEquipament> mongoEquipamentList = repository.queryFindByNom(text);

    assertNotNull(mongoEquipamentList);
    assertTrue(mongoEquipamentList.size() == 1);
  }

  /**
   * Test 05 find by nom like.
   */
  @Test
  public void test05FindByNomLike() {
    String like = "Like";
    String text = "findByNom" + like;
    MongoEquipament mongoEquipament = new MongoEquipament();
    mongoEquipament.setNom(text);
    mongoEquipament.setMunicipi(text);
    repository.save(mongoEquipament);

    List<MongoEquipament> mongoEquipamentList = repository.findByNomLike(like, null);

    assertNotNull(mongoEquipamentList);
    assertTrue(mongoEquipamentList.size() == 1);
  }

  /**
   * Test 08 find null paginated.
   */
  @Test(expected = IllegalArgumentException.class)
  public void test06FindNullPaginated() {
    PageRequest nullPage = null;
    repository.findAll(nullPage);
  }

  /**
   * Test 09 find paginated factory expression.
   */
  @Test
  public void test07FindPaginatedFactoryExpression() {
    String text = "findPaginatedProjeccio";
    for (int i = 0; i < 20; i++) {
      MongoEquipament mongoEquipament = new MongoEquipament();
      mongoEquipament.setNom(text + i);
      mongoEquipament.setMunicipi(text + i);
      repository.save(mongoEquipament);
    }

    Integer page = 1;
    Integer rpp = 10;
    String sort = MUNICIPI_DESC_SORT;
    String filter = null;

    List<MongoEquipament> mongoEquipamentList = findPaginatedFactoryExpression(page, rpp, sort, filter).getContent();

    assertNotNull(mongoEquipamentList);
    assertTrue(mongoEquipamentList.size() == rpp);
  }

  /**
   * Obté predicate.
   *
   * @param filter filter
   * @return predicate
   */
  private Predicate getPredicate(String filter) {
    GenericPredicateBuilder<MongoEquipament> builder = new GenericPredicateBuilder<>(MongoEquipament.class,
        "equipament");
    builder.populateSearchCriteria(filter);
    return builder.build();
  }

  /**
   * Find paginated factory expression.
   *
   * @param page   page
   * @param rpp    rpp
   * @param sort   sort
   * @param filter filter
   * @return page
   */
  protected Page<MongoEquipament> findPaginatedFactoryExpression(final Integer page, final Integer rpp,
      final String sort, final String filter) {
    Predicate predicate = getPredicate(filter);

    Pageable pageable = PageRequest.of(page - 1, rpp, getOrdenacio(sort));

    if (predicate != null && pageable != null) {
      return repository.findAll(predicate, pageable);
    } else if (pageable != null) {
      return repository.findAll(pageable);
    } else {
      return null;
    }

  }

  /**
   * Obté ordenacio.
   *
   * @param sort sort
   * @return ordenacio
   */
  private Sort getOrdenacio(String sort) {
    List<Order> orders = new ArrayList<>();

    if (sort != null && !sort.equals("")) {
      String[] fields = sort.split(",");

      for (int i = 0; i < fields.length; i++) {
        char direction = fields[i].charAt(0);
        if (Character.toString(direction).equals("-")) {
          // Order descendente
          String value = fields[i].substring(1);
          orders.add(new Order(Direction.DESC, value));
        } else {
          // Orden ascendente
          orders.add(new Order(Direction.ASC, fields[i]));
        }
      }
    }
    return Sort.by(orders);
  }
}

import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import cat.gencat.ctti.config.AppConfig;
import cat.gencat.ctti.mongodb.config.EquipamentMongoConfig;
import cat.gencat.ctti.mongodb.model.repository.EquipamentMongoRepository;

/**
 * Test cases for the {@link EquipamentMongoRepository}.
 */
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = { AppConfig.class, EquipamentMongoConfig.class })
public class EquipamentMongoRepositoryTest extends EquipamentMongoRepositoryCoreTest{
}

public MongoClient mongoClient()

import java.io.IOException;

import com.mongodb.MongoException;
import com.mongodb.client.MongoClient;

/**
 * Class EquipamentEmbeddedMongoConfig.
 *
 * @author cscanigo
 */
public class EquipamentEmbeddedMongoConfig extends EquipamentMongoConfig {

  /**
   * Mongo client.
   *
   * @return mongo client
   */
  @Override
  public MongoClient mongoClient() {

    EmbeddedMongoFactoryBean embeddedMongoFactoryBean = new EmbeddedMongoFactoryBean();
    if (mongo == null) {
      try {
        mongo = embeddedMongoFactoryBean.getObject();
      } catch (IOException e) {
        throw MongoException.fromThrowable(e);
      }
    }
    return mongo;
  }

}

import java.io.IOException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;

/**
 * Class EmbeddedReactorMongoFactoryBean.
 *
 * @author cscanigo
 */
public class EmbeddedMongoFactoryBean extends EmbeddedBaseMongoFactoryBean<MongoClient> {

  /** Constant LOG. */
  private static final Logger LOG = LoggerFactory.getLogger(EmbeddedMongoFactoryBean.class);

  /**
   * Obté object.
   *
   * @return object
   * @throws IOException senyala que una excepció I/O s'ha produït.
   */
  @Override
  public synchronized MongoClient getObject() throws IOException {
    if (mongodExecutable == null) {
      LOG.info("Starting embedded MongoDB instance");
      initMongoServer();
    }
    return MongoClients.create(EMBEDDED_TEST_URI);
  }

  /**
   * Obté object type.
   *
   * @return object type
   */
  @Override
  public Class<?> getObjectType() {
    return MongoClient.class;
  }

}

import java.io.IOException;
import java.net.InetAddress;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;

import de.flapdoodle.embed.mongo.MongodExecutable;
import de.flapdoodle.embed.mongo.MongodProcess;
import de.flapdoodle.embed.mongo.MongodStarter;
import de.flapdoodle.embed.mongo.config.MongodConfig;
import de.flapdoodle.embed.mongo.config.Net;
import de.flapdoodle.embed.mongo.distribution.IFeatureAwareVersion;
import de.flapdoodle.embed.mongo.distribution.Version;
import de.flapdoodle.embed.process.runtime.Network;

/**
 * Class EmbeddedBaseMongoFactoryBean.
 *
 * @author cscanigo
 * @param <E> the element type
 */
public abstract class EmbeddedBaseMongoFactoryBean<E> implements FactoryBean<E>, DisposableBean {

  /** Constant LOG. */
  private static final Logger LOG = LoggerFactory.getLogger(EmbeddedBaseMongoFactoryBean.class);

  /** version. */
  private static final IFeatureAwareVersion version = Version.Main.V4_0;

  /** Constant EMBEDDED_HOST. */
  protected static final String EMBEDDED_HOST = InetAddress.getLoopbackAddress().getHostAddress();

  /** Constant EMBEDDED_PORT. */
  protected static final int EMBEDDED_PORT = getPort();

  /** Constant EMBEDDED_TEST_URI. */
  protected static final String EMBEDDED_TEST_URI = "mongodb://" + EMBEDDED_HOST + ":" + EMBEDDED_PORT + "/canigo";

  /** mongod executable. */
  protected static MongodExecutable mongodExecutable;

  /** mongo process. */
  protected static MongodProcess mongoProcess;

  /**
   * Destroy.
   *
   * @throws Exception exception
   */
  @Override
  public void destroy() throws Exception {
    if (mongodExecutable != null) {
      LOG.info("Stopping embedded MongoDB instance");
      mongodExecutable.stop();
      mongoProcess.stop();
    }
  }

  /**
   * Inicialitza mongo server.
   *
   * @throws IOException senyala que una excepció I/O s'ha produït.
   */
  protected synchronized void initMongoServer() throws IOException {
    MongodConfig mongodConfig = MongodConfig.builder().version(version)
        .net(new Net(EMBEDDED_HOST, EMBEDDED_PORT, Network.localhostIsIPv6())).build();

    mongodExecutable = MongodStarter.getDefaultInstance().prepare(mongodConfig);
    mongoProcess = mongodExecutable.start();
  }

  /**
   * Obté port.
   *
   * @return port
   */
  protected static int getPort() {
    try {
      return Network.getFreeServerPort();
    } catch (IOException ex) {
      LOG.error("Needed free port");
      return 27017;
    }
  }
}

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.TestMethodOrder;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.runners.MethodSorters;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import cat.gencat.provamongo.config.AppConfig;
import cat.gencat.provamongo.mongodb.config.EquipamentEmbeddedMongoConfig;

/**
 * Test cases for the {@link EquipamentMongoRepository}.
 *
 * @author cscanigo
 */
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = { AppConfig.class, EquipamentEmbeddedMongoConfig.class })
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class EquipamentEmbeddedMongoRepositoryTest extends EquipamentMongoRepositoryCoreTest {
}

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;
import org.springframework.context.annotation.PropertySource;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import cat.gencat.ctti.mongodb.config.EquipamentEmbeddedMongoConfig;

@Configuration
@PropertySource("classpath:/config/props/boot.properties")
@ImportResource({ "classpath:cat/gencat/ctti/canigo/arch/core/config/canigo-core.xml" })
@EnableTransactionManagement
@Import(EquipamentEmbeddedMongoConfig.class)
public class EmbeddedMongoAppConfig {
}

import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import cat.gencat.ctti.config.EmbeddedMongoAppConfig;
import cat.gencat.ctti.mongodb.model.repository.EquipamentMongoRepository;

/**
 * Test cases for the {@link EquipamentMongoRepository}.
 */
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = { EmbeddedMongoAppConfig.class})
public class EquipamentEmbeddedMongoRepositoryTest extends EquipamentMongoRepositoryCoreTest{
}

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

import jakarta.inject.Inject;

import org.junit.Before;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;

import cat.gencat.demo.mongodb.model.MongoEquipament;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;

/**
 * Class EquipamentReactiveMongoRepositoryCoreTest.
 *
 * @author cscanigo
 */
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public abstract class EquipamentReactiveMongoRepositoryCoreTest {
  /** repository. */
  @Inject
  EquipamentReactiveMongoRepository repository;
  
  /**
   * Estableix up.
   */
  @Before
  public void setUp() {
    assertNotNull(repository);
    repository.deleteAll();
  }

  /**
   * Test 1 CRUD operations.
   */
  @Test
  public void test1CRUDOperations() {
    
    // Test if table is empty
    Flux<MongoEquipament> mongoEquipamentInitialContent = repository.deleteAll().thenMany(repository.findAll());
    List<MongoEquipament> mongoEquipamentList = new ArrayList<>();
    mongoEquipamentInitialContent.subscribe(mongoEquipamentList::add);
    assertTrue(mongoEquipamentList.isEmpty());

    StepVerifier.create(mongoEquipamentInitialContent).expectNextCount(0).expectComplete().verify();

    // Test save
    MongoEquipament mongoEquipament = new MongoEquipament();
    mongoEquipament.setNom("CAP La Pau");
    mongoEquipament.setMunicipi("Barcelona");
    Mono<MongoEquipament> mongoEquipamentMono = repository.save(mongoEquipament);
    mongoEquipament = mongoEquipamentMono.block(Duration.ofMinutes(1L));
    assertNotNull(mongoEquipament.getId());

    // Test insert and recover
    MongoEquipament mongoEquipament2 = new MongoEquipament();
    mongoEquipament2.setNom("CAP Santa Coloma");
    Mono<MongoEquipament> mongoEquipament2Mono = repository.save(mongoEquipament2);
    mongoEquipament2 = mongoEquipament2Mono.block(Duration.ofMinutes(1L));
    assertNotNull(mongoEquipament2.getId());

    Flux<MongoEquipament> mongoEquipamentFinalContent = repository.findAll();

    StepVerifier.create(mongoEquipamentFinalContent).expectNextCount(2).expectComplete().verify();

    Mono<MongoEquipament> mongoEquipament3Mono = repository.findById(mongoEquipament2.getId());
    assertEquals(mongoEquipament2.getMunicipi(), mongoEquipament3Mono.block().getMunicipi());

    // Test delete all
    repository.deleteAll();
    Mono<Boolean> existsById = repository.existsById(mongoEquipament2.getId());
    StepVerifier.create(existsById).expectNext(true).expectComplete().verify();

  }
}

import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.config.AppConfig;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.config.EquipamentReactiveMongoConfig;

/**
 * Class EquipamentReactiveMongoRepositoryTest.
 * @author cscanigo
 */
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = { AppConfig.class, EquipamentReactiveMongoConfig.class })
public class EquipamentReactiveMongoRepositoryTest extends EquipamentReactiveMongoRepositoryCoreTest {
}

public MongoClient reactiveMongoClient()

import java.io.IOException;
import com.mongodb.MongoException;
import com.mongodb.reactivestreams.client.MongoClient;

/**
 * Class EquipamentEmbeddedReactiveMongoConfig.
 * @author cscanigo
 */
public class EquipamentEmbeddedReactiveMongoConfig extends EquipamentReactiveMongoConfig {
    /**
     * Reactive mongo client.
     * @return mongo client
     */
    @Override
    public MongoClient reactiveMongoClient() {
        EmbeddedReactiveMongoFactoryBean embeddedReactiveMongoFactoryBean = new EmbeddedReactiveMongoFactoryBean();
        if (mongo == null) {
            try {
                mongo = embeddedReactiveMongoFactoryBean.getObject();
            } catch (IOException e) {
                throw MongoException.fromThrowable(e);
            }
        }
        return mongo;
    }
}

import java.io.IOException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.mongodb.reactivestreams.client.MongoClient;
import com.mongodb.reactivestreams.client.MongoClients;

/**
 * Class EmbeddedReactorMongoFactoryBean.
 *
 * @author cscanigo
 */
public class EmbeddedReactiveMongoFactoryBean extends EmbeddedBaseMongoFactoryBean<MongoClient> {

  /** Constant LOG. */
  private static final Logger LOG = LoggerFactory.getLogger(EmbeddedReactiveMongoFactoryBean.class);

  /**
   * Obté object.
   *
   * @return object
   * @throws IOException senyala que una excepció I/O s'ha produït.
   */
  @Override
  public synchronized MongoClient getObject() throws IOException {
    if (mongodExecutable == null) {
      LOG.info("Starting embedded MongoDB instance");
      initMongoServer();
    }
    return MongoClients.create(EMBEDDED_TEST_URI);
  }

  /**
   * Obté object type.
   *
   * @return object type
   */
  @Override
  public Class<?> getObjectType() {
    return MongoClient.class;
  }

}

import java.io.IOException;
import java.net.InetAddress;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;

import de.flapdoodle.embed.mongo.MongodExecutable;
import de.flapdoodle.embed.mongo.MongodProcess;
import de.flapdoodle.embed.mongo.MongodStarter;
import de.flapdoodle.embed.mongo.config.MongodConfig;
import de.flapdoodle.embed.mongo.config.Net;
import de.flapdoodle.embed.mongo.distribution.IFeatureAwareVersion;
import de.flapdoodle.embed.mongo.distribution.Version;
import de.flapdoodle.embed.process.runtime.Network;

/**
 * Class EmbeddedBaseMongoFactoryBean.
 *
 * @author cscanigo
 * @param <E> the element type
 */
public abstract class EmbeddedBaseMongoFactoryBean<E> implements FactoryBean<E>, DisposableBean {

  /** Constant LOG. */
  private static final Logger LOG = LoggerFactory.getLogger(EmbeddedBaseMongoFactoryBean.class);

  /** version. */
  private static final IFeatureAwareVersion version = Version.Main.V4_0;

  /** Constant EMBEDDED_HOST. */
  protected static final String EMBEDDED_HOST = InetAddress.getLoopbackAddress().getHostAddress();

  /** Constant EMBEDDED_PORT. */
  protected static final int EMBEDDED_PORT = getPort();

  /** Constant EMBEDDED_TEST_URI. */
  protected static final String EMBEDDED_TEST_URI = "mongodb://" + EMBEDDED_HOST + ":" + EMBEDDED_PORT + "/canigo";

  /** mongod executable. */
  protected static MongodExecutable mongodExecutable;

  /** mongo process. */
  protected static MongodProcess mongoProcess;

  /**
   * Destroy.
   *
   * @throws Exception exception
   */
  @Override
  public void destroy() throws Exception {
    if (mongodExecutable != null) {
      LOG.info("Stopping embedded MongoDB instance");
      mongodExecutable.stop();
      mongoProcess.stop();
    }
  }

  /**
   * Inicialitza mongo server.
   *
   * @throws IOException senyala que una excepció I/O s'ha produït.
   */
  protected synchronized void initMongoServer() throws IOException {
    MongodConfig mongodConfig = MongodConfig.builder().version(version)
        .net(new Net(EMBEDDED_HOST, EMBEDDED_PORT, Network.localhostIsIPv6())).build();

    mongodExecutable = MongodStarter.getDefaultInstance().prepare(mongodConfig);
    mongoProcess = mongodExecutable.start();
  }

  /**
   * Obté port.
   *
   * @return port
   */
  protected static int getPort() {
    try {
      return Network.getFreeServerPort();
    } catch (IOException ex) {
      LOG.error("Needed free port");
      return 27017;
    }
  }
}

import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.config.AppConfig;
import cat.gencat.ctti.canigo.arch.persistence.mongodb.config.EquipamentEmbeddedReactiveMongoConfig;

/**
 * Class EquipamentEmbeddedReactiveMongoRepositoryTest.
 *
 * @author cscanigo
 */
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = { AppConfig.class, EquipamentEmbeddedReactiveMongoConfig.class })
public class EquipamentEmbeddedReactiveMongoRepositoryTest extends EquipamentReactiveMongoRepositoryCoreTest {
}

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;
import org.springframework.context.annotation.PropertySource;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import cat.gencat.ctti.mongodb.config.EquipamentEmbeddedReactiveMongoConfig;

@Configuration
@PropertySource("classpath:/config/props/boot.properties")
@ImportResource({ "classpath:cat/gencat/ctti/canigo/arch/core/config/canigo-core.xml" })
@EnableTransactionManagement
@Import(EquipamentEmbeddedReactiveMongoConfig.class)
public class EmbeddedReactiveMongoAppConfig {
}

import java.io.IOException;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import de.flapdoodle.embed.mongo.Command;
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.config.RuntimeConfigBuilder;
import de.flapdoodle.embed.mongo.distribution.Version;
import de.flapdoodle.embed.process.config.IRuntimeConfig;
import de.flapdoodle.embed.process.runtime.Network;
import cat.gencat.ctti.mongodb.model.repository.EquipamentMongoRepository;

/**
 * Test cases for the {@link EquipamentMongoRepository}.
 */
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = { EmbeddedReactiveMongoAppConfig.class})
public class EquipamentEmbeddedReactiveMongoRepositoryTest extends EquipamentReactiveMongoRepositoryCoreTest {
}

      <Logger name="org.springframework.data.mongodb.core.MongoTemplate" level="debug" additivity="false">
         <AppenderRef ref="DAILY_LOG" />
      </Logger>