public void GetConnectionString_throws_when_cant_find_named_connection_in_config() { var config = new AppConfig(CreateEmptyConfig()); var info = new DbConnectionInfo("FindMe"); Assert.Equal(Strings.DbConnectionInfo_ConnectionStringNotFound("FindMe"), Assert.Throws<InvalidOperationException>(() => info.GetConnectionString(config)).Message); }
public virtual Type TryLoadFromConfig(AppConfig config) { DebugCheck.NotNull(config); var typeName = config.ConfigurationTypeName; if (string.IsNullOrWhiteSpace(typeName)) { return null; } Type type; try { type = Type.GetType(typeName, throwOnError: true); } catch (Exception ex) { throw new InvalidOperationException(Strings.DbConfigurationTypeNotFound(typeName), ex); } if (!typeof(DbConfiguration).IsAssignableFrom(type)) { throw new InvalidOperationException( Strings.CreateInstance_BadDbConfigurationType(type.ToString(), typeof(DbConfiguration).ToString())); } return type; }
public void Can_find_named_connection_in_config() { var config = new AppConfig(CreateEmptyConfig().AddConnectionString("FindMe", "connection_string", "provider_invariant_name")); var info = new DbConnectionInfo("FindMe"); var connection = info.GetConnectionString(config); Assert.Equal("FindMe", connection.Name); Assert.Equal("connection_string", connection.ConnectionString); Assert.Equal("provider_invariant_name", connection.ProviderName); }
public void Returns_valid_connection_from_string_and_provider() { var config = new AppConfig(CreateEmptyConfig()); var info = new DbConnectionInfo("connection_string", "provider_invariant_name"); var connection = info.GetConnectionString(config); Assert.Null(connection.Name); Assert.Equal("connection_string", connection.ConnectionString); Assert.Equal("provider_invariant_name", connection.ProviderName); }
public AppConfigDependencyResolver( AppConfig appConfig, InternalConfiguration internalConfiguration, ProviderServicesFactory providerServicesFactory = null) { DebugCheck.NotNull(appConfig); _appConfig = appConfig; _internalConfiguration = internalConfiguration; _providerServicesFactory = providerServicesFactory ?? new ProviderServicesFactory(); }
// <summary> // Gets the connection information represented by this instance. // </summary> // <param name="config"> Configuration to use if connection comes from the configuration file. </param> internal ConnectionStringSettings GetConnectionString(AppConfig config) { DebugCheck.NotNull(config); if (_connectionName != null) { var result = config.GetConnectionString(_connectionName); if (result == null) { throw Error.DbConnectionInfo_ConnectionStringNotFound(_connectionName); } return result; } return new ConnectionStringSettings(null, _connectionString, _providerInvariantName); }
/// <summary> /// Gets the connection information represented by this instance. /// </summary> /// <param name = "config">Configuration to use if connection comes from the configuration file.</param> internal ConnectionStringSettings GetConnectionString(AppConfig config) { //Contract.Requires(config != null); if (_connectionName != null) { var result = config.GetConnectionString(_connectionName); if (result == null) { throw Error.DbConnectionInfo_ConnectionStringNotFound(_connectionName); } return result; } return new ConnectionStringSettings(null, _connectionString, _providerInvariantName); }
public virtual InternalConfiguration TryLoadFromConfig(AppConfig config) { DebugCheck.NotNull(config); var typeName = config.ConfigurationTypeName; if (string.IsNullOrWhiteSpace(typeName)) { return null; } Type configType; try { configType = Type.GetType(typeName, throwOnError: true); } catch (Exception ex) { throw new InvalidOperationException(Strings.DbConfigurationTypeNotFound(typeName), ex); } return configType.CreateInstance<DbConfiguration>(Strings.CreateInstance_BadDbConfigurationType).InternalConfiguration; }
public void PopConfiguration_removes_the_first_configuration_associated_with_the_given_AppConfig() { var manager = CreateManager(); var configuration = new Mock<DbConfiguration>().Object; var appConfig1 = AppConfig.DefaultInstance; var appConfig2 = new AppConfig(ConfigurationManager.ConnectionStrings); manager.SetConfiguration(configuration); manager.PushConfiguration(appConfig1, typeof(DbContext)); var pushed1 = manager.GetConfiguration(); manager.PushConfiguration(appConfig2, typeof(DbContext)); manager.PopConfiguration(appConfig2); Assert.Same(pushed1, manager.GetConfiguration()); manager.PopConfiguration(appConfig1); Assert.Same(configuration, manager.GetConfiguration()); }
public void Configurations_can_be_pushed_and_popped_from_multiple_threads_concurrently() { for (var i = 0; i < 30; i++) { var manager = new DbConfigurationManager(new DbConfigurationLoader(), new DbConfigurationFinder()); var config = manager.GetConfiguration(); ExecuteInParallel( () => { var appConfig = new AppConfig(new ConnectionStringSettingsCollection()); manager.PushConfiguration(appConfig, typeof(SimpleModelContext)); manager.PopConfiguration(appConfig); }); Assert.Same(config, manager.GetConfiguration()); } }
public virtual DbConfiguration TryLoadFromConfig(AppConfig config) { // TODO: Implement loading from app.config return null; }
public virtual bool AppConfigContainsDbConfigurationType(AppConfig config) { DebugCheck.NotNull(config); return !string.IsNullOrWhiteSpace(config.ConfigurationTypeName); }
public void GetService_can_be_accessed_from_multiple_threads_concurrently() { var appConfig = new AppConfig( CreateEmptyConfig().AddDefaultConnectionFactory(typeof(FakeConnectionFactory).AssemblyQualifiedName)); for (var i = 0; i < 30; i++) { var bag = new ConcurrentBag<IDbConnectionFactory>(); var resolver = new AppConfigDependencyResolver(appConfig); ExecuteInParallel(() => bag.Add(resolver.GetService<IDbConnectionFactory>())); Assert.Equal(20, bag.Count); Assert.True(bag.All(c => resolver.GetService<IDbConnectionFactory>() == c)); } }
public virtual void PopConfiguration(AppConfig config) { DebugCheck.NotNull(config); lock (_lock) { var configuration = _configurationOverrides.Value.FirstOrDefault(c => c.Item1 == config); if (configuration != null) { _configurationOverrides.Value.Remove(configuration); } } }
public void PopConfiguration_removes_the_first_configuration_associated_with_the_given_AppConfig() { var manager = CreateManager(); var mockInternalConfiguration = new Mock<InternalConfiguration>(null, null, null, null) { CallBase = true }; var mockDbConfiguration = new Mock<DbConfiguration>(); mockDbConfiguration.Setup(m => m.InternalConfiguration).Returns(mockInternalConfiguration.Object); mockInternalConfiguration.Setup(m => m.Owner).Returns(mockDbConfiguration.Object); var appConfig1 = AppConfig.DefaultInstance; var appConfig2 = new AppConfig(ConfigurationManager.ConnectionStrings); manager.SetConfiguration(mockInternalConfiguration.Object); manager.PushConfiguration(appConfig1, typeof(DbContext)); var pushed1 = manager.GetConfiguration(); manager.PushConfiguration(appConfig2, typeof(DbContext)); manager.PopConfiguration(appConfig2); Assert.Same(pushed1, manager.GetConfiguration()); manager.PopConfiguration(appConfig1); Assert.Same(mockInternalConfiguration.Object, manager.GetConfiguration()); }
public void PushConfugiration_switches_in_original_root_resolver() { var appConfig = new AppConfig(new ConnectionStringSettingsCollection()); var mockLoader = new Mock<DbConfigurationLoader>(); mockLoader.Setup(m => m.TryLoadFromConfig(appConfig)).Returns(typeof(DbConfigurationWithMockInternals)); mockLoader.Setup(m => m.AppConfigContainsDbConfigurationType(It.IsAny<AppConfig>())).Returns(true); var manager = CreateManager(mockLoader); var defaultConfiguration = manager.GetConfiguration(); manager.PushConfiguration(appConfig, typeof(DbContext)); Mock.Get(manager.GetConfiguration()).Verify(m => m.SwitchInRootResolver(defaultConfiguration.RootResolver)); }
public void AppConfigResolver_is_added_to_pushed_configuration() { var appConfig = new AppConfig(new ConnectionStringSettingsCollection()); var mockLoader = new Mock<DbConfigurationLoader>(); mockLoader.Setup(m => m.TryLoadFromConfig(appConfig)).Returns(typeof(DbConfigurationWithMockInternals)); mockLoader.Setup(m => m.AppConfigContainsDbConfigurationType(It.IsAny<AppConfig>())).Returns(true); var manager = CreateManager(mockLoader); manager.PushConfiguration(appConfig, typeof(DbContext)); Mock.Get(manager.GetConfiguration()).Verify(m => m.AddAppConfigResolver(It.IsAny<AppConfigDependencyResolver>())); }
public void PushConfugiration_pushes_default_configuration_if_no_other_found() { var mockLoader = new Mock<DbConfigurationLoader>(); var mockFinder = new Mock<DbConfigurationFinder>(); var manager = CreateManager(mockLoader, mockFinder); var defaultConfiguration = manager.GetConfiguration(); var appConfig = new AppConfig(new ConnectionStringSettingsCollection()); manager.PushConfiguration(appConfig, typeof(DbContext)); Assert.NotSame(defaultConfiguration, manager.GetConfiguration()); mockLoader.Verify(m => m.TryLoadFromConfig(appConfig)); mockFinder.Verify(m => m.TryFindConfigurationType(typeof(DbContext), It.IsAny<IEnumerable<Type>>())); }
public void PushConfugiration_pushes_and_locks_configuration_discovered_in_context_assembly_if_found() { var mockLoader = new Mock<DbConfigurationLoader>(); var mockFinder = new Mock<DbConfigurationFinder>(); mockFinder.Setup(m => m.TryFindConfigurationType(typeof(DbContext), It.IsAny<IEnumerable<Type>>())).Returns( typeof(FakeConfiguration)); var manager = CreateManager(mockLoader, mockFinder); var appConfig = new AppConfig(new ConnectionStringSettingsCollection()); manager.PushConfiguration(appConfig, typeof(DbContext)); Assert.IsType<FakeConfiguration>(manager.GetConfiguration().Owner); AssertIsLocked(manager.GetConfiguration()); mockLoader.Verify(m => m.TryLoadFromConfig(appConfig)); mockFinder.Verify(m => m.TryFindConfigurationType(typeof(DbContext), It.IsAny<IEnumerable<Type>>())); }
public virtual void PushConfiguration(AppConfig config, Type contextType) { Contract.Requires(config != null); Contract.Requires(contextType != null); Contract.Requires(typeof(DbContext).IsAssignableFrom(contextType)); var configuration = _loader.TryLoadFromConfig(config) ?? _finder.TryCreateConfiguration(contextType.Assembly.GetAccessibleTypes()) ?? new DbConfiguration(); configuration.AddAppConfigResolver(new AppConfigDependencyResolver(config)); configuration.Lock(); _configurationOverrides.Add(Tuple.Create(config, configuration)); }
public virtual void PopConfiguration(AppConfig config) { Contract.Requires(config != null); var configuration = _configurationOverrides.FirstOrDefault(c => c.Item1 == config); if (configuration != null) { _configurationOverrides.Remove(configuration); } }
public virtual bool PushConfiguration(AppConfig config, Type contextType) { DebugCheck.NotNull(config); DebugCheck.NotNull(contextType); Debug.Assert(typeof(DbContext).IsAssignableFrom(contextType)); // Perf optimization: if there is no change to the default app-domain config and if the // context assembly has already been checked for configurations, then avoid creating // and pushing a new configuration since it would be the same as the current one anyway. if (config == AppConfig.DefaultInstance && (contextType == typeof(DbContext) || _knownAssemblies.ContainsKey(contextType.Assembly))) { return false; } var configuration = (_loader.TryLoadFromConfig(config) ?? _finder.TryFindConfigurationType(contextType) ?? typeof(DbConfiguration)) .CreateInstance<DbConfiguration>(Strings.CreateInstance_BadDbConfigurationType) .InternalConfiguration; configuration.SwitchInRootResolver(_configuration.Value.RootResolver); configuration.AddAppConfigResolver(new AppConfigDependencyResolver(config, configuration)); lock (_lock) { _configurationOverrides.Value.Add(Tuple.Create(config, configuration)); } configuration.Lock(); return true; }
public AppConfigDependencyResolver(AppConfig appConfig) { //Contract.Requires(appConfig != null); _appConfig = appConfig; }
private bool TryInitializeFromAppConfig(string name, AppConfig config) { DebugCheck.NotNull(config); var appConfigConnection = FindConnectionInConfig(name, config); if (appConfigConnection != null) { InitializeFromConnectionStringSetting(appConfigConnection); _connectionStringOrigin = DbConnectionStringOrigin.Configuration; _connectionStringName = appConfigConnection.Name; return true; } return false; }
private DbContextInfo( Type contextType, DbProviderInfo modelProviderInfo, AppConfig config, DbConnectionInfo connectionInfo, Func<IDbDependencyResolver> resolver = null) { if (!typeof(DbContext).IsAssignableFrom(contextType)) { throw new ArgumentOutOfRangeException("contextType"); } _resolver = resolver ?? (() => DbConfiguration.DependencyResolver); _contextType = contextType; _modelProviderInfo = modelProviderInfo; _appConfig = config; _connectionInfo = connectionInfo; _activator = CreateActivator(); if (_activator != null) { var context = CreateInstance(); if (context != null) { _isConstructible = true; using (context) { _connectionString = DbInterception.Dispatch.Connection.GetConnectionString( context.InternalContext.Connection, new DbInterceptionContext().WithDbContext(context)); _connectionStringName = context.InternalContext.ConnectionStringName; _connectionProviderName = context.InternalContext.ProviderName; _connectionStringOrigin = context.InternalContext.ConnectionStringOrigin; } } } }
// <summary> // Called internally when a context info is needed for an existing context, which may not be constructable. // </summary> // <param name="context"> The context instance to get info from. </param> internal DbContextInfo(DbContext context, Func<IDbDependencyResolver> resolver = null) { Check.NotNull(context, "context"); _resolver = resolver ?? (() => DbConfiguration.DependencyResolver); _contextType = context.GetType(); _appConfig = AppConfig.DefaultInstance; var internalContext = context.InternalContext; _connectionProviderName = internalContext.ProviderName; _connectionInfo = new DbConnectionInfo(internalContext.OriginalConnectionString, _connectionProviderName); _connectionString = internalContext.OriginalConnectionString; _connectionStringName = internalContext.ConnectionStringName; _connectionStringOrigin = internalContext.ConnectionStringOrigin; }
private DbContextInfo( Type contextType, DbProviderInfo modelProviderInfo, AppConfig config, DbConnectionInfo connectionInfo) { if (!typeof(DbContext).IsAssignableFrom(contextType)) { throw new ArgumentOutOfRangeException("contextType"); } _contextType = contextType; _modelProviderInfo = modelProviderInfo; _appConfig = config; _connectionInfo = connectionInfo; _activator = CreateActivator(); if (_activator != null) { var context = _activator(); if (context != null) { _isConstructible = true; PushConfiguration(context); using (context) { ConfigureContext(context); _connectionString = context.InternalContext.Connection.ConnectionString; _connectionStringName = context.InternalContext.ConnectionStringName; _connectionProviderName = context.InternalContext.ProviderName; _connectionStringOrigin = context.InternalContext.ConnectionStringOrigin; } } } }
public virtual bool AppConfigContainsDbConfigurationType(AppConfig config) { Contract.Requires(config != null); return !string.IsNullOrWhiteSpace(config.ConfigurationTypeName); }
/// <summary> /// Attempts to locate a connection entry in the configuration based on the supplied context name. /// </summary> /// <param name="name"> The name to search for. </param> /// <param name="config"> The configuration to search in. </param> /// <returns> Connection string if found, otherwise null. </returns> private static ConnectionStringSettings FindConnectionInConfig(string name, AppConfig config) { // Build a list of candidate names that might be found in the app.config/web.config file. // The first entry is the full name. var candidates = new List<string> { name }; // Second entry is full name with namespace stripped out. var lastDot = name.LastIndexOf('.'); if (lastDot >= 0 && lastDot + 1 < name.Length) { candidates.Add(name.Substring(lastDot + 1)); } // Now go through each candidate. As soon as we find one that matches, stop. var appConfigConnection = (from c in candidates where config.GetConnectionString(c) != null select config.GetConnectionString(c)).FirstOrDefault(); return appConfigConnection; }
/// <summary> /// Called internally when a context info is needed for an existing context, which may not be constructable. /// </summary> /// <param name="context"> The context instance to get info from. </param> internal DbContextInfo(DbContext context) { Check.NotNull(context, "context"); _contextType = context.GetType(); _appConfig = AppConfig.DefaultInstance; var internalContext = context.InternalContext; _connectionProviderName = internalContext.ProviderName; _connectionInfo = new DbConnectionInfo(internalContext.OriginalConnectionString, _connectionProviderName); _connectionString = internalContext.OriginalConnectionString; _connectionStringName = internalContext.ConnectionStringName; _connectionStringOrigin = internalContext.ConnectionStringOrigin; }