public MyContextConfiguration()
{
MyDbModelStore cachedDbModelStore = new MyDbModelStore(DbModelStorePath);
IDbDependencyResolver dependencyResolver = new SingletonDependencyResolver <DbModelStore>(cachedDbModelStore);
AddDependencyResolver(dependencyResolver);
}
public void CreateModel_uses_DbCompiledModel_from_ModelStore_when_available()
{
var store = new Mock <DbModelStore>();
var dbCompiledModelInStore = new DbCompiledModel();
store.Setup(c => c.TryLoad(It.IsAny <Type>())).Returns(dbCompiledModelInStore);
store.Setup(c => c.Save(It.IsAny <Type>(), It.IsAny <DbModel>()));
try
{
var dependencyResolver = new SingletonDependencyResolver <DbModelStore>(store.Object);
MutableResolver.AddResolver <DbModelStore>(dependencyResolver);
var mockContext = new Mock <LazyInternalContext>(
new Mock <DbContext>().Object, new Mock <IInternalConnection>().Object, null, null, null, null, null)
{
CallBase = true
};
var model = LazyInternalContext.CreateModel(mockContext.Object);
Assert.Same(dbCompiledModelInStore, model);
store.Verify(c => c.TryLoad(It.IsAny <Type>()), Times.Once(),
"should load existing model");
store.Verify(c => c.Save(It.IsAny <Type>(), It.IsAny <DbModel>()), Times.Never(),
"should not call Save when loading model from store");
}
finally //clean up
{
MutableResolver.ClearResolvers();
}
}
public void CreateModel_does_not_use_ModelStore_for_HistoryContext()
{
var store = new Mock<DbModelStore>();
var dbCompiledModelInStore = new DbCompiledModel();
store.Setup(c => c.TryLoad(It.IsAny<Type>())).Returns(dbCompiledModelInStore);
store.Setup(c => c.Save(It.IsAny<Type>(), It.IsAny<DbModel>()));
try
{
var dependencyResolver = new SingletonDependencyResolver<DbModelStore>(store.Object);
MutableResolver.AddResolver<DbModelStore>(dependencyResolver);
var mockContext = new Mock<LazyInternalContext>(
new MockHistoryContext(), new Mock<IInternalConnection>().Object, null, null, null, null, null)
{
CallBase = true
};
mockContext.Object.ModelProviderInfo = ProviderRegistry.Sql2008_ProviderInfo;
var model = LazyInternalContext.CreateModel(mockContext.Object);
Assert.NotSame(dbCompiledModelInStore, model);
store.Verify(c => c.TryLoad(It.IsAny<Type>()), Times.Never(),
"should not call store for HistoryContext");
store.Verify(c => c.Save(It.IsAny<Type>(), It.IsAny<DbModel>()), Times.Never(),
"should not call store for HistoryContext");
}
finally //clean up
{
MutableResolver.ClearResolvers();
}
}
public void CreateModel_saves_DbCompiledModel_into_ModelStore_when_not_yet_stored()
{
var store = new Mock <DbModelStore>();
store.Setup(c => c.TryLoad(It.IsAny <Type>())).Returns((DbCompiledModel)null); //no file exists yet
store.Setup(c => c.Save(It.IsAny <Type>(), It.IsAny <DbModel>()));
try
{
var dependencyResolver = new SingletonDependencyResolver <DbModelStore>(store.Object);
MutableResolver.AddResolver <DbModelStore>(dependencyResolver);
var mockContext = new Mock <LazyInternalContext>(
new Mock <DbContext>().Object, new Mock <IInternalConnection>().Object, null, null, null, null, null)
{
CallBase = true
};
mockContext.Object.ModelProviderInfo = ProviderRegistry.Sql2008_ProviderInfo;
var model = LazyInternalContext.CreateModel(mockContext.Object);
Assert.NotNull(model);
store.Verify(c => c.TryLoad(It.IsAny <Type>()), Times.Once(),
"should try to load existing model");
store.Verify(c => c.Save(It.IsAny <Type>(), It.IsAny <DbModel>()), Times.Once(),
"should Save after creating model when store did not contain exist yet");
}
finally //clean up
{
MutableResolver.ClearResolvers();
}
}
public void CreateModel_uses_DbCompiledModel_from_ModelStore_when_available()
{
var store = new Mock<DbModelStore>();
var dbCompiledModelInStore = new DbCompiledModel();
store.Setup(c => c.TryLoad(It.IsAny<Type>())).Returns(dbCompiledModelInStore);
store.Setup(c => c.Save(It.IsAny<Type>(), It.IsAny<DbModel>()));
try
{
var dependencyResolver = new SingletonDependencyResolver<DbModelStore>(store.Object);
MutableResolver.AddResolver<DbModelStore>(dependencyResolver);
var mockContext = new Mock<LazyInternalContext>(
new Mock<DbContext>().Object, new Mock<IInternalConnection>().Object, null, null, null, null, null)
{
CallBase = true
};
var model = LazyInternalContext.CreateModel(mockContext.Object);
Assert.Same(dbCompiledModelInStore, model);
store.Verify(c => c.TryLoad(It.IsAny<Type>()), Times.Once(),
"should load existing model");
store.Verify(c => c.Save(It.IsAny<Type>(), It.IsAny<DbModel>()), Times.Never(),
"should not call Save when loading model from store");
}
finally //clean up
{
MutableResolver.ClearResolvers();
}
}
public CustomDbConfiguration()
{
string path = Path.GetDirectoryName(this.GetType().Assembly.Location);
CustomDbModelStore cachedDbModelStore = new CustomDbModelStore(path);
IDbDependencyResolver dependencyResolver = new SingletonDependencyResolver <DbModelStore>(cachedDbModelStore);
AddDependencyResolver(dependencyResolver);
this.AddInterceptor(new EFCommandInterceptor(DatabaseName, DefaultDatabaseName));
}
public void GetService_returns_instance_of_contract_interface_only_when_key_predicate_matches()
{
var instance = new Mock<IPilkington>().Object;
var resolver = new SingletonDependencyResolver<IPilkington>(instance, k => k != null && ((string)k).StartsWith("K"));
Assert.Same(instance, resolver.GetService<IPilkington>("Karl"));
Assert.Null(resolver.GetService<IPilkington>("Ricky"));
Assert.Null(resolver.GetService<IPilkington>());
Assert.Null(resolver.GetService<IGervais>("Ricky"));
}
public SQLiteConfiguration()
{
SetProviderFactory("System.Data.SQLite", SQLiteFactory.Instance);
SetProviderFactory("System.Data.SQLite.EF6", SQLiteProviderFactory.Instance);
var service = SQLiteProviderFactory.Instance.GetService(typeof(DbProviderServices));
SetProviderServices("System.Data.SQLite", service as DbProviderServices);
Directory.CreateDirectory(ModelCachePath);
var cachedModelStore = new SQLiteModelStore(ModelCachePath);
var depResolver = new SingletonDependencyResolver <DbModelStore>(cachedModelStore);
AddDependencyResolver(depResolver);
}
public void DefaultDbModelStore_saves_and_loads_DbContext_with_DbFunction_StoreModelConvention()
{
try
{
var dependencyResolver = new SingletonDependencyResolver <DbModelStore>(_store);
MutableResolver.AddResolver <DbModelStore>(dependencyResolver);
Assert.False(File.Exists(_location + typeof(ScalarFunctionDbContext).FullName + ".edmx"), "edmx should not exist yet");
using (var context = new ScalarFunctionDbContext())
{
context.Models.Add(new Model {
Id = 1
});
context.SaveChanges();
Assert.True(
context.Set <Model>().Any(model => ScalarFunction.GetSomething("inValue") == "inValue"),
"Value passed in should be returned from db function without error");
}
Assert.True(
File.Exists(_location + typeof(ScalarFunctionDbContext).FullName + ".edmx"), "edmx should be written to _location");
var xdocFromStore = _store.TryGetEdmx(typeof(ScalarFunctionDbContext));
Assert.NotNull(xdocFromStore);
var compiledModelFromCache = _store.TryLoad(typeof(ScalarFunctionDbContext));
Assert.NotNull(compiledModelFromCache);
using (var context = new ScalarFunctionDbContext(compiledModelFromCache))
{
Assert.True(
context.Set <Model>().Any(prd => ScalarFunction.GetSomething("inValue") == "inValue"),
"Value passed in should be returned from db function without error");
}
}
finally //clean up
{
MutableResolver.ClearResolvers();
if (File.Exists(_location + typeof(ScalarFunctionDbContext).FullName + ".edmx"))
{
File.Delete(_location + typeof(ScalarFunctionDbContext).FullName + ".edmx");
}
}
}
public void EDMX_can_be_read_from_DbModelStore_after_context_is_initialized()
{
var location = Path.GetTempPath();
try
{
var store = new DefaultDbModelStore(location);
var dependencyResolver = new SingletonDependencyResolver <DbModelStore>(store);
MutableResolver.AddResolver <DbModelStore>(dependencyResolver);
EDMX_can_be_written(initializeContext: true);
}
finally //clean up
{
MutableResolver.ClearResolvers();
if (File.Exists(location + typeof(SimpleModelContext).FullName + ".edmx"))
{
File.Delete(location + typeof(SimpleModelContext).FullName + ".edmx");
}
}
}
public void CreateModel_does_not_use_ModelStore_for_HistoryContext()
{
var store = new Mock <DbModelStore>();
var dbCompiledModelInStore = new DbCompiledModel();
store.Setup(c => c.TryLoad(It.IsAny <Type>())).Returns(dbCompiledModelInStore);
store.Setup(c => c.Save(It.IsAny <Type>(), It.IsAny <DbModel>()));
try
{
var dependencyResolver = new SingletonDependencyResolver <DbModelStore>(store.Object);
MutableResolver.AddResolver <DbModelStore>(dependencyResolver);
var mockContext = new Mock <LazyInternalContext>(
new MockHistoryContext(), new Mock <IInternalConnection>().Object, null, null, null, null, null)
{
CallBase = true
};
mockContext.Object.ModelProviderInfo = ProviderRegistry.Sql2008_ProviderInfo;
var model = LazyInternalContext.CreateModel(mockContext.Object);
Assert.NotSame(dbCompiledModelInStore, model);
store.Verify(c => c.TryLoad(It.IsAny <Type>()), Times.Never(),
"should not call store for HistoryContext");
store.Verify(c => c.Save(It.IsAny <Type>(), It.IsAny <DbModel>()), Times.Never(),
"should not call store for HistoryContext");
}
finally //clean up
{
MutableResolver.ClearResolvers();
}
}
public void DefaultDbModelStore_saves_and_loads_DbContext_with_DropCreateAlwaysInitializer()
{
try
{
var dependencyResolver = new SingletonDependencyResolver <DbModelStore>(_store);
MutableResolver.AddResolver <DbModelStore>(dependencyResolver);
Assert.False(File.Exists(_location + typeof(ModelContext).FullName + ".edmx"), "edmx should not exist yet");
using (var context = new ModelContext())
{
context.Database.Initialize(true);
}
Assert.True(File.Exists(_location + typeof(ModelContext).FullName + ".edmx"), "edmx should have been written to _location");
var xdocFromStore = _store.TryGetEdmx(typeof(ModelContext));
Assert.NotNull(xdocFromStore);
var compiledModelFromCache = _store.TryLoad(typeof(ModelContext));
Assert.NotNull(compiledModelFromCache);
using (var context = new ModelContext(compiledModelFromCache))
{
Assert.False(context.Models.Any(prd => true), "should access without error");
}
}
finally //clean up
{
MutableResolver.ClearResolvers();
if (File.Exists(_location + typeof(ModelContext).FullName + ".edmx"))
{
File.Delete(_location + typeof(ModelContext).FullName + ".edmx");
}
}
}
public void GetService_can_be_accessed_from_multiple_threads_concurrently()
{
for (var i = 0; i < 30; i++)
{
var bag = new ConcurrentBag<IPilkington>();
var karl = new Mock<IPilkington>().Object;
var resolver = new SingletonDependencyResolver<IPilkington>(karl, "Karl");
ExecuteInParallel(() => bag.Add(resolver.GetService<IPilkington>("Karl")));
Assert.Equal(20, bag.Count);
Assert.True(bag.All(c => karl == c));
}
}
public void CreateModel_saves_DbCompiledModel_into_ModelStore_when_not_yet_stored()
{
var store = new Mock<DbModelStore>();
store.Setup(c => c.TryLoad(It.IsAny<Type>())).Returns((DbCompiledModel)null); //no file exists yet
store.Setup(c => c.Save(It.IsAny<Type>(), It.IsAny<DbModel>()));
try
{
var dependencyResolver = new SingletonDependencyResolver<DbModelStore>(store.Object);
MutableResolver.AddResolver<DbModelStore>(dependencyResolver);
var mockContext = new Mock<LazyInternalContext>(
new Mock<DbContext>().Object, new Mock<IInternalConnection>().Object, null, null, null, null, null)
{
CallBase = true
};
mockContext.Object.ModelProviderInfo = ProviderRegistry.Sql2008_ProviderInfo;
var model = LazyInternalContext.CreateModel(mockContext.Object);
Assert.NotNull(model);
store.Verify(c => c.TryLoad(It.IsAny<Type>()), Times.Once(),
"should try to load existing model");
store.Verify(c => c.Save(It.IsAny<Type>(), It.IsAny<DbModel>()), Times.Once(),
"should Save after creating model when store did not contain exist yet");
}
finally //clean up
{
MutableResolver.ClearResolvers();
}
}
