public void SetUp()
{
hashProviders = new Dictionary <string, IHashProvider>();
symmetricCrytoProviders = new Dictionary <string, ISymmetricCryptoProvider>();
CreateKeyFile(symmetricKeyFile);
CreateKeyFile(keyedHashKeyFile);
configSource = ConfigurationSourceFactory.Create();
HashProviderFactory factory = new HashProviderFactory(configSource);
defaultHashProvider = factory.Create(hashInstance);
hashProviders.Add(hashInstance, defaultHashProvider);
SymmetricCryptoProviderFactory symmfactory = new SymmetricCryptoProviderFactory(configSource);
defaultSymmetricCryptoProvider = symmfactory.Create(symmInstance);
algorithSymmetricCryptoProvider = symmfactory.Create(symmetricAlgorithm1);
symmetricCrytoProviders.Add(symmInstance, defaultSymmetricCryptoProvider);
symmetricCrytoProviders.Add(symmetricAlgorithm1, algorithSymmetricCryptoProvider);
var container = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
cryptographyManager = container.GetInstance <CryptographyManager>();
}
static void Main(string[] args)
{
// 構成情報を組み立てる
var builder = new ConfigurationSourceBuilder();
builder.ConfigureLogging()
.SpecialSources
.AllEventsCategory
.SendTo
.FlatFile("FlatFileListener")
.FormatWith(
new FormatterBuilder()
.TextFormatterNamed("TextFormatter")
.UsingTemplate("{timestamp(local:yyyy/MM/dd HH:mm:ss.fff)}: {message}"))
.ToFile("output.txt");
// 組み立てた構成情報からConfigurationSourceを作成
var config = new DictionaryConfigurationSource();
builder.UpdateConfigurationWithReplace(config);
// 構成情報を元にEnterpriseLibraryのコンテナの初期化
EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(config);
// EnterpriseLibraryのコンテナからLogging Application BlockのLog書き込み部品を取得
var logger = EnterpriseLibraryContainer.Current.GetInstance <LogWriter>();
// ログに出力する
logger.Write("Hello world");
// ログを表示
Process.Start("output.txt");
}
void NullEncryptorTests(string instanceName)
{
MockStorageEncryptionProvider.Encrypted = false;
MockStorageEncryptionProvider.Decrypted = false;
CacheManagerSettings settings = (CacheManagerSettings)TestConfigurationSource.GenerateConfiguration().GetSection(CacheManagerSettings.SectionName);
CacheStorageData cacheStorageData = settings.BackingStores.Get(((CacheManagerData)settings.CacheManagers.Get(instanceName)).CacheStorage);
StorageEncryptionProviderData encryptionProviderData = settings.EncryptionProviders.Get(cacheStorageData.StorageEncryption);
IStorageEncryptionProvider provider =
EnterpriseLibraryContainer.CreateDefaultContainer(TestConfigurationSource.GenerateConfiguration()).GetInstance <IStorageEncryptionProvider>(encryptionProviderData.Name);
Assert.IsNotNull(provider);
byte[] input = new byte[] { 0, 1, 2, 3, 4, 5 };
byte[] encrypted = provider.Encrypt(input);
Assert.IsTrue(MockStorageEncryptionProvider.Encrypted, "static encrypted");
Assert.IsTrue(CompareBytes(input, encrypted), "no encryption performed");
byte[] decrypted = provider.Decrypt(encrypted);
Assert.IsTrue(MockStorageEncryptionProvider.Decrypted, "static decrypted");
Assert.IsTrue(CompareBytes(encrypted, decrypted), "no decryption performed");
Assert.IsTrue(CompareBytes(input, decrypted), "no decryption performed2");
}
public void SetLogFilePath(string filePath)
{
ConfigurationFileMap objConfigPath = new ConfigurationFileMap();
// App config file path.
string appPath = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
objConfigPath.MachineConfigFilename = appPath;
Configuration entLibConfig = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration("~");
LoggingSettings loggingSettings = (LoggingSettings)entLibConfig.GetSection(LoggingSettings.SectionName);
TraceListenerData traceListenerData = loggingSettings.TraceListeners.Get("Flat File Trace Listener");
FlatFileTraceListenerData objFlatFileTraceListenerData = traceListenerData as FlatFileTraceListenerData;
objFlatFileTraceListenerData.FileName = filePath;
IUnityContainer container = new UnityContainer();
container.AddNewExtension <EnterpriseLibraryCoreExtension>();
// Configurator will read Enterprise Library configuration
// and set up the container
UnityContainerConfigurator configurator = new UnityContainerConfigurator(container);
var loggingXmlConfigSource = new SerializableConfigurationSource();
loggingXmlConfigSource.Add(LoggingSettings.SectionName, loggingSettings);
// Configure the container with our own custom logging
EnterpriseLibraryContainer.ConfigureContainer(configurator, loggingXmlConfigSource);
// Wrap in ServiceLocator
IServiceLocator locator = new UnityServiceLocator(container);
// And set Enterprise Library to use it
EnterpriseLibraryContainer.Current = locator;
}
public void CanBuildValidationInstanceFactoryFromGivenConfiguration()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
ValidationSettings settings = new ValidationSettings();
configurationSource.Add(ValidationSettings.SectionName, settings);
ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(BaseTestDomainObject));
settings.Types.Add(typeReference);
typeReference.DefaultRuleset = "RuleA";
ValidationRulesetData ruleData = new ValidationRulesetData("RuleA");
typeReference.Rulesets.Add(ruleData);
ValidatedPropertyReference propertyReference1 = new ValidatedPropertyReference("Property1");
ruleData.Properties.Add(propertyReference1);
MockValidatorData validator11 = new MockValidatorData("validator1", true);
propertyReference1.Validators.Add(validator11);
validator11.MessageTemplate = "message-from-config1-RuleA";
CompositeValidatorFactory factory
= EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource)
.GetInstance <CompositeValidatorFactory>();
var validator = factory.CreateValidator <BaseTestDomainObject>("RuleA");
var results = validator.Validate(new BaseTestDomainObject());
Assert.IsNotNull(factory);
Assert.IsFalse(results.IsValid);
Assert.AreEqual(validator11.MessageTemplate, results.ElementAt(0).Message);
}
public static UnityContainer Create()
{
var container = new UnityContainer();
container.InstallCoreExtensions();
// Configurator will read Enterprise Library configuration
// and set up the container
var configurator = new UnityContainerConfigurator(container);
// Configuration source holds the new configuration we want to use
// load this in your own code
IConfigurationSource configSource = new SystemConfigurationSource(true);
// Configure the container
EnterpriseLibraryContainer.ConfigureContainer(configurator, configSource);
// Self-register and set up service location
container.RegisterInstance <IUnityContainer>(container);
var locator = new UnityServiceLocator(container);
ServiceLocator.SetLocatorProvider(() => locator);
return(container);
}
/// <summary>
/// ConfigurationSourceBuilderの内容を元にIServiceProviderを作成します。
/// </summary>
/// <param name="self"></param>
/// <returns></returns>
public static IServiceLocator CreateContainer(this ConfigurationSourceBuilder self)
{
var configuration = new DictionaryConfigurationSource();
self.UpdateConfigurationWithReplace(configuration);
return(EnterpriseLibraryContainer.CreateDefaultContainer(configuration));
}
protected override void Arrange()
{
updatableConfigurationSource = new ConfigurationSourceUpdatable();
connectionStringsSection = new ConnectionStringsSection();
connectionStringsSection.ConnectionStrings.Add(
new ConnectionStringSettings
{
Name = "default connection",
ConnectionString = "connection string",
ProviderName = "System.Data.OracleClient"
});
connectionStringsSection.ConnectionStrings.Add(
new ConnectionStringSettings
{
Name = "other connection",
ConnectionString = "connection string",
ProviderName = "System.Data.SqlClient"
});
databaseSettings = new DatabaseSettings {
DefaultDatabase = "default connection"
};
updatableConfigurationSource.Add("connectionStrings", connectionStringsSection);
updatableConfigurationSource.Add(DatabaseSettings.SectionName, databaseSettings);
container = new UnityContainer();
containerConfigurator = new UnityContainerConfigurator(container);
EnterpriseLibraryContainer.ConfigureContainer(containerConfigurator, updatableConfigurationSource);
}
private void ConfigureExceptionHandling()
{
var configurationSource = new DictionaryConfigurationSource();
var builder = new ConfigurationSourceBuilder();
builder
.ConfigureExceptionHandling()
.GivenPolicyWithName(ValidationPolicy)
.ForExceptionType <DeleteConstraintException>()
.HandleCustom <BusinessValidationHandler>()
.ThenThrowNewException()
.ForExceptionType <BusinessValidationException>()
.ThenNotifyRethrow()
.ForExceptionType <BusinessException>()
.HandleCustom <BusinessValidationHandler>()
.ThenThrowNewException()
.GivenPolicyWithName(DefaultPolicy)
.ForExceptionType <Exception>()
.LogToCategory("General")
.WithSeverity(TraceEventType.Critical)
.UsingExceptionFormatter <TextExceptionFormatter>()
.WrapWith <Exception>()
.UsingMessage("An error has occurred while processing request. Please contact your administrator for more information. [Error ID: {handlingInstanceID}]")
.ThenThrowNewException();
builder.UpdateConfigurationWithReplace(configurationSource);
var configurator = new UnityContainerConfigurator(this.Container);
EnterpriseLibraryContainer.ConfigureContainer(configurator, configurationSource);
}
public void CreateLogger_WithConfiguredLogWriter_LogEntryIsForwardedToConfiguredLogWriter()
{
/* Create a mocked logwriter */
LogWriter mockedLogWriter = MockRepository.GenerateMock <LogWriter>();
/* Build up the EnterpriseLibraryContainer using Unity for the IoC */
IUnityContainer container = new UnityContainer();
container.RegisterInstance <LogWriter>("logwriter", mockedLogWriter); /* Any name will do */
UnityContainerConfigurator configurator = new UnityContainerConfigurator(container);
IConfigurationSource configSource = new DictionaryConfigurationSource();
EnterpriseLibraryContainer.ConfigureContainer(configurator, configSource);
IServiceLocator locator = new UnityServiceLocator(container);
EnterpriseLibraryContainer.Current = locator;
/* Call the test subject */
Logger result = LogManager.CreateLogger();
/* Make sure the returned logger is not null... */
Assert.IsNotNull(result);
/* ...and that the returned logger is working with the configured LogWriter */
LogEntry entry = new LogEntry("message", "category", 1, 1000, System.Diagnostics.TraceEventType.Information, "title", null);
result.Log(entry);
mockedLogWriter.AssertWasCalled(lw => lw.Write(Arg.Is(entry)));
}
public void EntLib5UseCase()
{
// construct the Configuration Source to use
var builder = new ConfigurationSourceBuilder();
// fluent API configuration
builder.ConfigureLogging()
.WithOptions
.DoNotRevertImpersonation()
.LogToCategoryNamed("Simple")
.SendTo.FlatFile("Simple Log File")
.FormatWith(new FormatterBuilder()
.TextFormatterNamed("simpleFormat")
.UsingTemplate("{timestamp} : {message}{newline}"))
.ToFile("simple.log");
var configSource = new DictionaryConfigurationSource();
builder.UpdateConfigurationWithReplace(configSource);
EnterpriseLibraryContainer.Current
= EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
ILog log = LogManager.GetLogger(GetType());
log.Debug("Debug Event Log Entry.");
log.Warn("Warning Event Log Entry.");
}
public void ConfigurationChangeNotificationRefreshesLoggerAutomatically()
{
using (var configurationSource = new SystemConfigurationSource(true, 100))
using (var serviceLocator = (UnityServiceLocator)EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource))
{
EnterpriseLibraryContainer.Current = serviceLocator;
Logger.Reset();
MockTraceListener.Reset();
Logger.Write("test", "MockCategoryOne");
Assert.AreEqual(1, MockTraceListener.Entries.Count);
System.Configuration.Configuration rwConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
LoggingSettings rwSettings = rwConfiguration.GetSection(LoggingSettings.SectionName) as LoggingSettings;
((CategoryFilterData)rwSettings.LogFilters.Get("Category")).CategoryFilters.Add(new CategoryFilterEntry("MockCategoryOne"));
rwConfiguration.Save();
Thread.Sleep(1000);
MockTraceListener.Reset();
Logger.Write("test", "MockCategoryOne");
Assert.AreEqual(0, MockTraceListener.Entries.Count);
}
}
private void ConfigureLogging()
{
var configurationSource = new DictionaryConfigurationSource();
var builder = new ConfigurationSourceBuilder();
const string DefaultListenerName = "Default";
builder.ConfigureLogging()
.WithOptions
.DoNotRevertImpersonation()
.SpecialSources
.LoggingErrorsAndWarningsCategory
.SendTo.SharedListenerNamed(DefaultListenerName)
.SpecialSources
.UnprocessedCategory
.SendTo.SharedListenerNamed(DefaultListenerName)
.SpecialSources
.AllEventsCategory
.SendTo.SharedListenerNamed(DefaultListenerName)
.LogToCategoryNamed("General")
.WithOptions.SetAsDefaultCategory()
.SendTo.SharedListenerNamed(DefaultListenerName);
builder.UpdateConfigurationWithReplace(configurationSource);
var configurator = new UnityContainerConfigurator(this.Container);
EnterpriseLibraryContainer.ConfigureContainer(configurator, configurationSource);
this.Container.RegisterType <TraceListener, CommonLoggingEntlibTraceListener>(
DefaultListenerName,
new ContainerControlledLifetimeManager(),
new InjectionFactory(this.CreateListener));
}
public void AddingCategoryFilterToConfigIsReflectedInContainer()
{
using (var configurationSource = new SystemConfigurationSource(false))
using (var serviceLocator = (UnityServiceLocator)EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource))
{
EnterpriseLibraryContainer.Current = serviceLocator;
Logger.Reset();
MockTraceListener.Reset();
Logger.Write("test", "MockCategoryOne");
Assert.AreEqual(1, MockTraceListener.Entries.Count);
System.Configuration.Configuration rwConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
LoggingSettings rwSettings = rwConfiguration.GetSection(LoggingSettings.SectionName) as LoggingSettings;
((CategoryFilterData)rwSettings.LogFilters.Get("Category")).CategoryFilters.Add(new CategoryFilterEntry("MockCategoryOne"));
rwConfiguration.Save();
((IConfigurationSourceTest)configurationSource).ConfigSourceChanged(string.Empty);
var categoryFilter = EnterpriseLibraryContainer.Current.GetInstance <CategoryFilter>("Category");
Assert.AreEqual(1,
categoryFilter.CategoryFilters.Count(c => c == "MockCategoryOne"));
}
}
public void ConfigurationChangeNotificationRefreshesLogger()
{
using (var configurationSource = new SystemConfigurationSource(false))
using (var serviceLocator = (UnityServiceLocator)EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource))
{
EnterpriseLibraryContainer.Current = serviceLocator;
Logger.Reset();
MockTraceListener.Reset();
Logger.Write("test", "MockCategoryOne");
Assert.AreEqual(1, MockTraceListener.Entries.Count);
System.Configuration.Configuration rwConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
LoggingSettings rwSettings = rwConfiguration.GetSection(LoggingSettings.SectionName) as LoggingSettings;
((CategoryFilterData)rwSettings.LogFilters.Get("Category")).CategoryFilters.Add(new CategoryFilterEntry("MockCategoryOne"));
rwConfiguration.Save();
((IConfigurationSourceTest)configurationSource).ConfigSourceChanged(string.Empty);
MockTraceListener.Reset();
Logger.Write("test", "MockCategoryOne");
Assert.AreEqual(0, MockTraceListener.Entries.Count, "should have been filtered out by the new category filter");
}
}
public override void createTestFixture()
{
base.createTestFixture();
ObjectsConverter.Configure();
configureLogging();
clientInformation = new ClientInformation()
{
Version = Const.ServiceVersion
};
clientInformation.ApplicationLanguage = "en";
clientInformation.PlatformVersion = "fgfdgdfg";
clientInformation.ApplicationVersion = "1.0.0.0";
var conf = new ConfigurationSourceBuilder();
conf.ConfigureCaching().ForCacheManagerNamed(SecurityManager.AuthenticationCacheName).StoreInMemory();
var configSource = new DictionaryConfigurationSource();
conf.UpdateConfigurationWithReplace(configSource);
var xmlStream = DateTimeExtension.GetResource("BodyArchitect.UnitTests.V2.BAPointsTests.BAPoints.xml");
var paymentsManager = new PaymentsManager();
this.paymentsManager = paymentsManager.Load(xmlStream);
InternalBodyArchitectService.PaymentsManager = this.paymentsManager;
EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
}
public void EntLib5FactoryTestWithFluentConfig()
{
// construct the Configuration Source to use
var builder = new ConfigurationSourceBuilder();
// fluent API configuration
builder.ConfigureLogging()
.WithOptions
.DoNotRevertImpersonation()
.LogToCategoryNamed("Simple")
.SendTo.FlatFile("Simple Log File")
.FormatWith(new FormatterBuilder()
.TextFormatterNamed("simpleFormat")
.UsingTemplate("{timestamp} : {message}{newline}"))
.ToFile("simple.log");
var configSource = new DictionaryConfigurationSource();
builder.UpdateConfigurationWithReplace(configSource);
EnterpriseLibraryContainer.Current
= EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
// initialize the EntLib5 Logger factory with configuration file
EntLib5Factory factory = new EntLib5Factory();
ILog log = factory.GetLogger(GetType());
Assert.IsNotNull(log);
Assert.IsNotNull(log as EntLib5Logger);
}
public void TestGetExceptionManagerFromServiceLocator()
{
// Create the container
var container = new UnityContainer();
// Configurator will read Enterprise Library configuration
// and set up the container
var configurator = new UnityContainerConfigurator(container);
// Configuration source holds the new configuration we want to use
// load this in your own code
var configSource = new FileConfigurationSource("EntLib.config.xml");
// Configure the container
EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
// Wrap in ServiceLocator
var locator = new UnityServiceLocator(container);
// And set Enterprise Library to use it
EnterpriseLibraryContainer.Current = locator;
var exceptionManager = EnterpriseLibraryContainer.Current.GetInstance <ExceptionManager>();
Assert.NotNull(exceptionManager);
}
private void configureEntLib()
{
var formatterStandard = new FormatterBuilder().TextFormatterNamed("Text Formatter").UsingTemplate(
"Timestamp: {timestamp}{newline}Message: {message}{newline}Severity: {severity}{newline}Machine: {machine}{newline}Process Name: {processName}{newline}Extended Properties: {dictionary({key} - {value}{newline})}");
var conf = new ConfigurationSourceBuilder();
var logConfig = conf.ConfigureLogging();
logConfig.WithOptions.LogToCategoryNamed("Exception").SendTo.RollingFile(
"ExceptionFileListener").WithHeader("----------------------------------------").WithFooter("----------------------------------------").ToFile(UserContext.Settings.ExceptionsLogFile);
logConfig.WithOptions.LogToCategoryNamed("General").SendTo.RollingFile(
"FlatFile TraceListener").WithHeader("----------------------------------------").WithFooter("----------------------------------------").FormatWith(formatterStandard).ToFile(UserContext.Settings.StandardLogFile);
logConfig.WithOptions.LogToCategoryNamed("email").SendTo.Email("email").FormatWith(formatterStandard).UsingSmtpServer(
ApplicationSettings.MailSmtp).WithUserNameAndPassword(ApplicationSettings.MailUserName,
ApplicationSettings.MailPassword).To(
ApplicationSettings.MailAccount).From(
ApplicationSettings.MailAccount).UseSSL(true);
//configure cache
var cacheCfg = conf.ConfigureCaching();
cacheCfg.ForCacheManagerNamed(PicturesCache.PicturesCacheName).StoreInIsolatedStorage(
"Isolated Storage Cache Store").UsePartition("PicturesCache1");
cacheCfg.ForCacheManagerNamed("ErrorCache").StoreInMemory();
var configSource = new DictionaryConfigurationSource();
conf.UpdateConfigurationWithReplace(configSource);
EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
BodyArchitect.Logger.Log.EnableExceptionLog = Settings1.Default.LogErrorEnabled;
BodyArchitect.Logger.Log.EnableStandardLog = Settings1.Default.LogStandardEnabled;
}
// http://www.nikosbaxevanis.com/bonus-bits/2011/08/following-the-composition-root-pattern-with-enterprise-library.html
public static void ForEnterpriseLibrary(UnityContainer container)
{
var configurator = new UnityContainerConfigurator(container);
var configSource = ConfigurationSourceFactory.Create();
EnterpriseLibraryContainer.ConfigureContainer(configurator, configSource);
}
public void Setup()
{
container = new UnityContainer();
var configurationSource =
new SystemConfigurationSource();
EnterpriseLibraryContainer.ConfigureContainer(new UnityContainerConfigurator(container), configurationSource);
}
/// <summary>
/// Initializes a new instance of the <see cref="EntLib5Factory"/> class.
/// </summary>
/// <param name="EntLib5ConfigurationSrc">The enterprise library 5.0 configuration source to load. Supercedes any configuration found in the Config file.</param>
public EntLib5Factory(IConfigurationSource EntLib5ConfigurationSrc)
{
// replace any settings from App.Config with the ones in the provided config source
var builder = new ConfigurationSourceBuilder();
builder.UpdateConfigurationWithReplace(EntLib5ConfigurationSrc);
EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(EntLib5ConfigurationSrc);
}
private static TraceListener GetListener(string name, IConfigurationSource configurationSource)
{
var container = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource);
var listener = container.GetInstance <TraceListener>(name);
container.Dispose();
return(listener);
}
public void CanResolveCryptoProvider()
{
IServiceLocator container = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource);
ISymmetricCryptoProvider provider = container.GetInstance <ISymmetricCryptoProvider>(symmetricInstance);
Assert.IsNotNull(provider);
Assert.AreSame(typeof(DpapiSymmetricCryptoProvider), provider.GetType());
}
public InterceptionStrategy()
{
IUnityContainer container = new UnityContainer();
UnityContainerConfigurator configurator = new UnityContainerConfigurator(container);
EnterpriseLibraryContainer.ConfigureContainer(configurator, ConfigurationSourceFactory.Create());
this.UnityContainer = container;
this.InterceptionMember = new InstanceInterceptionPolicySettingInjectionMember(new TransparentProxyInterceptor());
}
public void CanBuildLogWriterStructureHolder()
{
LogWriterStructureHolder setup =
EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource)
.GetInstance <LogWriterStructureHolder>();
Assert.IsNotNull(setup);
Assert.AreEqual(2, setup.TraceSources.Count);
}
public void StaticFacadeUsesTheCurrentServiceLocator()
{
GlobalCountCallHandler.Calls.Clear();
var interceptionConfigurationSource = new DictionaryConfigurationSource();
interceptionConfigurationSource.Add(
PolicyInjectionSettings.SectionName,
new PolicyInjectionSettings
{
Policies =
{
new PolicyData("policy")
{
MatchingRules =
{
new CustomMatchingRuleData("always", typeof(AlwaysMatchingRule))
},
Handlers =
{
new CustomCallHandlerData("count", typeof(GlobalCountCallHandler))
{
Attributes ={ { "callhandler","count" } }
}
}
}
}
});
var interceptionLocator = EnterpriseLibraryContainer.CreateDefaultContainer(interceptionConfigurationSource);
var noInterceptionLocator = EnterpriseLibraryContainer.CreateDefaultContainer(new DictionaryConfigurationSource());
try
{
EnterpriseLibraryContainer.Current = interceptionLocator;
var interceptedWrappable = PolicyInjection.Create <Wrappable>();
interceptedWrappable.Method();
Assert.AreEqual(1, GlobalCountCallHandler.Calls.Count);
GlobalCountCallHandler.Calls.Clear();
EnterpriseLibraryContainer.Current = noInterceptionLocator;
var nonInterceptedWrappable = PolicyInjection.Create <Wrappable>();
nonInterceptedWrappable.Method();
Assert.AreEqual(0, GlobalCountCallHandler.Calls.Count);
}
finally
{
EnterpriseLibraryContainer.Current = null;
GlobalCountCallHandler.Calls.Clear();
interceptionLocator.Dispose();
noInterceptionLocator.Dispose();
}
}
/// <summary>
/// Configures the Unity container to be able to resolve Enterprise Library
/// objects.
/// </summary>
protected override void Initialize()
{
// Only need to do this once; do nothing if this extension has already
// been added.
if (Container.Configure <EnterpriseLibraryCoreExtension>() == this)
{
var configurator = new UnityContainerConfigurator(Container);
EnterpriseLibraryContainer.ConfigureContainer(configurator, configurationSource);
}
}
protected override void Act()
{
IServiceLocator locator = EnterpriseLibraryContainer.CreateDefaultContainer(GetConfig());
EnterpriseLibraryContainer.Current = locator;
staticFu = EnterpriseLibraryContainer.Current.GetInstance <StaticFu>();
Assert.IsInstanceOfType(staticFu.MyInnerFoo, typeof(Foo));
updatableConfigSource.DoSourceChanged(new[] { "MockRegistrationProvider" });
}
static IServiceLocator GetContainerWithTracingFlag(bool tracingEnabled)
{
var config = new FileConfigurationSource(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, false);
var loggingSettings = ((LoggingSettings)config.GetSection(LoggingSettings.SectionName));
loggingSettings.TracingEnabled = tracingEnabled;
Logger.Reset();
return(EnterpriseLibraryContainer.CreateDefaultContainer(config));
}
public static void SetCurrentLocator(IServiceLocator locator)
{
var newContainer = new EnterpriseLibraryContainer(locator);
lock (globalContainerLock)
{
globalContainer = newContainer;
}
}
public void Given()
{
context = new MockLocatorContext();
container = new EnterpriseLibraryContainer(context.MockLocator);
}
