public void CanReadAndWriteLoggingHandler() { ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap(); fileMap.ExeConfigFilename = "test.exe.config"; SysConfig.Configuration config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); config.Sections.Remove(ExceptionHandlingSettings.SectionName); config.Sections.Add(ExceptionHandlingSettings.SectionName, CreateSettings()); config.Save(ConfigurationSaveMode.Full); config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); ExceptionHandlingSettings settings = (ExceptionHandlingSettings)config.Sections[ExceptionHandlingSettings.SectionName]; FaultContractExceptionHandlerData data = (FaultContractExceptionHandlerData)settings.ExceptionPolicies.Get("test").ExceptionTypes.Get("test").ExceptionHandlers.Get("test"); config.Sections.Remove(ExceptionHandlingSettings.SectionName); config.Save(ConfigurationSaveMode.Full); Assert.AreEqual("test", data.Name); Assert.AreEqual(typeof(object).AssemblyQualifiedName, data.FaultContractType); Assert.AreEqual("my exception message", data.ExceptionMessage); Assert.AreEqual(2, data.PropertyMappings.Count); Assert.AreEqual("source1", data.PropertyMappings.Get("property1").Source); Assert.AreEqual("source2", data.PropertyMappings.Get("property2").Source); }
public void SetUp() { provider = new FaultContractExceptionHandlerDataManageabilityProvider(); machineKey = new MockRegistryKey(true); userKey = new MockRegistryKey(true); configurationObject = new FaultContractExceptionHandlerData(); }
public void CanCreatePoliciesForHandler() { ExceptionPolicyData exceptionPolicyData = new ExceptionPolicyData("policy"); settings.ExceptionPolicies.Add(exceptionPolicyData); ExceptionTypeData exceptionTypeData = new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException); exceptionPolicyData.ExceptionTypes.Add(exceptionTypeData); FaultContractExceptionHandlerData exceptionHandlerData = new FaultContractExceptionHandlerData("handler1", typeof(MockFaultContract).AssemblyQualifiedName); exceptionHandlerData.ExceptionMessage = "fault message"; exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("Message", "{Message}")); exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("Data", "{Data}")); exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("SomeNumber", "{OffendingNumber}")); exceptionTypeData.ExceptionHandlers.Add(exceptionHandlerData); container.AddExtension(new ExceptionHandlingBlockExtension()); ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy"); NotFiniteNumberException originalException = new NotFiniteNumberException("MyException", 12341234123412); originalException.Data.Add("someKey", "someValue"); try { policy.HandleException(originalException); Assert.Fail("a new exception should have been thrown"); } catch (FaultContractWrapperException e) { MockFaultContract fault = (MockFaultContract)e.FaultContract; Assert.AreEqual(originalException.Message, fault.Message); Assert.AreEqual(originalException.Data.Count, fault.Data.Count); Assert.AreEqual(originalException.Data["someKey"], fault.Data["someKey"]); Assert.AreEqual(originalException.OffendingNumber, fault.SomeNumber); } }
public void NodeCreatesValidatorDataWithValues() { FaultContractExceptionHandlerNode node = new FaultContractExceptionHandlerNode(); node.Name = "faultContract"; node.FaultContractType = typeof(object).AssemblyQualifiedName; node.ExceptionMessage = "my exception message"; FaultContractPropertyMapping mapping1 = new FaultContractPropertyMapping(); mapping1.Name = "property1"; mapping1.Source = "source1"; node.PropertyMappings.Add(mapping1); FaultContractPropertyMapping mapping2 = new FaultContractPropertyMapping(); mapping2.Name = "property2"; mapping2.Source = "source2"; node.PropertyMappings.Add(mapping2); FaultContractExceptionHandlerData data = node.ExceptionHandlerData as FaultContractExceptionHandlerData; Assert.IsNotNull(data); Assert.AreEqual("faultContract", data.Name); Assert.AreEqual(typeof(object).AssemblyQualifiedName, data.FaultContractType); Assert.AreEqual("my exception message", data.ExceptionMessage); Assert.AreEqual(2, data.PropertyMappings.Count); Assert.AreEqual("source1", data.PropertyMappings.Get("property1").Source); Assert.AreEqual("source2", data.PropertyMappings.Get("property2").Source); }
public void ShouldReturnTypeRegistration() { var handlerData = new FaultContractExceptionHandlerData("name", typeof(object).AssemblyQualifiedName) { ExceptionMessage = "message" }; handlerData.Attributes["foo"] = "bar"; var registration = handlerData.GetRegistrations("prefix").First(); registration .AssertForServiceType(typeof(IExceptionHandler)) .ForName("prefix.name") .ForImplementationType(typeof(FaultContractExceptionHandler)); NameValueCollection attributes; IStringResolver resolver; registration .AssertConstructor() .WithValueConstructorParameter(out resolver) .WithValueConstructorParameter(typeof(object)) .WithValueConstructorParameter(out attributes) .VerifyConstructorParameters(); CollectionAssert.AreEquivalent(handlerData.Attributes, attributes); }
protected override void Arrange() { configuration = new FaultContractExceptionHandlerData("wcf") { ExceptionMessage = ErrorMessage }; }
protected override void Arrange() { configuration = new FaultContractExceptionHandlerData("wcf", typeof(MockFaultContract).AssemblyQualifiedName) { ExceptionMessage = ErrorMessage }; }
public void SetUp() { provider = new FaultContractExceptionHandlerDataManageabilityProvider(); machineKey = new MockRegistryKey(true); userKey = new MockRegistryKey(true); configurationObject = new FaultContractExceptionHandlerData(); }
protected override void Arrange() { configuration = new FaultContractExceptionHandlerData("wcf", typeof(MockFaultContract).AssemblyQualifiedName) { ExceptionMessageResourceName = "WcfMessageResource", ExceptionMessageResourceType = typeof(Resources).AssemblyQualifiedName }; }
public void SetUp() { provider = new ConfigurationElementManageabilityProviderWrapper(new FaultContractExceptionHandlerDataManageabilityProvider()); machineKey = new MockRegistryKey(true); userKey = new MockRegistryKey(true); wmiSettings = new List <ConfigurationSetting>(); configurationObject = new FaultContractExceptionHandlerData(); }
public static void GenerateWmiObjects(FaultContractExceptionHandlerData configurationObject, ICollection <ConfigurationSetting> wmiSettings) { string[] attributesArray = GenerateAttributesArray(configurationObject.Attributes); wmiSettings.Add( new FaultContractExceptionHandlerSetting(configurationObject, configurationObject.Name, configurationObject.ExceptionMessage, configurationObject.FaultContractType, attributesArray)); }
public ExceptionConfigurationLoggingProviderBuilder(IExceptionConfigurationForExceptionTypeOrPostHandling context, Type faultContractType, string faultContractMessage) : base(context) { shieldingHandling = new FaultContractExceptionHandlerData { Name = faultContractType.FullName, FaultContractType = faultContractType.AssemblyQualifiedName, ExceptionMessage = faultContractMessage }; base.CurrentExceptionTypeData.ExceptionHandlers.Add(shieldingHandling); }
public static bool SaveChanges(FaultContractExceptionHandlerSetting faultContractExceptionHandlerSetting, ConfigurationElement sourceElement) { FaultContractExceptionHandlerData element = (FaultContractExceptionHandlerData)sourceElement; element.Attributes.Clear(); element.ExceptionMessage = faultContractExceptionHandlerSetting.ExceptionMessage; element.FaultContractType = faultContractExceptionHandlerSetting.FaultContractType; foreach (string attribute in faultContractExceptionHandlerSetting.Attributes) { string[] splittedAttribute = attribute.Split('='); element.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData(splittedAttribute[0], splittedAttribute[1])); } return(true); }
public void CreatedNodeWithValidatorDataHasAppropriateValuesFromData() { FaultContractExceptionHandlerData data = new FaultContractExceptionHandlerData("name"); data.FaultContractType = typeof(object).AssemblyQualifiedName; data.ExceptionMessage = "my exception message"; data.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("property", "source")); FaultContractExceptionHandlerNode node = new FaultContractExceptionHandlerNode(data); Assert.AreEqual(typeof(object).AssemblyQualifiedName, node.FaultContractType); Assert.AreEqual("my exception message", node.ExceptionMessage); Assert.AreEqual(1, node.PropertyMappings.Count); Assert.AreEqual("property", node.PropertyMappings[0].Name); Assert.AreEqual("source", node.PropertyMappings[0].Source); }
void IContainerPolicyCreator.CreatePolicies( IPolicyList policyList, string instanceName, ConfigurationElement configurationObject, IConfigurationSource configurationSource) { FaultContractExceptionHandlerData castConfigurationObject = (FaultContractExceptionHandlerData)configurationObject; new PolicyBuilder <FaultContractExceptionHandler, FaultContractExceptionHandlerData>( NamedTypeBuildKey.Make <FaultContractExceptionHandler>(instanceName), castConfigurationObject, c => new FaultContractExceptionHandler( Type.GetType(castConfigurationObject.FaultContractType), castConfigurationObject.ExceptionMessage, castConfigurationObject.Attributes)) .AddPoliciesToPolicyList(policyList); }
/// <summary> /// Initialize a new instance of the <see cref="FaultContractExceptionHandlerNode"/> class with a <see cref="Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.WCF.Configuration.FaultContractExceptionHandlerData"/> instance. /// </summary> /// <param name="data">A <see cref="Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.WCF.Configuration.FaultContractExceptionHandlerData"/> instance</param> public FaultContractExceptionHandlerNode(FaultContractExceptionHandlerData data) { if (null == data) { throw new ArgumentNullException("data"); } Rename(data.Name); this.faultContractType = data.FaultContractType; this.exceptionMessage = data.ExceptionMessage; foreach (FaultContractExceptionHandlerMappingData mappingData in data.PropertyMappings) { FaultContractPropertyMapping mapping = new FaultContractPropertyMapping(); mapping.Name = mappingData.Name; mapping.Source = mappingData.Source; this.PropertyMappings.Add(mapping); } }
static ExceptionHandlingSettings CreateSettings() { FaultContractExceptionHandlerData logData = new FaultContractExceptionHandlerData("test"); logData.FaultContractType = typeof(object).AssemblyQualifiedName; logData.ExceptionMessage = "my exception message"; logData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("property1", "source1")); logData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("property2", "source2")); ExceptionTypeData typeData = new ExceptionTypeData("test", typeof(Exception), PostHandlingAction.None); typeData.ExceptionHandlers.Add(logData); ExceptionPolicyData policy = new ExceptionPolicyData("test"); policy.ExceptionTypes.Add(typeData); ExceptionHandlingSettings settings = new ExceptionHandlingSettings(); settings.ExceptionPolicies.Add(policy); return(settings); }
public void SavesChangesToConfigurationObject() { FaultContractExceptionHandlerData sourceElement = new FaultContractExceptionHandlerData("name", "System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"); sourceElement.Attributes.Add("att3", "val3"); sourceElement.Attributes.Add("att4", "val4"); sourceElement.Attributes.Add("att5", "val5"); List <ConfigurationSetting> settings = new List <ConfigurationSetting>(1); FaultContractExceptionHandlerDataWmiMapper.GenerateWmiObjects(sourceElement, settings); Assert.AreEqual(1, settings.Count); FaultContractExceptionHandlerSetting setting = settings[0] as FaultContractExceptionHandlerSetting; Assert.IsNotNull(setting); setting.Attributes = new string[] { "att1=val1", "att2=val2" }; setting.Commit(); Assert.AreEqual(2, sourceElement.Attributes.Count); Assert.AreEqual("val1", sourceElement.Attributes["att1"]); Assert.AreEqual("val2", sourceElement.Attributes["att2"]); }
protected override void Arrange() { configuration = new FaultContractExceptionHandlerData(); }
protected override void Arrange() { this.configuration = new FaultContractExceptionHandlerData("wcf", typeof(MockFaultContract).AssemblyQualifiedName); }