public void ReadAndWriteRootEntity()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var dbSet = new MongoDbSet <RootKnownBaseModel>(context);
var rootEntity = new RootKnownBaseModel
{
Description = "ReadAndWriteRootEntity-RootKnownBaseModel"
};
dbSet.Add(rootEntity);
var childEntity = new UnknownChildToRootModel
{
Description = "ReadAndWriteRootEntity-UnknownChildToRootModel"
};
dbSet.Add(childEntity);
context.SaveChanges();
ResetMongoDb();
dbSet = new MongoDbSet <RootKnownBaseModel>(context);
var dbRootEntity = dbSet.Where(e => e.Id == rootEntity.Id).FirstOrDefault();
Assert.IsNotNull(dbRootEntity);
Assert.IsInstanceOfType(dbRootEntity, typeof(RootKnownBaseModel));
var dbChildEntity = dbSet.Where(e => e.Id == childEntity.Id).FirstOrDefault();
Assert.IsNotNull(dbChildEntity);
Assert.IsInstanceOfType(dbChildEntity, typeof(UnknownChildToRootModel));
}
public void ExtraElementsSerializationIntegrationTest()
{
EntityMapping.AddMappingProcessor(new CollectionNameProcessor());
EntityMapping.AddMappingProcessor(new ExtraElementsProcessor());
EntityMapping.RegisterType(typeof(ExtraElementsAttrModel));
EntityMapping.RegisterType(typeof(ModelWithExtraElements));
var connection = TestConfiguration.GetConnection();
var modelWithExtraPropertiesDbSet = new MongoDbSet <ModelWithExtraElements>();
modelWithExtraPropertiesDbSet.SetConnection(connection);
var entity = new ModelWithExtraElements
{
PropertyOne = "ModelWithExtraElements",
PropertyTwo = 123
};
modelWithExtraPropertiesDbSet.Add(entity);
modelWithExtraPropertiesDbSet.SaveChanges();
var extraElementsAttrModelDbSet = new MongoDbSet <ExtraElementsAttrModel>();
extraElementsAttrModelDbSet.SetConnection(connection);
var dbEntity = extraElementsAttrModelDbSet.Where(e => e.Id == entity.Id).FirstOrDefault();
Assert.AreEqual("ModelWithExtraElements", dbEntity.AdditionalElements[nameof(ModelWithExtraElements.PropertyOne)]);
Assert.AreEqual(123, dbEntity.AdditionalElements[nameof(ModelWithExtraElements.PropertyTwo)]);
}
public void SuccessfullyAttachUntrackedEntity()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var dbSet = new MongoDbSet <DbSetModel>(context);
var model = new DbSetModel
{
Id = "abcd"
};
dbSet.Add(model);
context.SaveChanges();
ResetMongoDb();
context = new MongoDbContext(connection);
dbSet = new MongoDbSet <DbSetModel>(context);
var result = dbSet.AsNoTracking().FirstOrDefault();
context.Attach(result);
Assert.AreEqual(MongoFramework.Infrastructure.EntityEntryState.NoChanges, context.ChangeTracker.GetEntry(result).State);
}
public async Task SuccessfullyLinqFindNoTrackingAsync()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var dbSet = new MongoDbSet <TestModel>(context);
var model = new TestModel
{
Id = "abcd",
Description = "SuccessfullyFindTracked.1"
};
dbSet.Add(model);
context.SaveChanges();
ResetMongoDb();
context = new MongoDbContext(connection);
dbSet = new MongoDbSet <TestModel>(context);
var result = await dbSet.AsNoTracking().FirstOrDefaultAsync();
Assert.IsNull(context.ChangeTracker.GetEntry(result));
}
public async Task SuccessfullyLinqFindTrackedAsync()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var dbSet = new MongoDbSet <TestModel>(context);
var model = new TestModel
{
Id = "abcd",
Description = "SuccessfullyFindTracked.1"
};
dbSet.Add(model);
context.SaveChanges();
ResetMongoDb();
var result = await dbSet.FirstOrDefaultAsync();
result.Description = "changed";
context.ChangeTracker.DetectChanges();
Assert.AreEqual(MongoFramework.Infrastructure.EntityEntryState.Updated, context.ChangeTracker.GetEntry(result).State);
}
public void ValidationExceptionOnInvalidModel()
{
var dbSet = new MongoDbSet <MongoDbSetValidationModel>();
dbSet.SetConnection(TestConfiguration.GetConnection());
dbSet.Add(new MongoDbSetValidationModel());
dbSet.SaveChanges();
}
public void SearchGeoNearRecordLimits()
{
var connection = TestConfiguration.GetConnection();
var dbSet = new MongoDbSet <SearchGeoModel>();
dbSet.SetConnection(connection);
for (var i = 0; i < 100; i++)
{
dbSet.Add(new SearchGeoModel
{
Description = $"Adelaide ({i})",
PrimaryCoordinates = new GeoJsonPoint <GeoJson2DGeographicCoordinates>(
new GeoJson2DGeographicCoordinates(138.600739, -34.928497)
)
});
}
dbSet.AddRange(new SearchGeoModel[]
{
new SearchGeoModel {
Description = "New York", PrimaryCoordinates = new GeoJsonPoint <GeoJson2DGeographicCoordinates>(
new GeoJson2DGeographicCoordinates(-74.005974, 40.712776)
)
},
new SearchGeoModel {
Description = "Perth", PrimaryCoordinates = new GeoJsonPoint <GeoJson2DGeographicCoordinates>(
new GeoJson2DGeographicCoordinates(115.860458, -31.950527)
)
},
new SearchGeoModel {
Description = "Hobart", PrimaryCoordinates = new GeoJsonPoint <GeoJson2DGeographicCoordinates>(
new GeoJson2DGeographicCoordinates(147.327194, -42.882137)
)
}
});
dbSet.SaveChanges();
IQueryable <SearchGeoModel> WithGeoQuery()
{
return(dbSet.SearchGeoNear(e => e.PrimaryCoordinates, new GeoJsonPoint <GeoJson2DGeographicCoordinates>(
new GeoJson2DGeographicCoordinates(138, -30)
)));
}
Assert.AreEqual(103, WithGeoQuery().Count());
Assert.AreEqual(3, WithGeoQuery().Skip(100).Count());
var afterSkipResult = WithGeoQuery().Skip(100).FirstOrDefault();
Assert.AreEqual("Hobart", afterSkipResult.Description);
var afterTakeResult = WithGeoQuery().Take(3).ToArray();
Assert.AreEqual(3, afterTakeResult.Length);
Assert.AreEqual("Adelaide (0)", afterTakeResult[0].Description);
}
public void ValidationExceptionOnInvalidModel()
{
var database = TestConfiguration.GetDatabase();
var dbSet = new MongoDbSet <MongoDbSetValidationModel>();
dbSet.SetDatabase(database);
dbSet.Add(new MongoDbSetValidationModel());
dbSet.SaveChanges();
}
public void ReadAndWriteRootEntity()
{
var database = TestConfiguration.GetDatabase();
var dbSet = new MongoDbSet <RootKnownBaseModel>();
dbSet.SetDatabase(database);
var rootEntity = new RootKnownBaseModel
{
Description = "ReadAndWriteRootEntity-RootKnownBaseModel"
};
dbSet.Add(rootEntity);
var childEntity = new UnknownChildToRootModel
{
Description = "ReadAndWriteRootEntity-UnknownChildToRootModel"
};
dbSet.Add(childEntity);
dbSet.SaveChanges();
ResetMongoDbDriver();
dbSet = new MongoDbSet <RootKnownBaseModel>();
dbSet.SetDatabase(database);
var dbRootEntity = dbSet.Where(e => e.Id == rootEntity.Id).FirstOrDefault();
Assert.IsNotNull(dbRootEntity);
Assert.AreEqual(typeof(RootKnownBaseModel), dbRootEntity.GetType());
var dbChildEntity = dbSet.Where(e => e.Id == childEntity.Id).FirstOrDefault();
Assert.IsNotNull(dbChildEntity);
Assert.AreEqual(typeof(UnknownChildToRootModel), dbChildEntity.GetType());
}
public void SuccessfulInsertAndQueryBack()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var dbSet = new MongoDbSet <TestModel>(context);
dbSet.Add(new TestModel
{
Description = "ValueSync"
});
Assert.IsFalse(dbSet.Any(m => m.Description == "ValueSync"));
context.SaveChanges();
Assert.IsTrue(dbSet.Any(m => m.Description == "ValueSync"));
}
public void SuccessfulInsertAndQueryBack()
{
var dbSet = new MongoDbSet <MongoDbSetValidationModel>();
dbSet.SetConnection(TestConfiguration.GetConnection());
dbSet.Add(new MongoDbSetValidationModel
{
RequiredField = "ValueSync"
});
Assert.IsFalse(dbSet.Any(m => m.RequiredField == "ValueSync"));
dbSet.SaveChanges();
Assert.IsTrue(dbSet.Any(m => m.RequiredField == "ValueSync"));
}
public async Task SuccessfulInsertAndQueryBackAsync()
{
var dbSet = new MongoDbSet <MongoDbSetValidationModel>();
dbSet.SetConnection(TestConfiguration.GetConnection());
dbSet.Add(new MongoDbSetValidationModel
{
RequiredField = "ValueAsync"
});
Assert.IsFalse(dbSet.Any(m => m.RequiredField == "ValueAsync"));
await dbSet.SaveChangesAsync().ConfigureAwait(false);
Assert.IsTrue(dbSet.Any(m => m.RequiredField == "ValueAsync"));
}
public void SuccessfulNullFind()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var dbSet = new MongoDbSet <TestModel>(context);
var model = new TestModel
{
Description = "SuccessfulNullFind"
};
dbSet.Add(model);
context.SaveChanges();
Assert.IsNull(dbSet.Find("abcd"));
}
public async Task SuccessfullyFindAsyncTracked()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var dbSet = new MongoDbSet <TestModel>(context);
var model = new TestModel
{
Id = "abcd",
Description = "SuccessfullyFindTracked"
};
dbSet.Add(model);
//Note: not saving, but still should be found as tracked
Assert.AreEqual("SuccessfullyFindTracked", (await dbSet.FindAsync(model.Id)).Description);
Assert.AreEqual(MongoFramework.Infrastructure.EntityEntryState.Added, context.ChangeTracker.GetEntry(model).State);
}
public void SaveWithNullNavigationProperty()
{
var connection = TestConfiguration.GetConnection();
var dbSet = new MongoDbSet <CollectionIntegrationModel>();
dbSet.SetConnection(connection);
var entity = new CollectionIntegrationModel
{
Description = "SaveWithNullNavigationProperty"
};
dbSet.Add(entity);
dbSet.SaveChanges();
var dbEntity = dbSet.Where(e => e.Id == entity.Id).FirstOrDefault();
Assert.AreEqual(0, dbEntity.StringModelEntities.Count);
}
public void SuccessfulInsertAndFind()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var dbSet = new MongoDbSet <TestModel>(context);
var model = new TestModel
{
Description = "SuccessfulInsertAndFind"
};
dbSet.Add(model);
context.SaveChanges();
context = new MongoDbContext(connection);
dbSet = new MongoDbSet <TestModel>(context);
Assert.AreEqual("SuccessfulInsertAndFind", dbSet.Find(model.Id).Description);
Assert.AreEqual(MongoFramework.Infrastructure.EntityEntryState.NoChanges, context.ChangeTracker.GetEntry(model).State);
}
public void SuccessfullyRemoveEntityById()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var dbSet = new MongoDbSet <TestModel>(context);
var entity = new TestModel
{
Description = "SuccessfullyRemoveEntityById"
};
dbSet.Add(entity);
context.SaveChanges();
dbSet = new MongoDbSet <TestModel>(context);
dbSet.RemoveById(entity.Id);
Assert.IsTrue(dbSet.Any(m => m.Description == "SuccessfullyRemoveEntityById"));
context.SaveChanges();
Assert.IsFalse(dbSet.Any(m => m.Description == "SuccessfullyRemoveEntityById"));
}
public void SuccessfullyRemoveEntityById()
{
var dbSet = new MongoDbSet <MongoDbSetValidationModel>();
dbSet.SetConnection(TestConfiguration.GetConnection());
var entity = new MongoDbSetValidationModel
{
RequiredField = "SuccessfullyRemoveEntityById"
};
dbSet.Add(entity);
dbSet.SaveChanges();
dbSet.SetConnection(TestConfiguration.GetConnection());
dbSet.RemoveById(entity.Id);
Assert.IsTrue(dbSet.Any(m => m.RequiredField == "SuccessfullyRemoveEntityById"));
dbSet.SaveChanges();
Assert.IsFalse(dbSet.Any(m => m.RequiredField == "SuccessfullyRemoveEntityById"));
}