public void SetUp()
{
configurationSource = new DictionaryConfigurationSource();
configurationAccessor = new DictionaryConfigurationSourceConfigurationAccessor(configurationSource);
currentUser = new MockRegistryKey(true);
localMachine = new MockRegistryKey(true);
registryAccessor = new MockRegistryAccessor(currentUser, localMachine);
manageabilityProviders = new Dictionary<string, ConfigurationSectionManageabilityProvider>();
subProviders = new Dictionary<Type, ConfigurationElementManageabilityProvider>();
}
protected override void Arrange()
{
var source = new DictionaryConfigurationSource();
source.Add(RetryPolicyConfigurationSettings.SectionName, GetSettings());
var typeRegistrationSettings = new TypeRegistrationProvidersConfigurationSection();
typeRegistrationSettings.TypeRegistrationProviders.Add(new TypeRegistrationProviderElement() { SectionName = RetryPolicyConfigurationSettings.SectionName });
source.Add(TypeRegistrationProvidersConfigurationSection.SectionName, typeRegistrationSettings);
EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(source);
}
public void Setup()
{
var configSource = new DictionaryConfigurationSource();
var connectionStrings = new ConnectionStringsSection();
connectionStrings.ConnectionStrings.Add(new ConnectionStringSettings
{
Name = "someSetting",
ConnectionString = "someConnectionString",
ProviderName = "non registered"
});
configSource.Add("connectionStrings", connectionStrings);
configSettings = new DatabaseSyntheticConfigSettings(configSource.GetSection);
}
public void Setup()
{
var configSource = new DictionaryConfigurationSource();
var connectionStrings = new ConnectionStringsSection();
connectionStrings.ConnectionStrings.Add(
new ConnectionStringSettings("someSetting", "someConnectionString", "System.Data.Odbc"));
configSource.Add("connectionStrings", connectionStrings);
var databaseSettings = new DatabaseSettings();
databaseSettings.ProviderMappings.Add(new DbProviderMapping("System.Data.Odbc", typeof(TestDatabase)));
configSource.Add(DatabaseSettings.SectionName, databaseSettings);
configSettings = new DatabaseSyntheticConfigSettings(configSource.GetSection);
}
public void ManageabilityProviderGeneratesProperAdmContent()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
LoggingSettings section = new LoggingSettings();
configurationSource.Add(LoggingSettings.SectionName, section);
section.TraceSources.Add(new TraceSourceData("source1", SourceLevels.Off));
section.TraceSources.Add(new TraceSourceData("source2", SourceLevels.Off));
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
contentBuilder.StartCategory("category");
provider.InvokeAddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, "TestApp");
contentBuilder.EndCategory();
MockAdmContent content = contentBuilder.GetMockContent();
IEnumerator <AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator <AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
Assert.IsTrue(policiesEnumerator.MoveNext());
Assert.AreEqual(String.Format(Resources.FilterPolicyNameTemplate, configurationObject.Name),
policiesEnumerator.Current.Name);
IEnumerator <AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmDropDownListPart), partsEnumerator.Current.GetType());
Assert.IsNull(partsEnumerator.Current.KeyName);
Assert.AreEqual(CategoryFilterDataManageabilityProvider.CategoryFilterModePropertyName,
partsEnumerator.Current.ValueName);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual(Resources.CategoryFilterCategoriesPartName, partsEnumerator.Current.PartName);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmCheckboxPart), partsEnumerator.Current.GetType());
Assert.IsTrue(partsEnumerator.Current.KeyName.EndsWith(CategoryFilterDataManageabilityProvider.CategoryFiltersKeyName));
Assert.AreEqual("source1", partsEnumerator.Current.ValueName);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmCheckboxPart), partsEnumerator.Current.GetType());
Assert.IsTrue(partsEnumerator.Current.KeyName.EndsWith(CategoryFilterDataManageabilityProvider.CategoryFiltersKeyName));
Assert.AreEqual("source2", partsEnumerator.Current.ValueName);
Assert.IsFalse(partsEnumerator.MoveNext());
Assert.IsFalse(policiesEnumerator.MoveNext());
}
public void CanBuildCustomLogFormatterFromGivenConfiguration()
{
CustomFormatterData customData
= new CustomFormatterData("formatter", typeof(MockCustomLogFormatter));
customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
LoggingSettings settings = new LoggingSettings();
settings.Formatters.Add(customData);
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(LoggingSettings.SectionName, settings);
ILogFormatter formatter = LogFormatterCustomFactory.Instance.Create(context, "formatter", configurationSource, reflectionCache);
Assert.IsNotNull(formatter);
Assert.AreSame(typeof(MockCustomLogFormatter), formatter.GetType());
Assert.AreEqual("value1", ((MockCustomLogFormatter)formatter).customValue);
}
private ICacheManager CreateEntLibCacheManager()
{
var internalConfigurationSource = new DictionaryConfigurationSource();
var settings = new CacheManagerSettings();
internalConfigurationSource.Add(CacheManagerSettings.SectionName, settings);
var storageConfig = new CacheStorageData("Null Storage", typeof(NullBackingStore));
settings.BackingStores.Add(storageConfig);
var cacheManagerConfig = new CacheManagerData("CustomCache", 60, 1000, 10, storageConfig.Name);
settings.CacheManagers.Add(cacheManagerConfig);
settings.DefaultCacheManager = cacheManagerConfig.Name;
return(new CacheManagerFactory(internalConfigurationSource).CreateDefault());
}
public static void Create()
{
var builder = new ConfigurationSourceBuilder();
builder.ConfigureCaching()
.ForCacheManagerNamed("TestCache")
.UseAsDefaultCache()
.StoreInMemory();
var configSource = new DictionaryConfigurationSource();
builder.UpdateConfigurationWithReplace(configSource);
EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
cacheManager = (CacheManager)EnterpriseLibraryContainer.Current.GetInstance <ICacheManager>("TestCache");
if (!System.IO.File.Exists(dependencyFileName))
{
using (System.IO.File.Create(dependencyFileName)) { }
}
}
public void DatabaseCreatedByProviderFactoryIsASqlCeDatabase()
{
DictionaryConfigurationSource source = new DictionaryConfigurationSource();
DatabaseSettings settings = new DatabaseSettings();
ConnectionStringsSection connSection = GetConnectionStringsSection();
DbProviderMapping providerMapping = GetProviderMapping();
settings.ProviderMappings.Add(providerMapping);
source.Add("dataConfiguration", settings);
source.Add("connectionStrings", connSection);
DatabaseProviderFactory factory = new DatabaseProviderFactory(source);
Database db = factory.Create(instanceName);
Assert.IsNotNull(db);
Assert.AreSame(typeof(SqlCeDatabase), db.GetType());
}
public void ManageabilityProviderGeneratesProperAdmContent()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationObject.Type = typeof(object);
configurationObject.Attributes.Add("name1", "valu;e1");
configurationObject.Attributes.Add("name2", "value2");
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
contentBuilder.StartCategory("category");
contentBuilder.StartPolicy("policy", "policy key");
provider.AddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, "TestApp");
contentBuilder.EndPolicy();
contentBuilder.EndCategory();
MockAdmContent content = contentBuilder.GetMockContent();
IEnumerator <AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator <AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
policiesEnumerator.MoveNext();
IEnumerator <AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmTextPart), partsEnumerator.Current.GetType());
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual(CustomHandlerDataManageabilityProvider.ProviderTypePropertyName,
partsEnumerator.Current.ValueName);
Assert.IsNotNull(partsEnumerator.Current.KeyName);
Assert.AreEqual(typeof(object).AssemblyQualifiedName, ((AdmEditTextPart)partsEnumerator.Current).DefaultValue);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual(CustomHandlerDataManageabilityProvider.AttributesPropertyName,
partsEnumerator.Current.ValueName);
Assert.IsNotNull(partsEnumerator.Current.KeyName);
IDictionary <String, String> attributes = new Dictionary <String, String>();
KeyValuePairParser.ExtractKeyValueEntries(((AdmEditTextPart)partsEnumerator.Current).DefaultValue, attributes);
Assert.AreEqual(2, attributes.Count);
Assert.AreEqual("valu;e1", attributes["name1"]);
Assert.AreEqual("value2", attributes["name2"]);
Assert.IsFalse(partsEnumerator.MoveNext());
}
public void CanCreateValidatorForTypeFromAttributesAndConfigurationWithDefaultRulesetName()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
ValidationSettings settings = new ValidationSettings();
configurationSource.Add(ValidationSettings.SectionName, settings);
ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(TestObjectWithFailingAttributesOnProperties));
settings.Types.Add(typeReference);
typeReference.DefaultRuleset = "RuleA";
ValidationRulesetData ruleData = new ValidationRulesetData("RuleA");
typeReference.Rulesets.Add(ruleData);
ValidatedPropertyReference propertyReference1 = new ValidatedPropertyReference("FailingProperty1");
ruleData.Properties.Add(propertyReference1);
MockValidatorData validator11 = new MockValidatorData("validator1", true);
propertyReference1.Validators.Add(validator11);
validator11.MessageTemplate = "message-from-config1-RuleA";
MockValidatorData validator12 = new MockValidatorData("validator2", true);
propertyReference1.Validators.Add(validator12);
validator12.MessageTemplate = "message-from-config2-RuleA";
MockValidatorData validator13 = new MockValidatorData("validator3", false);
propertyReference1.Validators.Add(validator13);
validator13.MessageTemplate = "message-from-config3-RuleA";
Validator <TestObjectWithFailingAttributesOnProperties> validator
= ValidationFactory.CreateValidator <TestObjectWithFailingAttributesOnProperties>((IConfigurationSource)configurationSource);
ValidationResults validationResults = validator.Validate(new TestObjectWithFailingAttributesOnProperties());
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(4, resultsMapping.Count);
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config1-RuleA"));
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config1-RuleA"));
Assert.IsTrue(resultsMapping.ContainsKey("message1"));
Assert.IsTrue(resultsMapping.ContainsKey("message2"));
}
public void ManageabilityProviderGeneratesProperAdmContent()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
LoggingSettings section = new LoggingSettings();
configurationSource.Add(LoggingSettings.SectionName, section);
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
contentBuilder.StartCategory("category");
provider.AddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, "TestApp");
contentBuilder.EndCategory();
MockAdmContent content = contentBuilder.GetMockContent();
IEnumerator <AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator <AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
Assert.IsTrue(policiesEnumerator.MoveNext());
IEnumerator <AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.IsNull(partsEnumerator.Current.KeyName);
Assert.AreEqual(XmlTraceListenerDataManageabilityProvider.FileNamePropertyName,
partsEnumerator.Current.ValueName);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmDropDownListPart), partsEnumerator.Current.GetType());
Assert.IsNull(partsEnumerator.Current.KeyName);
Assert.AreEqual(XmlTraceListenerDataManageabilityProvider.TraceOutputOptionsPropertyName,
partsEnumerator.Current.ValueName);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmDropDownListPart), partsEnumerator.Current.GetType());
Assert.IsNull(partsEnumerator.Current.KeyName);
Assert.AreEqual(XmlTraceListenerDataManageabilityProvider.FilterPropertyName,
partsEnumerator.Current.ValueName);
Assert.IsFalse(partsEnumerator.MoveNext());
Assert.IsFalse(policiesEnumerator.MoveNext());
}
public static DictionaryConfigurationSource CreateConfigurationSource()
{
DictionaryConfigurationSource source = new DictionaryConfigurationSource();
DatabaseSettings settings = new DatabaseSettings();
settings.DefaultDatabase = "Db2Test";
settings.ProviderMappings.Add(new DbProviderMapping("IBM.Data.DB2.iSeries", "EntLibContrib.Data.IBM.DB2.iSeries.Db2Database, EntLibContrib.Data.IBM.DB2.iSeries, Version=6.0.0.0, Culture=neutral, PublicKeyToken=null"));
Db2ConnectionSettings db2ConnectionSettings = new Db2ConnectionSettings();
Db2ConnectionData data = new Db2ConnectionData();
db2ConnectionSettings.Db2ConnectionsData.Add(data);
source.Add(DatabaseSettings.SectionName, settings);
source.Add(Db2ConnectionSettings.SectionName, db2ConnectionSettings);
return(source);
}
protected override void Initialize()
{
this.WellKnownITypeNameAutoRegistration <ContainerControlledLifetimeManager>(WellKnownAppParts.Manager);
this.Container.RegisterType <IApplicationPrincipal, ThreadApplicationPrincipal>(new ContainerControlledLifetimeManager());
var configurationSource = new DictionaryConfigurationSource();
var builder = new ConfigurationSourceBuilder();
builder.ConfigureCryptography()
.EncryptUsingHashAlgorithmProviderNamed(UserManager.HashInstance)
.WithOptions
.UsingHashAlgorithm <Zetetic.Security.Pbkdf2Hash>()
/*.SetAsDefault()*/; // do not want Pbkdf2Hash (low speed algorithm) to be default
builder.UpdateConfigurationWithReplace(configurationSource);
var configurator = new UnityContainerConfigurator(this.Container);
EnterpriseLibraryContainer.ConfigureContainer(configurator, configurationSource);
}
public void BuildsEmptyExceptionPolicyWithName()
{
DictionaryConfigurationSource emptyConfigSource = new DictionaryConfigurationSource();
ConfigurationSourceBuilder builder = new ConfigurationSourceBuilder();
builder.ConfigureExceptionHandling()
.GivenPolicyWithName("Sample Policy");
builder.UpdateConfigurationWithReplace(emptyConfigSource);
var settings = emptyConfigSource.GetSection(ExceptionHandlingSettings.SectionName) as ExceptionHandlingSettings;
Assert.IsNotNull(settings);
Assert.AreEqual(1, settings.ExceptionPolicies.Count);
var policy = settings.ExceptionPolicies.Get(0);
Assert.AreEqual(0, policy.ExceptionTypes.Count);
}
public void ManageabilityProviderGeneratesProperAdmContent()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
CacheManagerSettings cacheSettings = new CacheManagerSettings();
configurationSource.Add(CacheManagerSettings.SectionName, cacheSettings);
cacheSettings.CacheManagers.Add(new CacheManagerData("manager", 0, 0, 0, "storage"));
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
contentBuilder.StartCategory("category");
provider.InvokeAddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, "TestApp");
contentBuilder.EndCategory();
MockAdmContent content = contentBuilder.GetMockContent();
IEnumerator <AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator <AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
Assert.IsTrue(policiesEnumerator.MoveNext());
Assert.AreEqual(String.Format(Resources.SecurityCacheProviderPolicyNameTemplate, configurationObject.Name),
policiesEnumerator.Current.Name);
IEnumerator <AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmDropDownListPart), partsEnumerator.Current.GetType());
Assert.IsNull(((AdmDropDownListPart)partsEnumerator.Current).KeyName);
Assert.AreEqual(CachingStoreProviderDataManageabilityProvider.CacheManagerPropertyName,
((AdmDropDownListPart)partsEnumerator.Current).ValueName);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmNumericPart), partsEnumerator.Current.GetType());
Assert.IsNull(((AdmNumericPart)partsEnumerator.Current).KeyName);
Assert.AreEqual(CachingStoreProviderDataManageabilityProvider.AbsoluteExpirationPropertyName,
((AdmNumericPart)partsEnumerator.Current).ValueName);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmNumericPart), partsEnumerator.Current.GetType());
Assert.IsNull(((AdmNumericPart)partsEnumerator.Current).KeyName);
Assert.AreEqual(CachingStoreProviderDataManageabilityProvider.SlidingExpirationPropertyName,
((AdmNumericPart)partsEnumerator.Current).ValueName);
Assert.IsFalse(partsEnumerator.MoveNext());
Assert.IsFalse(policiesEnumerator.MoveNext());
}
static InjectionFriendlyRuleDrivenPolicy CreatePolicySetContainingCallHandler(
ValidationCallHandlerData validationCallHandler,
IUnityContainer container)
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("policy");
policyData.MatchingRules.Add(new CustomMatchingRuleData("match everything", typeof(AlwaysMatchingRule)));
policyData.Handlers.Add(validationCallHandler);
settings.Policies.Add(policyData);
DictionaryConfigurationSource dictionaryConfigurationSource = new DictionaryConfigurationSource();
dictionaryConfigurationSource.Add(PolicyInjectionSettings.SectionName, settings);
settings.ConfigureContainer(container, dictionaryConfigurationSource);
return(container.Resolve <InjectionFriendlyRuleDrivenPolicy>("policy"));
}
public void Given()
{
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";
MockValidatorData validator12 = new MockValidatorData("validator2", true);
propertyReference1.Validators.Add(validator12);
validator12.MessageTemplate = "message-from-config2-RuleA";
MockValidatorData validator13 = new MockValidatorData("validator3", false);
propertyReference1.Validators.Add(validator13);
validator13.MessageTemplate = "message-from-config3-RuleA";
ValidationRulesetData ruleDataB = new ValidationRulesetData("RuleB");
typeReference.Rulesets.Add(ruleDataB);
ValidatedPropertyReference propertyReferenceB1 = new ValidatedPropertyReference("Property1");
ruleDataB.Properties.Add(propertyReferenceB1);
MockValidatorData validator21 = new MockValidatorData("validator21", true);
propertyReferenceB1.Validators.Add(validator21);
validator21.MessageTemplate = "message-from-config1-RuleB";
validationFactory = ConfigurationValidatorFactory.FromConfigurationSource(configurationSource);
}
public void MappedDatabaseIsResolvedWhenSetAsDefault()
{
configurationStart.WithProviderNamed(DbProviderMapping.DefaultSqlProviderName)
.MappedToDatabase <SqlDatabase>()
.ForDatabaseNamed(DatabaseName)
.AsDefault()
.ThatIs
.AnotherDatabaseType(DbProviderMapping.DefaultSqlProviderName)
.WithConnectionString(GenericConnectionString);
DictionaryConfigurationSource source = new DictionaryConfigurationSource();
builder.UpdateConfigurationWithReplace(source);
base.ConfigurationSource = source;
// ConfigureContainer();
var database = new DatabaseProviderFactory(base.ConfigurationSource).CreateDefault();
Assert.IsNotNull(database);
Assert.IsInstanceOfType(database, typeof(SqlDatabase));
}
private void ConfigureExceptionHandling()
{
var configurationSource = new DictionaryConfigurationSource();
var builder = new ConfigurationSourceBuilder();
builder.ConfigureExceptionHandling()
.GivenPolicyWithName(DeletePolicy)
.ForExceptionType <Exception>()
.ThenNotifyRethrow()
.ForExceptionType <NHibernate.Exceptions.ConstraintViolationException>()
.WrapWith <DeleteConstraintException>()
.UsingMessage("Cannot delete object.")
.ThenThrowNewException();
builder.UpdateConfigurationWithReplace(configurationSource);
var configurator = new UnityContainerConfigurator(this.Container);
EnterpriseLibraryContainer.ConfigureContainer(configurator, configurationSource);
}
public void CanCreateEmptyPolicy()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(new PolicyData("Policy"));
DictionaryConfigurationSource dictSource = new DictionaryConfigurationSource();
dictSource.Add(PolicyInjectionSettings.SectionName, settings);
PolicySetFactory factory = new PolicySetFactory(dictSource);
PolicySet policySet = factory.Create();
Assert.IsNotNull(policySet);
RuleDrivenPolicy policy = (RuleDrivenPolicy)policySet[1];
Assert.IsNotNull(policy);
Assert.AreEqual("Policy", policy.Name);
}
public void CanBuildCustomSecurityCacheProviderFromGivenConfiguration()
{
CustomSecurityCacheProviderData customData
= new CustomSecurityCacheProviderData("custom", typeof(MockCustomSecurityCacheProvider));
customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
SecuritySettings settings = new SecuritySettings();
settings.SecurityCacheProviders.Add(customData);
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(SecuritySettings.SectionName, settings);
ISecurityCacheProvider custom
= EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource).GetInstance <ISecurityCacheProvider>("custom");
Assert.IsNotNull(custom);
Assert.AreSame(typeof(MockCustomSecurityCacheProvider), custom.GetType());
Assert.AreEqual("value1", ((MockCustomSecurityCacheProvider)custom).customValue);
}
public void Given()
{
configurationSource = new DictionaryConfigurationSource();
var connectionStringsSection = new ConnectionStringsSection();
connectionStringsSection.ConnectionStrings.Add(
new ConnectionStringSettings
{
Name = "sql connection",
ConnectionString = "connection string",
ProviderName = "System.Data.SqlClient"
});
configurationSource.Add("connectionStrings", connectionStringsSection);
configurationSource.Add(
DatabaseSettings.SectionName,
new DatabaseSettings {
DefaultDatabase = "sql connection"
});
settings = new DatabaseSyntheticConfigSettings();
}
public void CanCreatePolicyWithCustomMatchingRule()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(new PolicyData("Policy"));
settings.Policies.Get(0).MatchingRules.Add(new CustomMatchingRuleData("alwaysTrue", typeof(AlwaysMatchingRule)));
DictionaryConfigurationSource dictSource = new DictionaryConfigurationSource();
dictSource.Add(PolicyInjectionSettings.SectionName, settings);
settings.ConfigureContainer(container, dictSource);
InjectionFriendlyRuleDrivenPolicy policy = container.Resolve <InjectionFriendlyRuleDrivenPolicy>("Policy");
List <IMatchingRule> rules = GetRules(policy);
Assert.IsNotNull(policy);
Assert.AreEqual("Policy", policy.Name);
Assert.AreEqual(1, rules.Count);
Assert.AreEqual(typeof(AlwaysMatchingRule), rules[0].GetType());
}
public void ManageabilityProviderGeneratesProperAdmContent()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
contentBuilder.StartCategory("category");
provider.AddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, "TestApp");
contentBuilder.EndCategory();
MockAdmContent content = contentBuilder.GetMockContent();
IEnumerator <AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator <AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
Assert.IsTrue(policiesEnumerator.MoveNext());
IEnumerator <AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsFalse(partsEnumerator.MoveNext());
Assert.IsFalse(policiesEnumerator.MoveNext());
}
protected override void Arrange()
{
base.Arrange();
var builder = new TestConfigurationBuilder();
configSource = new DictionaryConfigurationSource();
builder.AddCachingSettings()
.Build(configSource);
var configurationSourceModel = Container.Resolve <ConfigurationSourceModel>();
var source = new DesignDictionaryConfigurationSource();
source.Add(BlockSectionNames.Caching, CachingConfiguration);
configurationSourceModel.Load(source);
CachingSettingsViewModel =
configurationSourceModel.Sections
.Where(x => x.ConfigurationType == typeof(CacheManagerSettings)).Single();
}
public void CanCreatePolicyWithNamespaceMatchingRule()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(new PolicyData("Policy"));
settings.Policies.Get(0).MatchingRules.Add(new NamespaceMatchingRuleData("RuleName", "namespaceName"));
DictionaryConfigurationSource dictSource = new DictionaryConfigurationSource();
dictSource.Add(PolicyInjectionSettings.SectionName, settings);
settings.ConfigureContainer(container);
RuleDrivenPolicy policy = container.Resolve <RuleDrivenPolicy>("Policy");
List <IMatchingRule> rules = GetRules(policy);
Assert.IsNotNull(policy);
Assert.AreEqual("Policy", policy.Name);
Assert.AreEqual(1, rules.Count);
Assert.AreEqual(typeof(NamespaceMatchingRule), rules[0].GetType());
}
public void InstancesWithNoNameWillBeAttachedToTheirInstrumentationListeners()
{
DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
configSource.Add(InstrumentationConfigurationSection.SectionName,
new InstrumentationConfigurationSection(true, true, true, "fooApplicationInstanceName"));
UnnamedSource source = new UnnamedSource();
BuilderContext context
= new BuilderContext(
new StrategyChain(),
null,
null,
new PolicyList(GetPolicies(configSource)),
NamedTypeBuildKey.Make <UnnamedSource>(),
source);
InstrumentationStrategy strategy = new InstrumentationStrategy();
strategy.PreBuildUp(context);
Assert.IsTrue(((UnnamedSource)context.Existing).IsWired);
}
public static DictionaryConfigurationSource CreateConfigurationSource()
{
DictionaryConfigurationSource source = new DictionaryConfigurationSource();
DatabaseSettings settings = new DatabaseSettings();
settings.DefaultDatabase = "Service_Dflt";
OracleConnectionSettings oracleConnectionSettings = new OracleConnectionSettings();
OracleConnectionData data = new OracleConnectionData();
data.Name = "OracleTest";
data.Packages.Add(new OraclePackageData("TESTPACKAGE", "TESTPACKAGETOTRANSLATE"));
oracleConnectionSettings.OracleConnectionsData.Add(data);
source.Add(DatabaseSettings.SectionName, settings);
source.Add(OracleConnectionSettings.SectionName, oracleConnectionSettings);
return(source);
}
protected override void Arrange()
{
base.Arrange();
ConfigurationSourceBuilder builder = new ConfigurationSourceBuilder();
builder.ConfigureSecurity()
.AuthorizeUsingCustomProviderNamed("custom authz", typeof(IAuthorizationProvider))
.AuthorizeUsingRuleProviderNamed("ruleProvider")
.SpecifyRule("rule1", "true")
.SpecifyRule("rule2", "false")
.CacheSecurityInCacheStoreNamed("cache Storage").WithOptions.UseSharedCacheManager("cache");
DictionaryConfigurationSource source = new DictionaryConfigurationSource();
builder.UpdateConfigurationWithReplace(source);
securitySettings = (SecuritySettings)source.GetSection(SecuritySettings.SectionName);
}
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 CreatedAndCompositeValidatorFromConfigAppropiately()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
ValidationSettings settings = new ValidationSettings();
configurationSource.Add(ValidationSettings.SectionName, settings);
ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(BaseTestDomainObject));
settings.Types.Add(typeReference);
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";
ValidatedPropertyReference propertyReference2 = new ValidatedPropertyReference("Property2");
ruleData.Properties.Add(propertyReference2);
propertyReference2.Validators.Add(validator11);
Validator validator
= ValidationFactory.CreateValidatorFromConfiguration(typeof(BaseTestDomainObject), "RuleA", (IConfigurationSource)configurationSource);
var validatorWrapper = validator as GenericValidatorWrapper <BaseTestDomainObject>;
AndCompositeValidator compositeValidator = validatorWrapper.WrappedValidator as AndCompositeValidator;
Assert.IsNotNull(compositeValidator);
IList <Validator> allValidators = ValidationTestHelper.CreateListFromEnumerable <Validator>(compositeValidator.Validators);
Assert.AreEqual(2, allValidators.Count);
Assert.AreEqual(typeof(ValueAccessValidator), allValidators[0].GetType());
Assert.AreEqual(typeof(ValueAccessValidator), allValidators[1].GetType());
}
public void ManageabilityProviderGeneratesProperAdmContent()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationObject.Type = typeof(object);
configurationObject.Attributes.Add("name1", "valu;e1");
configurationObject.Attributes.Add("name2", "value2");
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
contentBuilder.StartCategory("category");
provider.AddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, "TestApp");
contentBuilder.EndCategory();
MockAdmContent content = contentBuilder.GetMockContent();
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator<AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
Assert.IsTrue(policiesEnumerator.MoveNext());
Assert.AreEqual(configurationObject.Name,
policiesEnumerator.Current.Name);
IEnumerator<AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual(MockCustomProviderDataManageabilityProvider.ProviderTypePropertyName,
partsEnumerator.Current.ValueName);
Assert.IsNull(partsEnumerator.Current.KeyName);
Assert.AreEqual(typeof(object).AssemblyQualifiedName, ((AdmEditTextPart)partsEnumerator.Current).DefaultValue);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual(MockCustomProviderDataManageabilityProvider.AttributesPropertyName,
partsEnumerator.Current.ValueName);
Assert.IsNull(partsEnumerator.Current.KeyName);
IDictionary<String, String> attributes = new Dictionary<String, String>();
KeyValuePairParser.ExtractKeyValueEntries(((AdmEditTextPart)partsEnumerator.Current).DefaultValue, attributes);
Assert.AreEqual(2, attributes.Count);
Assert.AreEqual("valu;e1", attributes["name1"]);
Assert.AreEqual("value2", attributes["name2"]);
Assert.IsFalse(partsEnumerator.MoveNext());
Assert.IsFalse(policiesEnumerator.MoveNext());
}
public static DictionaryConfigurationSource Create()
{
DictionaryConfigurationSource source = new DictionaryConfigurationSource();
source.Add("test", new LocalConfigurationSection());
return source;
}
private DictionaryConfigurationSource BuildConfiguration()
{
var cfg = new DictionaryConfigurationSource();
InitializerHelper.OnConfiguring(cfg);
return cfg;
}
public void ManageabilityProviderGeneratesProperAdmContent()
{
IConfigurationSource configurationSource = new DictionaryConfigurationSource();
section.EventLoggingEnabled = false;
section.PerformanceCountersEnabled = true;
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
provider.AddAdministrativeTemplateDirectives(contentBuilder, section, configurationSource, "TestApp");
}
