public ObjectsRepositoryTests()
{
runner = MongoDbRunner.Start();
var database = TestHelpers.GetDefaultDatabase(runner.ConnectionString);
repo = new ObjectsRepository(TestHelpers.GetDefaultMapper(), new DbContext(database));
}
static void Main(string[] args)
{
Console.WriteLine("Hello Mongo In-Memory World!");
var mongo = MongoDbRunner.Start(Path.Combine("mongo", Guid.NewGuid().ToString()));
var service = new BookService(new BookstoreDatabaseSettings {
BookstoreCollectionName = "BookstoreCollection",
ConnectionString = mongo.ConnectionString,
DatabaseName = "BookstoreDatabase"
});
service.Create(new Book {
Id = "5bfd996f7b8e48dc15ff215d",
BookName = "Design Patterns",
Author = "Ralph Johnson",
Category = "Computers",
Price = 54.93M
});
Console.WriteLine("Wrote a book in the store");
var book = service.Get("5bfd996f7b8e48dc15ff215d");
Console.WriteLine($"Book readed from store is '{book.BookName}'");
}
protected TestBase()
{
var runner = MongoDbRunner.Start();
ApplicationBootstrap.AddTestingServicesRegistrar(r =>
{
r.RegisterServices(register =>
{
register.Register <IDbContextProvider <EventStoreContext>, FakedEventStoreContextProvider>();
register
.Register <IDbContextProvider <RestAirlineReadModelContext>,
FakedEntityFramewokReadModelDbContextProvider>();
register.Register(f =>
{
MongoUrl mongoUrl = new MongoUrl(runner.ConnectionString);
IMongoDatabase mongoDatabase = new MongoClient(mongoUrl).GetDatabase("restairline-api-tests");
return(mongoDatabase);
}, Lifetime.Singleton);
});
});
var hostBuilder = new WebHostBuilder()
.UseEnvironment("UnitTest")
.ConfigureAppConfiguration((context, builder) => { builder.AddJsonFile("appsettings.UnitTest.json"); })
.UseStartup <Startup>();
_server = new TestServer(hostBuilder);
HttpClient = _server.CreateClient();
CommandBus = ServiceProvider.GetService <ICommandBus>();
}
public void SetUp()
{
_mongoDbRunner = MongoDbRunner.Start(additionalMongodArguments: "--quiet");
var connection = new MongoClient(_mongoDbRunner.ConnectionString);
var database = connection.GetDatabase("Test");
var gridFsBucket = new GridFSBucket(database);
_scanBackendService = new Mock <IScanBackendService>();
_scanBackendService
.SetupGet(x => x.List)
.Returns(() => new[]
{
new ScanBackend {
Id = "dummy", Enabled = true
},
new ScanBackend {
Id = "clamav", Enabled = true
},
new ScanBackend {
Id = "disabled", Enabled = false
}
});
_resultService = new ScanResultService(
database, gridFsBucket, _scanBackendService.Object);
}
public async Task UpdateDriverInfos_Successfull()
{
using (var runner = MongoDbRunner.Start())
{
var database = new DatabaseService(runner.ConnectionString, "UpdateDriverInfos_Successfull");
var collection = database.GetCollection <Motorista>();
collection.InsertOne(new Motorista {
Id = "507f191e810c19729de860ea", Cpf = "123.456.789-00", Idade = 20, Nome = "Firstname Lastname", PossuiVeiculoProprio = true, Sexo = Sexo.Feminino, TipoCnh = TipoCnh.A
});
collection.InsertOne(new Motorista {
Id = "40af192e110d19029d986dea", Cpf = "987.654.321-00", Idade = 25, Nome = "Firstname Middlename Lastname", PossuiVeiculoProprio = true, Sexo = Sexo.Masculino, TipoCnh = TipoCnh.D
});
var command = new Command {
MotoristaId = "507f191e810c19729de860ea", Idade = 20, Nome = "New name", Sexo = Sexo.Feminino, PossuiVeiculoProprio = false, TipoCnh = TipoCnh.B
};
var handler = new CommandHandler(database);
var result = await handler.Handle(command);
Assert.IsTrue(result.IsOk);
var updated = await collection.AsQueryable().SingleOrDefaultAsync(m => m.Id == "507f191e810c19729de860ea");
Assert.AreEqual("New name", updated.Nome);
Assert.AreEqual(Sexo.Feminino, updated.Sexo);
Assert.IsFalse(updated.PossuiVeiculoProprio);
Assert.AreEqual(TipoCnh.B, updated.TipoCnh);
}
}
public NoteRepositoryTests()
{
_testModels = new[]
{
new Note
{
Title = "1",
PatientId = 1
},
new Note
{
Title = "2",
PatientId = 1
},
new Note
{
Title = "3",
PatientId = 2
}
};
_runner = MongoDbRunner.Start();
_client = new MongoClient(_runner.ConnectionString);
var db = _client.GetDatabase("IntegrationTests");
var collection = db.GetCollection <Note>("Notes");
collection.InsertMany(_testModels);
}
public void ConfigureMongoDb(IServiceCollection services)
{
services.AddSingleton <MongoDbRunner>(sp =>
{
return(MongoDbRunner.Start());
});
services.AddTransient <MongoClient>(sp =>
{
var mongoDbRunner = sp.GetRequiredService <MongoDbRunner>();
return(new MongoClient(mongoDbRunner.ConnectionString));
});
services.AddTransient <ICarRepository, MongoRepository>(sp =>
{
var mongoClient = sp.GetRequiredService <MongoClient>();
ApplicationSettings config = sp.GetRequiredService <IOptions <ApplicationSettings> >().Value;
return(new MongoRepository(mongoClient, config.MongoDb.MainDb));
});
services.AddTransient <IIdentityMongoRepository <User>, IdentityMongoRepository <User> >(sp =>
{
var mongoClient = sp.GetRequiredService <MongoClient>();
ApplicationSettings config = sp.GetRequiredService <IOptions <ApplicationSettings> >().Value;
return(new IdentityMongoRepository <User>(mongoClient, config.MongoDb.MongoDbIdentity));
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
_runner = MongoDbRunner.Start();
builder.UseEnvironment("Release");
builder.ConfigureAppConfiguration((ctx, config) =>
{
config.AddInMemoryCollection(new Dictionary <string, string>()
{
["MongoDb:ConnectionString"] = _runner.ConnectionString,
["MongoDb:DatabaseName"] = Guid.NewGuid().ToString(),
["Jwt:Secret"] = new string('#', 1000),
["Jwt:JwtTokenLifespan"] = TimeSpan.FromMinutes(5).ToString(),
["Jwt:RefreshTokenLifespan"] = TimeSpan.FromMinutes(7).ToString(),
});
});
builder.ConfigureTestServices((services) =>
{
var systemClockMock = new Mock <ISystemClock>();
systemClockMock.Setup(x => x.UtcNow).Returns(UtcNow);
var sd = new ServiceDescriptor(typeof(ISystemClock), _ => systemClockMock.Object, ServiceLifetime.Transient);
services.Replace(sd);
});
base.ConfigureWebHost(builder);
}
private (MongoDbRunner, string, IMongoCollection <SampleModel>) CreateDb(string databaseName, string collectionName)
{
//Use 'MongoDbRunner.StartForDebugging' instead of 'MongoDbRunner.Start', if you want to see the data in MongoDb.
//'MongoDbRunner.Start' will delete the db after use whereas 'MongoDbRunner.StartForDebugging' doesn't
var runner = MongoDbRunner.Start(singleNodeReplSet: false);
var connectionString = runner.ConnectionString;
var client = new MongoClient(connectionString);
var database = client.GetDatabase(MongoDbEntities.DatabaseName);
var collection = database.GetCollection <SampleModel>(MongoDbEntities.CollectionName);
collection.InsertOne(new SampleModel(12345, 1)
{
Name = "Goku",
Address = "Kame House",
City = "Some Island",
Country = "Japan",
PhoneNumbers = new List <int> {
1234567890, 2143658709
}
});
return(runner, connectionString, collection);
}
public async Task ZeroDriverWithVehicle_ReturnZero()
{
using (var runner = MongoDbRunner.Start())
{
var database = new DatabaseService(runner.ConnectionString, "TwoDriversWithVehicle_ReturnTwo");
var motoristaCollection = database.GetCollection <Motorista>();
var registroCollection = database.GetCollection <Registro>();
var motoristas = new List <Motorista>()
{
new Motorista {
Id = "507f191e810c19729de860ea", Cpf = "123.456.789-00", PossuiVeiculoProprio = false
},
new Motorista {
Id = "40af192e110d19029d986dea", Cpf = "321.654.987-00", PossuiVeiculoProprio = false
},
new Motorista {
Id = "21af192e1fdde90292987dba", Cpf = "432.432.423-05", PossuiVeiculoProprio = false
},
new Motorista {
Id = "7f19192e190029029d986dbb", Cpf = "987.423.123-03", PossuiVeiculoProprio = false
}
};
await motoristaCollection.InsertManyAsync(motoristas);
var query = new Query();
var handler = new QueryHandler(database);
var result = await handler.Handle(query);
Assert.AreEqual(0, result);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("v1", new Info {
Title = "Customer API", Version = "v1"
});
});
var connectionString = Configuration.GetConnectionString("customersDB");
if (Configuration.GetValue <bool>("UseMongo2Go"))
{
var runner = MongoDbRunner.StartForDebugging();
services.AddSingleton(runner);
connectionString = runner.ConnectionString + "customers";
}
var database = OpenDatabaseConnection(connectionString);
services.AddSingleton(database);
var serviceProvider = services.BuildServiceProvider();
services.AddPlatibusServices(configure: configuration =>
{
var sink = serviceProvider.GetService <AspNetCoreLoggingSink>();
configuration.DiagnosticService.AddSink(sink);
});
}
public ApiE2E(DatabaseTestFixture fixture)
{
_runner = fixture.Db;
var dbSettings = new MongoDbSettings {
ConnectionString = _runner.ConnectionString, Database = "Testing"
};
_runner.Import(dbSettings.Database, "Clients", Path.Combine(Directory.GetCurrentDirectory(), @"Client_SeedData.json"), true);
_runner.Import(dbSettings.Database, "AuthUsers", Path.Combine(Directory.GetCurrentDirectory(), @"Users_SeedData.json"), true);
var settings = new Dictionary <string, string>()
{
{ "MongoDbSettings:ConnectionString", dbSettings.ConnectionString },
{ "MongoDbSettings:Database", dbSettings.Database }
};
var builder = new WebHostBuilder()
.ConfigureAppConfiguration((hostingContext, config) => config.AddInMemoryCollection(settings))
.UseStartup <Gibson.Api.Startup>();
_testServer = new TestServer(builder);
_client = _testServer.CreateClient();
_client.DefaultRequestHeaders.Add("Authorization", "Bearer " + NMJ_TOKEN);
_client.DefaultRequestHeaders.Add("Gibson-ClientKey", "nmj");
_client.DefaultRequestHeaders.Add("referer", "https://mycars.io/nmj/route/anotherroute");
}
public GameSessionFeedbackIntegrationTest(WebApplicationFactory <Startup> factory)
{
_runner = MongoDbRunner.Start();
FeedbackDatabaseSettings _databaseSettings = new FeedbackDatabaseSettings()
{
ConnectionString = _runner.ConnectionString,
SessionFeedbacksCollectionName = "SessionFeedbacks"
};
GameSessionFeedbackProperties _feedbackProperties = new GameSessionFeedbackProperties()
{
GameKey = "IntegrationTest",
ServiceName = "GameSessionFeedbackIntegration"
};
_factory = factory.WithWebHostBuilder(builder =>
{
builder.ConfigureTestServices(
services =>
{
services.Configure <FeedbackDatabaseSettings>(settings =>
{
settings.ConnectionString = _databaseSettings.ConnectionString;
settings.SessionFeedbacksCollectionName = _databaseSettings.SessionFeedbacksCollectionName;
});
services.Configure <GameSessionFeedbackProperties>(properties =>
{
properties.GameKey = _feedbackProperties.GameKey;
properties.ServiceName = _feedbackProperties.ServiceName;
});
});
});
_client = _factory.CreateClient();
}
public async Task RunBeforeAllTests()
{
//Setup MongoDB InMemory
MongoDbServer = MongoDbRunner.Start();
// Setup IoC Container
var builder = new ContainerBuilder();
builder.RegisterModule(new IoCModuleApplicationService());
builder.RegisterModule(new IoCModuleInfrastructure());
builder.RegisterModule(new IoCModuleAutoMapper());
builder.RegisterModule(new IoCModuleDomainTest());
builder.RegisterModule(new IoCModuleDatabase());
var settings = new MongoSettings
{
ConnectionString = MongoDbServer.ConnectionString,
DatabaseName = "Database-Domain-Tests"
};
builder.RegisterInstance(settings);
Container = builder.Build();
//Apply Db Migrations
var migrator = Container.Resolve <IDatabaseMigrator>();
await migrator.ApplyMigrations();
}
public static TMongoContext GetMongoContext <TMongoContext>()
where TMongoContext : BaseMongoContext
{
MockHelper.DisposeMongoDbRunner();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
_runner = MongoDbRunner.Start(MongoTestPath, "*/tools/mongodb-linux*/bin", Environment.GetEnvironmentVariable("HOME") + "/.nuget/packages/mongo2go");
}
else
{
_runner = MongoDbRunner.Start(MongoTestPath);
}
var mongoUrlBuilder = new MongoUrlBuilder(_runner.ConnectionString);
mongoUrlBuilder.DatabaseName = Guid.NewGuid().ToString();
var client = new MongoClient(mongoUrlBuilder.ToMongoUrl());
var database = client.GetDatabase(mongoUrlBuilder.DatabaseName);
var db = (TMongoContext)Activator.CreateInstance(typeof(TMongoContext), database);
return(db);
}
public async Task UpdateObjectThatExist()
{
var runner = MongoDbRunner.Start();
var database = TestHelpers.GetDefaultDatabase(runner.ConnectionString);
var path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "1.json");
runner.Import("okn", "objects", path, true);
var config = new MapperConfiguration(cfg => cfg.AddProfile(typeof(MappingProfile)));
var mapper = config.CreateMapper();
var repo = new ObjectsRepository(mapper, new DbContext(database));
var command = new UpdateObjectCommand("5af2796e32522f798f822a41")
{
Name = "TEST1"
};
await repo.UpdateObject(command, CancellationToken.None);
;
// var entities = _database.GetCollection<ObjectEntity>("objects").Find(Builders<ObjectEntity>.Filter
// .Where(x => x.ObjectId == command.ObjectId)).ToList();
// Assert.Single(entities);
// Assert.Equal(command.Name, entities[0].Name);
// var versions = _database.GetCollection<ObjectEntity>("objects_versions").Find(Builders<ObjectEntity>.Filter
// .Where(x => x.ObjectId == command.ObjectId)).ToList();
// Assert.Single(versions);
// Assert.Equal("TEST", versions[0].Name);
}
public void IterationSetup()
{
var runner = MongoDbRunner.Start(singleNodeReplSet: true);
var client = new MongoClient(runner.ConnectionString);
database = client.GetDatabase("testdb");
random = new Random(32);
collectionName = Guid.NewGuid().ToString();
collection = database.GetCollection <Outer>(collectionName);
var outers = new List <Outer>();
for (var o = 0; o < NumberOfOuters; o++)
{
var data = new Outer
{
Id = "OuterX",
Elements = new List <Element>(),
};
for (var i = 0; i < NumberOfElements; i++)
{
var element = new Element {
Id = "ElementX"
};
element.DeletedAt = random.NextDouble() <= PercentageOfDeletedElements ? (DateTime?)DateTime.Now : null;
data.Elements.Add(element);
}
outers.Add(data);
}
collection.InsertMany(outers);
}
public async Task <Outer> GetDbFilter()
{
var runner = MongoDbRunner.Start(singleNodeReplSet: true);
var client = new MongoClient(runner.ConnectionString);
database = client.GetDatabase("testdb");
collection = database.GetCollection <Outer>(collectionName);
var aggregate = collection.Aggregate();
var expression = new BsonDocument
{
{ "input", "$e" },
{ "cond", new BsonDocument
{
{
"$eq", new BsonArray(new BsonValue[] { new BsonString("$$this.da"), BsonNull.Value })
}
} }
};
var filterExpression = new BsonDocument {
{ "$filter", expression }
};
var overwriteExpression = new BsonDocument {
{ "e", filterExpression }
};
var addFieldsStage = new BsonDocument(new BsonElement("$addFields", overwriteExpression));
var obj = await aggregate.AppendStage <Outer>(addFieldsStage).As <Outer>().SingleAsync();
return(obj);
}
private WebApplicationFactory <Startup> GetFactory()
{
if (_factory == null)
{
// run mongo db
_dbRunner = MongoDbRunner.Start();
var projectDir = Directory.GetCurrentDirectory();
var configPath = Path.Combine(projectDir, "appsettings.json");
// amend mongodb connection string
string json = File.ReadAllText(configPath);
dynamic jsonObj = JsonConvert.DeserializeObject(json);
jsonObj["Server"] = _dbRunner.ConnectionString;
jsonObj["S3Url"] = "https://gadb-articles-test.s3-eu-west-1.amazonaws.com";
jsonObj["AWS"]["Bucket"] = "gadb-articles-test";
string output = Newtonsoft.Json.JsonConvert.SerializeObject(jsonObj, Newtonsoft.Json.Formatting.Indented);
File.WriteAllText(configPath, output);
// start up web app context
_factory = new WebApplicationFactory <Startup>().WithWebHostBuilder(
builder =>
{
builder.ConfigureAppConfiguration((context, conf) =>
{
conf.AddJsonFile(configPath);
});
});
}
return(_factory);
}
//Mongo Db local instance
public MongoDbContext()
{
_runner = MongoDbRunner.StartForDebugging();
MongoClient client = new MongoClient(_runner.ConnectionString);
//TODO Change this
MongoServer server = client.GetServer();
MongoDatabase database = server.GetDatabase("Games");
//Get the collection for writing
var collection = database.GetCollection <Game>("GameItems");
//We want to know that it has been written successfully
collection.WithWriteConcern(WriteConcern.Acknowledged);
//Retrieve the game objects from the json
List <Game> games = RetrieveObjectsFromJson();
foreach (Game game in games)
{
try
{
//Attempt to add each object to the mango db
collection.Insert <Game>(game);
}
catch (Exception e)
{
Console.WriteLine("Unable to write to MongoDb, game Id:" + game.id);
}
}
//IQueryable uses lazy loading so it is not actually reading the entire list to memory
//It will only actually load the data when 'tolist' or the query is explicitly executed
_games = collection.AsQueryable <Game>();
}
public DatabaseTestFixture()
{
Db = MongoDbRunner.Start();
var client = new MongoClient(Db.ConnectionString);
database = client.GetDatabase("Testing");
}
public void Dispose()
{
_mongoRunner.Dispose();
_mongoRunner = null;
_client = null;
_context = null;
}
public void Initialize(Action seedData = null)
{
_mongoRunner = MongoDbRunner.Start();
_client = new MongoClient(_mongoRunner.ConnectionString);
_context = _client.GetDatabase("BookstoreDb");
seedData?.Invoke();
}
public HistoryRepositoryTests()
{
RadarTechno.History.History[] histories = new[]
{
new RadarTechno.History.History("author", "entity-technology", "id1", "diff"),
new RadarTechno.History.History("author", "entity-technology", "id1", "diff2"),
new RadarTechno.History.History("author", "entity-technology", "id1", "diff3"),
new RadarTechno.History.History("author", "entity-technology", "id2", "diff")
};
_mongoRunner = MongoDbRunner.Start();
MongoClient client = new MongoClient(_mongoRunner.ConnectionString);
IMongoDatabase database = client.GetDatabase("radar-techno");
var collection = database.GetCollection <RadarTechno.History.History>("history");
collection.InsertMany(histories);
var databaseSettings = new DatabaseSettings()
{
ConnectionString = _mongoRunner.ConnectionString,
Database = "radar-techno"
};
IOptions <DatabaseSettings> options = Options.Create <DatabaseSettings>(databaseSettings);
_database = new RadarDatabase(options);
_repository = new HistoryRepository(_database);
}
public void SetUp()
{
// All these means nothing to upgrade
_runner = MongoDbRunner.Start();
_client = new MongoClient(_runner.ConnectionString);
_database = _client.GetDatabase("intergationtest");
_settings = UpgradeSettings.Default;
}
public MongoUnitTests()
{
_runner = MongoDbRunner.Start(singleNodeReplSet: true, singleNodeReplSetWaitTimeout: 10);
var mongoUrl = new MongoUrl(_runner.ConnectionString);
_client = new MongoClient(mongoUrl);
_client.EnsureReplicationSetReady();
}
public void CreateConnection()
{
_runner = MongoDbRunner.Start(singleNodeReplSet: true, singleNodeReplSetWaitTimeout: 10);
var mongoClient = new MongoClient(_runner.ConnectionString);
_database = mongoClient.GetDatabase("test_db");
}
public InviteServiceTests()
{
DocIT.Core.AutoMapperConfig.RegisterMappings();
_runner = MongoDbRunner.Start();
MongoDB.Driver.MongoClient client = new MongoClient(_runner.ConnectionString);
database = client.GetDatabase("IntegrationTest");
}
public MongoUserStoreTests()
{
runner = MongoDbRunner.Start();
options = Options.Create(new MongoDbSettings()
{
ConnectionString = runner.ConnectionString, Database = Guid.NewGuid().ToString()
});
}
public string Build()
{
Console.WriteLine($"Starting {nameof(Mongo2Go)}...");
_runner = MongoDbRunner.Start();
Console.WriteLine($"Running {nameof(Mongo2Go)} at {_runner.ConnectionString}...");
return(_runner.ConnectionString);
}
