public void InstrumentationIsWiredUpCorrectlyWhenConfigurationSectionIsPresent()
{
EventSource source
= EnterpriseLibraryFactory.BuildUp <EventSource>("ignore", configSource);
Assert.IsTrue(source.IsWired);
}
public void InstrumentationAvoidsTryingToWireUpToObjectsWithNoListenerDefined()
{
NoListenerEventSource source
= EnterpriseLibraryFactory.BuildUp <NoListenerEventSource>("ignore", configSource);
Assert.IsFalse(source.IsWired);
}
public void CanStillCreateLoggerWithoutConfigurationSectionPresent()
{
DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
DefaultEventLogger logger = EnterpriseLibraryFactory.BuildUp <DefaultEventLogger>(configSource);
Assert.IsFalse(logger.EventLoggingEnabled);
}
public MsmqListener(DistributorService distributorService, int timerInterval, string msmqPath)
{
this.distributorService = distributorService;
this.QueueTimerInterval = timerInterval;
this.eventLogger = distributorService.EventLogger;
this.logDistributor = new MsmqLogDistributor(EnterpriseLibraryFactory.BuildUp <LogWriter>(), msmqPath, this.eventLogger);
}
private void NullEncryptorTests(string instanceName)
{
MockStorageEncryptionProvider.Encrypted = false;
MockStorageEncryptionProvider.Decrypted = false;
CacheManagerSettings settings = (CacheManagerSettings)TestConfigurationSource.GenerateConfiguration().GetSection(CacheManagerSettings.SectionName);
CacheStorageData cacheStorageData = settings.BackingStores.Get(settings.CacheManagers.Get(instanceName).CacheStorage);
StorageEncryptionProviderData encryptionProviderData = settings.EncryptionProviders.Get(cacheStorageData.StorageEncryption);
IStorageEncryptionProvider provider =
EnterpriseLibraryFactory.BuildUp <IStorageEncryptionProvider>(encryptionProviderData.Name, TestConfigurationSource.GenerateConfiguration());
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 CanCreateSqlDatabase()
{
Database database = EnterpriseLibraryFactory.BuildUp <Database>("Service_Dflt");
Assert.IsNotNull(database);
Assert.AreSame(typeof(SqlDatabase), database.GetType());
}
private static ExceptionPolicyImpl GetExceptionPolicy(Exception exception, string policyName, ExceptionPolicyFactory factory)
{
try
{
return(factory.Create(policyName));
}
catch (ConfigurationErrorsException configurationException)
{
try
{
DefaultExceptionHandlingEventLogger logger = EnterpriseLibraryFactory.BuildUp <DefaultExceptionHandlingEventLogger>();
logger.LogConfigurationError(configurationException, policyName);
}
catch { }
throw;
}
catch (Exception ex)
{
try
{
string exceptionMessage = ExceptionUtility.FormatExceptionHandlingExceptionMessage(policyName, ex, null, exception);
DefaultExceptionHandlingEventLogger logger = EnterpriseLibraryFactory.BuildUp <DefaultExceptionHandlingEventLogger>();
logger.LogInternalError(policyName, exceptionMessage);
}
catch { }
throw new ExceptionHandlingException(ex.Message, ex);
}
}
public void InstrumentationNotWiredWhenConfigurationSectionNotPresent()
{
EventSource source
= EnterpriseLibraryFactory.BuildUp <EventSource>("ignore", new DictionaryConfigurationSource());
Assert.IsFalse(source.IsWired);
}
public void CanBuildLogWriterStructureHolder()
{
LogWriterStructureHolder setup
= EnterpriseLibraryFactory.BuildUp <LogWriterStructureHolder>(configurationSource);
Assert.IsNotNull(setup);
Assert.AreEqual(2, setup.TraceSources.Count);
}
public void CanCreateGenericDatabase()
{
Database database = EnterpriseLibraryFactory.BuildUp <Database>("OdbcDatabase");
Assert.IsNotNull(database);
Assert.AreSame(typeof(GenericDatabase), database.GetType());
DbCommand command = database.GetStoredProcCommand("ignore");
Assert.AreSame(typeof(OdbcCommand), command.GetType());
}
internal static void TryLogConfigurationFailure(ConfigurationErrorsException configurationException)
{
try
{
DefaultLoggingEventLogger logger = EnterpriseLibraryFactory.BuildUp <DefaultLoggingEventLogger>();
logger.LogConfigurationError(configurationException);
}
catch
{ }
}
public void AttemptingToReadEncryptedDataWithoutDecryptingThrowsException()
{
IStorageEncryptionProvider encryptionProvider = null;
encryptionProvider = EnterpriseLibraryFactory.BuildUp <IStorageEncryptionProvider>("Fred");
DataBackingStore encryptingBackingStore = new DataBackingStore(db, "encryptionTests", encryptionProvider);
encryptingBackingStore.Add(new CacheItem("key", "value", CacheItemPriority.Normal, new MockRefreshAction(), new AlwaysExpired()));
Hashtable dataInCache = unencryptedBackingStore.Load();
}
public void InstrumentationNotWiredWhenConfigurationValuesAllFalse()
{
DictionaryConfigurationSource section = new DictionaryConfigurationSource();
section.Add(InstrumentationConfigurationSection.SectionName,
new InstrumentationConfigurationSection(false, false, false, "fooApplicationInstanceName"));
EventSource source
= EnterpriseLibraryFactory.BuildUp <EventSource>("ignore", new DictionaryConfigurationSource());
Assert.IsFalse(source.IsWired);
}
public void CanCreateThroughObjectBuilder()
{
DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
InstrumentationConfigurationSection configSection = new InstrumentationConfigurationSection();
configSection.EventLoggingEnabled = true;
configSource.Add(InstrumentationConfigurationSection.SectionName, configSection);
DefaultEventLogger logger = EnterpriseLibraryFactory.BuildUp <DefaultEventLogger>(configSource);
Assert.IsTrue(logger.EventLoggingEnabled);
}
public void CanBuildDefaultLogger()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(InstrumentationConfigurationSection.SectionName, new InstrumentationConfigurationSection(true, true, true));
DefaultCachingEventLogger logger
= EnterpriseLibraryFactory.BuildUp <DefaultCachingEventLogger>(configurationSource);
Assert.IsNotNull(logger);
}
public void SetUp()
{
logWriter = EnterpriseLibraryFactory.BuildUp <LogWriter>();
MockTraceListener.Reset();
ErrorsMockTraceListener.Reset();
emptyTraceSource = new LogSource("none");
if (emptyTraceSource.Listeners.Count == 1)
{
emptyTraceSource.Listeners.RemoveAt(0);
}
}
private static void TryLogConfigurationError(ConfigurationErrorsException configurationException, string instanceName)
{
try
{
DefaultDataEventLogger eventLogger = EnterpriseLibraryFactory.BuildUp <DefaultDataEventLogger>();
if (eventLogger != null)
{
eventLogger.LogConfigurationError(configurationException, instanceName);
}
}
catch { }
}
private static void TryLogConfigurationError(ConfigurationErrorsException configurationException, string instanceName)
{
try
{
DefaultSecurityEventLogger eventLogger = EnterpriseLibraryFactory.BuildUp <DefaultSecurityEventLogger>();
if (eventLogger != null)
{
eventLogger.LogConfigurationError(instanceName, Resources.ErrorAuthorizationConfigurationFailedMessage, configurationException);
}
}
catch { }
}
public void CanBuildCustomAuthorizationProviderFromSystemConfiguration()
{
IConfigurationSource configurationSource
= new SystemConfigurationSource();
IAuthorizationProvider custom
= EnterpriseLibraryFactory.BuildUp <IAuthorizationProvider>("custom", configurationSource);
Assert.IsNotNull(custom);
Assert.AreSame(typeof(MockCustomAuthorizationProvider), custom.GetType());
Assert.AreEqual("value1", ((MockCustomAuthorizationProvider)custom).customValue);
}
private static void TryLogConfigurationError(ConfigurationErrorsException configurationException, string hashInstance, string template)
{
try
{
DefaultCryptographyEventLogger eventLogger = EnterpriseLibraryFactory.BuildUp <DefaultCryptographyEventLogger>();
if (eventLogger != null)
{
eventLogger.LogConfigurationError(hashInstance, template, configurationException);
}
}
catch { }
}
public void CanCreateOracleDatabase()
{
Database database = EnterpriseLibraryFactory.BuildUp <Database>("OracleTest");
Assert.IsNotNull(database);
Assert.AreSame(typeof(OracleDatabase), database.GetType());
DbCommand dbCommand1 = database.GetStoredProcCommand(OracleTestStoredProcedureInPackageWithTranslation);
Assert.AreEqual((object)OracleTestTranslatedStoredProcedureInPackageWithTranslation, dbCommand1.CommandText);
DbCommand dbCommand2 = database.GetStoredProcCommand(OracleTestStoredProcedureInPackageWithoutTranslation);
Assert.AreEqual((object)OracleTestStoredProcedureInPackageWithoutTranslation, dbCommand2.CommandText);
}
public void SetUp()
{
AppDomain.CurrentDomain.SetData("APPBASE", Environment.CurrentDirectory);
logWriter = EnterpriseLibraryFactory.BuildUp <LogWriter>();
MockTraceListener.Reset();
ErrorsMockTraceListener.Reset();
emptyTraceSource = new LogSource("none");
if (emptyTraceSource.Listeners.Count == 1)
{
emptyTraceSource.Listeners.RemoveAt(0);
}
}
public void InstrumentationIsTurnedOffWhenPassingNoConfigurationSource()
{
int initialValue = GetCounterValue(performanceCounterTracesPerSecondName, operation);
LogWriter logWriter = EnterpriseLibraryFactory.BuildUp <LogWriter>();
using (Tracer tracer = new Tracer(operation, logWriter, null))
{
int i = new Random().Next();
}
int valueAfterTracing = GetCounterValue(performanceCounterTracesPerSecondName, operation);
Assert.IsTrue(valueAfterTracing == initialValue);
}
private static TracerInstrumentationListener GetInstrumentationListener(IConfigurationSource configurationSource)
{
TracerInstrumentationListener instrumentationListener;
if (configurationSource != null)
{
instrumentationListener = EnterpriseLibraryFactory.BuildUp <TracerInstrumentationListener>(configurationSource);
}
else
{
instrumentationListener = new TracerInstrumentationListener(false);
}
return(instrumentationListener);
}
public void UpdateLogWriter(object sender, ConfigurationChangedEventArgs args)
{
if (logWriter != null)
{
try
{
LogWriterStructureHolder newStructureHolder
= EnterpriseLibraryFactory.BuildUp <LogWriterStructureHolder>(configurationSource);
logWriter.ReplaceStructureHolder(newStructureHolder);
}
catch (ConfigurationErrorsException configurationException)
{
logWriter.ReportConfigurationFailure(configurationException);
}
}
}
public static CacheManager Create(string name, IConfigurationSource configurationSource)
{
CachingConfigurationView configurationView = new CachingConfigurationView(configurationSource);
CacheManagerData objectConfiguration = configurationView.GetCacheManagerData(name);
IBackingStore backingStore =
EnterpriseLibraryFactory.BuildUp <IBackingStore>(objectConfiguration.CacheStorage, configurationSource);
return(new MockCacheManagerFactoryHelper().BuildCacheManager(
name,
backingStore,
objectConfiguration.MaximumElementsInCacheBeforeScavenging,
objectConfiguration.NumberToRemoveWhenScavenging,
objectConfiguration.ExpirationPollFrequencyInSeconds,
new CachingInstrumentationProvider()));
}
public void LogWriterCanGetConfiguredCategories()
{
LogWriter logWriter = EnterpriseLibraryFactory.BuildUp <LogWriter>();
LogSource source = null;
foreach (string key in logWriter.TraceSources.Keys)
{
logWriter.TraceSources.TryGetValue(key, out source);
Assert.IsNotNull(source, key);
Assert.AreEqual(key, source.Name);
}
source = null;
logWriter.TraceSources.TryGetValue("AppTest", out source);
logWriter.Dispose();
Assert.IsNotNull(source);
}
public void DecryptedDataCanBeReadBackFromDatabase()
{
IStorageEncryptionProvider encryptionProvider = null;
encryptionProvider = EnterpriseLibraryFactory.BuildUp <IStorageEncryptionProvider>("Fred");
DataBackingStore encryptingBackingStore = new DataBackingStore(db, "encryptionTests", encryptionProvider);
encryptingBackingStore.Add(new CacheItem("key", "value", CacheItemPriority.Normal, new MockRefreshAction(), new AlwaysExpired()));
Hashtable dataInCache = encryptingBackingStore.Load();
CacheItem retrievedItem = (CacheItem)dataInCache["key"];
Assert.AreEqual("key", retrievedItem.Key);
Assert.AreEqual("value", retrievedItem.Value);
Assert.AreEqual(CacheItemPriority.Normal, retrievedItem.ScavengingPriority);
Assert.AreEqual(typeof(MockRefreshAction), retrievedItem.RefreshAction.GetType());
Assert.AreEqual(typeof(AlwaysExpired), retrievedItem.GetExpirations()[0].GetType());
}
public void CanBuildCustomHashProviderFromGivenConfiguration()
{
CustomHashProviderData customData
= new CustomHashProviderData("custom", typeof(MockCustomHashProvider));
customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
CryptographySettings settings = new CryptographySettings();
settings.HashProviders.Add(customData);
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(CryptographyConfigurationView.SectionName, settings);
IHashProvider custom
= EnterpriseLibraryFactory.BuildUp <IHashProvider>("custom", configurationSource);
Assert.IsNotNull(custom);
Assert.AreSame(typeof(MockCustomHashProvider), custom.GetType());
Assert.AreEqual("value1", ((MockCustomHashProvider)custom).customValue);
}
public void CanBuildCustomBackingStoreFromGivenConfiguration()
{
CustomCacheStorageData customData
= new CustomCacheStorageData("custom", typeof(MockCustomStorageBackingStore));
customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
CacheManagerSettings settings = new CacheManagerSettings();
settings.BackingStores.Add(customData);
settings.CacheManagers.Add(new CacheManagerData("ignore", 0, 0, 0, "custom"));
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(CacheManagerSettings.SectionName, settings);
IBackingStore custom
= EnterpriseLibraryFactory.BuildUp <IBackingStore>("custom", configurationSource);
Assert.IsNotNull(custom);
Assert.AreSame(typeof(MockCustomStorageBackingStore), custom.GetType());
Assert.AreEqual("value1", ((MockCustomStorageBackingStore)custom).customValue);
}
