<version>1.7.0-SNAPSHOT</version>
<parent>
- <groupId>org.onap.oparent</groupId>
- <artifactId>oparent</artifactId>
- <version>2.0.0</version>
+ <groupId>org.onap.aai.aai-common</groupId>
+ <artifactId>aai-parent</artifactId>
+ <version>1.7.2</version>
</parent>
<properties>
<icd.file>service.json</icd.file>
<icd.package>org.onap.aai.cacher.service.rest</icd.package>
<!-- Start of Compiler Related Properties -->
- <java.version>1.8</java.version>
- <maven.compiler.source>1.8</maven.compiler.source>
- <maven.compiler.target>1.8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!-- End of Compiler Related Properties -->
<skip.integration.tests>true</skip.integration.tests>
<!-- End of Test Related Properties -->
- <spring.boot.version>1.5.21.RELEASE</spring.boot.version>
-
<eclipse.jetty.version>9.4.1.v20170120</eclipse.jetty.version>
- <docker.registry>docker.io</docker.registry>
<build.number>local</build.number>
<service.account>aai-svc-account</service.account>
<docker.namespace>openecomp</docker.namespace>
-
<!--
Nexus Proxy Properties and Snapshot Locations
Ideally this can be overwritten at runtime per internal environment specific values at runtime
<aai-core.version>1.5.1</aai-core.version>
<aai-schema-service.version>1.6.6</aai-schema-service.version>
- <activemq.version>5.15.8</activemq.version>
-
+
<!-- Start of the jacoco plugin properties -->
<sonar.language>java</sonar.language>
<sonar.java.coveragePlugin>jacoco</sonar.java.coveragePlugin>
<sonar.projectVersion>${project.version}</sonar.projectVersion>
<!-- End of the jacoco plugin properties -->
- <json.version>20090211</json.version>
- <logback.version>1.2.3</logback.version>
- <eelf.core.version>1.0.0</eelf.core.version>
- <mockito.version>1.10.19</mockito.version>
- <json.assert.version>1.5.0</json.assert.version>
<spring.security.version>1.0.8.RELEASE</spring.security.version>
- <common.logging.version>1.2.2</common.logging.version>
<dmaap.client.version>0.2.12</dmaap.client.version>
<dme2.version>2.8.5</dme2.version>
- <commons.configuration.version>1.9</commons.configuration.version>
- <docker.fabric.version>0.23.0</docker.fabric.version>
<!-- Default docker registry that maven fabric plugin will try to pull from -->
<docker.registry>docker.io</docker.registry>
<!-- Specifying the docker push registry where the image should be pushed -->
<!-- This value should be overwritten at runtime to wherever need to be pushed to -->
<docker.push.registry>localhost:5000</docker.push.registry>
+ <aai.common.version>1.7.2</aai.common.version>
<aai.docker.version>1.0.0</aai.docker.version>
<!--
Location where assembly of our scripts, resources and main jar will be held
</profile>
</profiles>
- <dependencyManagement>
- <dependencies>
- <dependency>
- <groupId>org.springframework.boot</groupId>
- <artifactId>spring-boot-starter-parent</artifactId>
- <version>${spring.boot.version}</version>
- <scope>import</scope>
- <type>pom</type>
- </dependency>
- <dependency>
- <groupId>org.apache.activemq</groupId>
- <artifactId>activemq-broker</artifactId>
- <version>${activemq.version}</version>
- </dependency>
- <dependency>
- <groupId>org.apache.activemq</groupId>
- <artifactId>activemq-client</artifactId>
- <version>${activemq.version}</version>
- </dependency>
- <dependency>
- <groupId>org.apache.activemq</groupId>
- <artifactId>activemq-openwire-legacy</artifactId>
- <version>${activemq.version}</version>
- </dependency>
-
- </dependencies>
- </dependencyManagement>
-
<dependencies>
<dependency>
- <groupId>com.fasterxml.jackson.core</groupId>
- <artifactId>jackson-databind</artifactId>
- <version>2.6.3</version>
+ <groupId>javax.jms</groupId>
+ <artifactId>javax.jms-api</artifactId>
+ <version>2.0.1</version>
</dependency>
<dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpclient</artifactId>
- <version>4.5.6</version>
+ <groupId>javax.ws.rs</groupId>
+ <artifactId>javax.ws.rs-api</artifactId>
+ <version>2.1</version>
</dependency>
<dependency>
- <groupId>com.google.code.gson</groupId>
- <artifactId>gson</artifactId>
- <version>2.7</version>
+ <groupId>de.bwaldvogel</groupId>
+ <artifactId>mongo-java-server</artifactId>
+ <version>1.36.0</version>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>de.flapdoodle.embed</groupId>
<artifactId>de.flapdoodle.embed.mongo</artifactId>
- <version>2.2.0</version>
+ <version>3.0.0</version>
<exclusions>
<exclusion>
<groupId>org.apache.commons</groupId>
</exclusions>
</dependency>
<dependency>
- <groupId>org.apache.commons</groupId>
- <artifactId>commons-compress</artifactId>
- <version>1.18</version>
+ <groupId>org.apache.httpcomponents</groupId>
+ <artifactId>httpclient</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.google.code.gson</groupId>
+ <artifactId>gson</artifactId>
</dependency>
<dependency>
- <groupId>org.mongodb</groupId>
- <artifactId>mongodb-driver</artifactId>
- <version>3.6.2</version>
+ <groupId>org.apache.commons</groupId>
+ <artifactId>commons-compress</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<dependency>
<groupId>org.reflections</groupId>
<artifactId>reflections</artifactId>
- <version>0.9.10</version>
</dependency>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
- <version>2.6</version>
- </dependency>
- <dependency>
- <groupId>org.glassfish.jersey.core</groupId>
- <artifactId>jersey-client</artifactId>
- <version>2.24</version>
- </dependency>
- <dependency>
- <groupId>org.glassfish.jersey.core</groupId>
- <artifactId>jersey-common</artifactId>
- <version>2.24</version>
</dependency>
<dependency>
<groupId>com.googlecode.json-simple</groupId>
<artifactId>json-simple</artifactId>
- <version>1.1.1</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>apache-log4j-extras</artifactId>
- <version>1.2.17</version>
<exclusions>
<exclusion>
<artifactId>log4j</artifactId>
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
- <version>${json.version}</version>
- </dependency>
- <dependency>
- <groupId>javax.ws.rs</groupId>
- <artifactId>javax.ws.rs-api</artifactId>
- <version>2.0.1</version>
</dependency>
<dependency>
<groupId>org.onap.aai.aai-common</groupId>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-core</artifactId>
</exclusion>
+ <exclusion>
+ <groupId>org.eclipse.jetty</groupId>
+ <artifactId>jetty-http</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>org.eclipse.jetty</groupId>
+ <artifactId>jetty-server</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-web</artifactId>
+ </exclusion>
</exclusions>
</dependency>
<dependency>
<dependency>
<groupId>com.att.eelf</groupId>
<artifactId>eelf-core</artifactId>
- <version>${eelf.core.version}</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-core</artifactId>
- <version>${logback.version}</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
- <version>${logback.version}</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-access</artifactId>
- <version>${logback.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
- <version>${mockito.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.skyscreamer</groupId>
<artifactId>jsonassert</artifactId>
- <version>${json.assert.version}</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>com.github.fakemongo</groupId>
- <artifactId>fongo</artifactId>
- <version>2.2.0-RC2</version>
<scope>test</scope>
</dependency>
<!--
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
+import org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
-import org.springframework.boot.web.support.SpringBootServletInitializer;
+import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication
@EnableScheduling
-@EnableAutoConfiguration(exclude = { DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class })
+@EnableAutoConfiguration(exclude = { DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class, EmbeddedMongoAutoConfiguration.class})
@ComponentScan(basePackages = { "org.onap.aai.cacher", "com" })
public class Application extends SpringBootServletInitializer {
LoggingContext.statusCode(StatusCode.COMPLETE);
SpringApplication app = new SpringApplication(Application.class);
- app.setLogStartupInfo(false);
+ app.setLogStartupInfo(true);
app.setRegisterShutdownHook(true);
app.addInitializers(new PropertyPasswordConfiguration());
app.run(args);
import de.flapdoodle.embed.mongo.MongodExecutable;
import de.flapdoodle.embed.mongo.MongodProcess;
import de.flapdoodle.embed.mongo.MongodStarter;
-import de.flapdoodle.embed.mongo.config.*;
+import de.flapdoodle.embed.mongo.config.Defaults;
+import de.flapdoodle.embed.mongo.config.MongoCmdOptions;
+import de.flapdoodle.embed.mongo.config.MongodConfig;
+import de.flapdoodle.embed.mongo.config.Net;
import de.flapdoodle.embed.mongo.distribution.Version;
import de.flapdoodle.embed.process.config.io.ProcessOutput;
import de.flapdoodle.embed.process.io.Processors;
private static final EELFLogger EELF_LOGGER = EELFManager.getInstance().getLogger(MongoConfig.class);
- @Value("${mongodb.host}")
+ @Value("${spring.data.mongodb.host}")
private String MONGO_DB_HOST;
- @Value("${mongodb.dbName}")
+ @Value("${spring.data.mongodb.database}")
private String MONGO_DB_NAME;
- @Value("${mongodb.port}")
+ @Value("${spring.data.mongodb.port}")
private int MONGO_DB_PORT;
private MongodProcess mongod;
Logger logger = LoggerFactory.getLogger("mongo");
int port = MONGO_DB_PORT;
- IMongodConfig mongoConfigConfig = new MongodConfigBuilder()
+ MongodConfig mongoConfigConfig = MongodConfig.builder()
.version(Version.Main.PRODUCTION)
.net(new Net(port, Network.localhostIsIPv6()))
- .cmdOptions(new MongoCmdOptionsBuilder().enableTextSearch(true).useNoPrealloc(false).build())
- .configServer(false)
+ .cmdOptions(MongoCmdOptions.builder().enableTextSearch(true).useNoPrealloc(false).build())
+ .isConfigServer(false)
.build();
ProcessOutput processOutput = new ProcessOutput(Processors.logTo(logger, Slf4jLevel.WARN), Processors.logTo(logger,
Slf4jLevel.WARN), Processors.logTo(logger, Slf4jLevel.WARN));
MongodExecutable mongodExecutable = MongodStarter
- .getInstance((new RuntimeConfigBuilder())
- .defaults(Command.MongoD)
+ .getInstance(Defaults.runtimeConfigFor(Command.MongoD)
.processOutput(processOutput)
.build())
.prepare(mongoConfigConfig);
* @return
*/
public String encodeProp(String string) {
- try {
- return UriUtils.encode(string, "UTF-8");
- } catch (UnsupportedEncodingException e) {
- return "";
- }
+ return UriUtils.encode(string, "UTF-8");
}
/**
* @return
*/
public String decodeProp(String string) {
- try {
- return UriUtils.decode(string, "UTF-8");
- } catch (UnsupportedEncodingException e) {
- return "";
- }
+ return UriUtils.decode(string, "UTF-8");
}
public String getAAIUriFromEntityUri(String fullUri) {
private static final int TASK_INTERVAL_TIME = 30000;
private static final int TASK_DELAY_TIME = 0;
- private ScheduledTaskConfig(){}
+ //private ScheduledTaskConfig(){}
@Configuration
static class RegisterTaskSchedulerViaSchedulingConfigurer implements SchedulingConfigurer {
@Bean
RestTemplate restTemplate(RestTemplateBuilder builder) throws Exception {
- RestTemplate restTemplate = builder.requestFactory(new HttpComponentsClientHttpRequestFactory(restClient))
+ RestTemplate restTemplate = builder.requestFactory(() -> new HttpComponentsClientHttpRequestFactory(restClient))
.build();
restTemplate.setErrorHandler(new ResponseErrorHandler() {
*/
package org.onap.aai.cacher.web;
-import org.glassfish.jersey.filter.LoggingFilter;
+import org.glassfish.jersey.logging.LoggingFeature;
import org.glassfish.jersey.server.ResourceConfig;
import org.onap.aai.cacher.service.rest.CacheInteractionService;
import org.onap.aai.cacher.service.rest.CacheKeyService;
// If the LoggingFilter second argument is set to true, it will print response
// value as well
if ("true".equalsIgnoreCase(env.getProperty("aai.request.logging.enabled"))) {
- register(new LoggingFilter(log, false));
+ register(new LoggingFeature(log, 0));
}
}
import ch.qos.logback.access.jetty.RequestLogImpl;
import org.eclipse.jetty.server.handler.HandlerCollection;
import org.eclipse.jetty.server.handler.RequestLogHandler;
-import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
-import org.springframework.boot.context.embedded.jetty.JettyEmbeddedServletContainerFactory;
-import org.springframework.boot.context.embedded.jetty.JettyServerCustomizer;
+import org.springframework.boot.web.embedded.jetty.JettyServerCustomizer;
+import org.springframework.boot.web.embedded.jetty.JettyServletWebServerFactory;
+import org.springframework.boot.web.servlet.server.AbstractServletWebServerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
public class LocalHostAccessLog {
@Bean
- public EmbeddedServletContainerFactory jettyConfigBean() {
- JettyEmbeddedServletContainerFactory jef = new JettyEmbeddedServletContainerFactory();
+ public AbstractServletWebServerFactory jettyConfigBean() {
+ JettyServletWebServerFactory jef = new JettyServletWebServerFactory();
jef.addServerCustomizers((JettyServerCustomizer) server -> {
HandlerCollection handlers = new HandlerCollection();
spring.mvc.urls=swagger,docs,prometheus
-server.contextPath=/
+server.servlet.context-path=/
spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
spring.profiles.active=production,one-way-ssl
server.ssl.key-store-type=JKS
#mongodb configuration values
-mongodb.host=localhost
-mongodb.dbName=aai
-mongodb.port=27017
+spring.data.mongodb.host=localhost
+spring.data.mongodb.database=aai
+spring.data.mongodb.port=27017
#logging configurations
aai.transaction.logging=true
import de.flapdoodle.embed.mongo.MongodExecutable;
import de.flapdoodle.embed.mongo.MongodProcess;
import de.flapdoodle.embed.mongo.MongodStarter;
-import de.flapdoodle.embed.mongo.config.*;
+import de.flapdoodle.embed.mongo.config.Defaults;
+import de.flapdoodle.embed.mongo.config.MongoCmdOptions;
+import de.flapdoodle.embed.mongo.config.MongodConfig;
+import de.flapdoodle.embed.mongo.config.Net;
import de.flapdoodle.embed.mongo.distribution.Version;
import de.flapdoodle.embed.process.config.io.ProcessOutput;
import de.flapdoodle.embed.process.io.Processors;
protected static void startEmbedded(int port) throws IOException {
Logger logger = LoggerFactory.getLogger("mongo");
- IMongodConfig mongoConfigConfig = new MongodConfigBuilder()
+ MongodConfig mongoConfigConfig = MongodConfig.builder()
.version(Version.Main.PRODUCTION)
.net(new Net(port, Network.localhostIsIPv6()))
- .cmdOptions(new MongoCmdOptionsBuilder().enableTextSearch(true).useNoPrealloc(false).build())
- .configServer(false)
+ .cmdOptions(MongoCmdOptions.builder().enableTextSearch(true).useNoPrealloc(false).build())
+ .isConfigServer(false)
.build();
ProcessOutput processOutput = new ProcessOutput(Processors.logTo(logger, Slf4jLevel.WARN), Processors.logTo(logger,
Slf4jLevel.WARN), Processors.logTo(logger, Slf4jLevel.WARN));
MongodExecutable mongodExecutable = MongodStarter
- .getInstance((new RuntimeConfigBuilder())
- .defaults(Command.MongoD)
+ .getInstance(Defaults.runtimeConfigFor(Command.MongoD)
.processOutput(processOutput)
.build())
.prepare(mongoConfigConfig);
protected static void startEmbedded(int port) throws IOException {
Logger logger = LoggerFactory.getLogger("mongo");
- IMongodConfig mongoConfigConfig = new MongodConfigBuilder()
+ MongodConfig mongoConfigConfig = MongodConfig.builder()
.version(Version.Main.PRODUCTION)
.net(new Net(port, Network.localhostIsIPv6()))
- .cmdOptions(new MongoCmdOptionsBuilder().enableTextSearch(true).useNoPrealloc(false).build())
- .configServer(false)
+ .cmdOptions(MongoCmdOptions.builder().enableTextSearch(true).useNoPrealloc(false).build())
+ .isConfigServer(false)
.build();
ProcessOutput processOutput = new ProcessOutput(Processors.logTo(logger, Slf4jLevel.WARN), Processors.logTo(logger,
Slf4jLevel.WARN), Processors.logTo(logger, Slf4jLevel.WARN));
MongodExecutable mongodExecutable = MongodStarter
- .getInstance((new RuntimeConfigBuilder())
- .defaults(Command.MongoD)
+ .getInstance(Defaults.runtimeConfigFor(Command.MongoD)
.processOutput(processOutput)
.build())
.prepare(mongoConfigConfig);
*/
package org.onap.aai.cacher.common;
-import com.github.fakemongo.Fongo;
import com.google.gson.JsonParser;
import com.mongodb.DB;
+import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.UpdateOptions;
+import de.bwaldvogel.mongo.MongoServer;
+import de.bwaldvogel.mongo.backend.memory.MemoryBackend;
import org.bson.Document;
import org.json.JSONException;
import org.json.JSONObject;
import org.onap.aai.cacher.model.DBAction;
import org.skyscreamer.jsonassert.JSONAssert;
+import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
@BeforeClass
public static void setup() {
- Fongo fongo = new Fongo(DB_NAME);
- mongoDatabase = fongo.getDatabase(DB_NAME);
- db = fongo.getDB(DB_NAME);
+ MongoServer mongoServer = new MongoServer(new MemoryBackend());
+ InetSocketAddress serverAddress = mongoServer.bind();
+
+ MongoClient client = new MongoClient(new ServerAddress(serverAddress));
+ mongoDatabase = client.getDatabase(DB_NAME);
+ db = client.getDB(DB_NAME);
}
@Before
.getClass()
.getEnclosingMethod()
.getName();
- setupCollection(collectionName);
MongoCollection<Document> collection = setupCollection(collectionName);
.getClass()
.getEnclosingMethod()
.getName();
- setupCollection(collectionName);
MongoCollection<Document> collection = setupCollection(collectionName);
.getClass()
.getEnclosingMethod()
.getName();
- setupCollection(collectionName);
MongoCollection<Document> collection = setupCollection(collectionName);
.getClass()
.getEnclosingMethod()
.getName();
- setupCollection(collectionName);
MongoCollection<Document> collection = setupCollection(collectionName);
.getClass()
.getEnclosingMethod()
.getName();
- setupCollection(collectionName);
MongoCollection<Document> collection = setupCollection(collectionName);
*/
package org.onap.aai.cacher.dmaap.consumer;
-import com.github.fakemongo.Fongo;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.mongodb.DB;
import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
import com.mongodb.client.MongoDatabase;
+import de.bwaldvogel.mongo.MongoServer;
+import de.bwaldvogel.mongo.backend.memory.MemoryBackend;
import de.flapdoodle.embed.mongo.MongodProcess;
import org.apache.commons.io.IOUtils;
import org.bson.Document;
import java.io.IOException;
import java.io.InputStream;
+import java.net.InetSocketAddress;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
@BeforeClass
public static void setup() throws IOException, InterruptedException {
- Fongo fongo = new Fongo(DB_NAME);
- mongoDb = fongo.getDatabase(DB_NAME);
- db = fongo.getDB(DB_NAME);
+ MongoServer mongoServer = new MongoServer(new MemoryBackend());
+ InetSocketAddress serverAddress = mongoServer.bind();
+
+ MongoClient client = new MongoClient(new ServerAddress(serverAddress));
+ mongoDb = client.getDatabase(DB_NAME);
+ db = client.getDB(DB_NAME);
}
@AfterClass
package org.onap.aai.cacher.dmaap.consumer;
import com.att.nsa.mr.client.MRConsumer;
-import com.github.fakemongo.Fongo;
import com.mongodb.DB;
import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
import com.mongodb.client.MongoDatabase;
+import de.bwaldvogel.mongo.MongoServer;
+import de.bwaldvogel.mongo.backend.memory.MemoryBackend;
import de.flapdoodle.embed.mongo.MongodProcess;
import org.hamcrest.Matchers;
import org.junit.*;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.io.IOException;
+import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertThat;
-//@Ignore
@RunWith(SpringJUnit4ClassRunner.class)
@Configuration
@ContextConfiguration(classes = {InjestionTestComponent.class, AAIEventConsumerTest.class})
@BeforeClass
public static void setup() throws IOException, InterruptedException {
- Fongo fongo = new Fongo(DB_NAME);
- mongoDb = fongo.getDatabase(DB_NAME);
- db = fongo.getDB(DB_NAME);
+
+ MongoServer mongoServer = new MongoServer(new MemoryBackend());
+ InetSocketAddress serverAddress = mongoServer.bind();
+
+ MongoClient client = new MongoClient(new ServerAddress(serverAddress));
+ mongoDb = client.getDatabase(DB_NAME);
+ db = client.getDB(DB_NAME);
}
@Before
*/
package org.onap.aai.cacher.injestion.parser;
-import com.github.fakemongo.Fongo;
import com.mongodb.DB;
import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
import com.mongodb.client.MongoDatabase;
+import de.bwaldvogel.mongo.MongoServer;
+import de.bwaldvogel.mongo.backend.memory.MemoryBackend;
import de.flapdoodle.embed.mongo.MongodProcess;
import org.junit.After;
import org.junit.AfterClass;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.io.IOException;
+import java.net.InetSocketAddress;
import java.util.*;
import static org.hamcrest.CoreMatchers.is;
@BeforeClass
public static void setup() throws IOException, InterruptedException {
- Fongo fongo = new Fongo(DB_NAME);
- mongoDb = fongo.getDatabase(DB_NAME);
- db = fongo.getDB(DB_NAME);
+ MongoServer mongoServer = new MongoServer(new MemoryBackend());
+ InetSocketAddress serverAddress = mongoServer.bind();
+
+ MongoClient client = new MongoClient(new ServerAddress(serverAddress));
+ mongoDb = client.getDatabase(DB_NAME);
+ db = client.getDB(DB_NAME);
}
@AfterClass
*/
package org.onap.aai.cacher.injestion.parser;
-import com.github.fakemongo.Fongo;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.mongodb.DB;
import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
import com.mongodb.client.MongoDatabase;
+import de.bwaldvogel.mongo.MongoServer;
+import de.bwaldvogel.mongo.backend.memory.MemoryBackend;
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.MongoCmdOptionsBuilder;
-import de.flapdoodle.embed.mongo.config.MongodConfigBuilder;
+import de.flapdoodle.embed.mongo.config.MongoCmdOptions;
+import de.flapdoodle.embed.mongo.config.MongodConfig;
import de.flapdoodle.embed.mongo.config.Net;
import de.flapdoodle.embed.mongo.distribution.Version;
import de.flapdoodle.embed.process.runtime.Network;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.io.IOException;
+import java.net.InetSocketAddress;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
@BeforeClass
public static void setup() throws IOException, InterruptedException {
- Fongo fongo = new Fongo(DB_NAME);
- mongoDb = fongo.getDatabase(DB_NAME);
- db = fongo.getDB(DB_NAME);
+ MongoServer mongoServer = new MongoServer(new MemoryBackend());
+ InetSocketAddress serverAddress = mongoServer.bind();
+
+ MongoClient client = new MongoClient(new ServerAddress(serverAddress));
+ mongoDb = client.getDatabase(DB_NAME);
+ db = client.getDB(DB_NAME);
}
protected static void startEmbedded(int port) throws IOException {
- IMongodConfig mongoConfigConfig = new MongodConfigBuilder()
+ MongodConfig mongoConfigConfig = MongodConfig.builder()
.version(Version.Main.PRODUCTION)
.net(new Net(port, Network.localhostIsIPv6()))
- .cmdOptions(new MongoCmdOptionsBuilder().verbose(true).build())
- .configServer(false)
+ .cmdOptions(MongoCmdOptions.builder().isVerbose(true).build())
+ .isConfigServer(false)
.build();
MongodExecutable mongodExecutable = MongodStarter.getDefaultInstance().prepare(mongoConfigConfig);
*/
package org.onap.aai.cacher.service.helper;
-import com.github.fakemongo.Fongo;
import com.mongodb.DB;
import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
import com.mongodb.client.MongoDatabase;
+import de.bwaldvogel.mongo.MongoServer;
+import de.bwaldvogel.mongo.backend.memory.MemoryBackend;
import de.flapdoodle.embed.mongo.MongodProcess;
import org.junit.After;
import org.junit.AfterClass;
import javax.ws.rs.core.Response;
import java.io.IOException;
+import java.net.InetSocketAddress;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
@Bean
public RestClientHelperService restClientHelperService() {
- return restClientHelperService;
+ return new RestClientHelperService();
}
@Bean
@BeforeClass
public static void setup() throws IOException, InterruptedException {
- Fongo fongo = new Fongo(DB_NAME);
- mongoDb = fongo.getDatabase(DB_NAME);
- db = fongo.getDB(DB_NAME);
+ MongoServer mongoServer = new MongoServer(new MemoryBackend());
+ InetSocketAddress serverAddress = mongoServer.bind();
+
+ MongoClient client = new MongoClient(new ServerAddress(serverAddress));
+ mongoDb = client.getDatabase(DB_NAME);
+ db = client.getDB(DB_NAME);
}
@AfterClass
*/
package org.onap.aai.cacher.service.helper;
-import com.github.fakemongo.Fongo;
+import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.FindOneAndUpdateOptions;
import com.mongodb.client.model.UpdateOptions;
+import de.bwaldvogel.mongo.MongoServer;
+import de.bwaldvogel.mongo.backend.memory.MemoryBackend;
import org.bson.Document;
import org.junit.BeforeClass;
import org.junit.Test;
+import java.net.InetSocketAddress;
+
import static org.junit.Assert.assertEquals;
public class CrudOperationsTest {
@BeforeClass
public static void setup() {
- Fongo fongo = new Fongo(DB_NAME);
- mongoDatabase = fongo.getDatabase(DB_NAME);
+ MongoServer mongoServer = new MongoServer(new MemoryBackend());
+ InetSocketAddress serverAddress = mongoServer.bind();
+
+ MongoClient client = new MongoClient(new ServerAddress(serverAddress));
+ mongoDatabase = client.getDatabase(DB_NAME);
}
@Test