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);
}
