public void SetUp()
{
provider = new WrapHandlerDataManageabilityProvider();
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
configurationObject = new WrapHandlerData();
}
public void SetUp()
{
provider = new WrapHandlerDataManageabilityProvider();
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
configurationObject = new WrapHandlerData();
}
public void CanOpenAndSaveWithWrapHandler()
{
System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
ExceptionHandlingSettings settings = (ExceptionHandlingSettings)config.Sections[ExceptionHandlingSettings.SectionName];
WrapHandlerData data = (WrapHandlerData)settings.ExceptionPolicies.Get(wrapPolicy).ExceptionTypes.Get(exceptionType).ExceptionHandlers.Get(wrapHandler);
string oldName = data.Name;
data.Name = newWrapHandler;
config.Save(ConfigurationSaveMode.Full);
ConfigurationManager.RefreshSection(ExceptionHandlingSettings.SectionName);
settings = (ExceptionHandlingSettings)ConfigurationManager.GetSection(ExceptionHandlingSettings.SectionName);
data = (WrapHandlerData)settings.ExceptionPolicies.Get(wrapPolicy).ExceptionTypes.Get(exceptionType).ExceptionHandlers.Get(newWrapHandler);
Assert.IsNotNull(data);
Assert.AreEqual(data.Name, newWrapHandler);
// reset
config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
settings = (ExceptionHandlingSettings)config.Sections[ExceptionHandlingSettings.SectionName];
data = (WrapHandlerData)settings.ExceptionPolicies.Get(wrapPolicy).ExceptionTypes.Get(exceptionType).ExceptionHandlers.Get(newWrapHandler);
data.Name = oldName;
config.Save(ConfigurationSaveMode.Full);
ConfigurationManager.RefreshSection(ExceptionHandlingSettings.SectionName);
}
public void Then_WrapExceptionHandlersHasApproriateMessage()
{
var exceptionTypeData = GetExceptionTypeData();
WrapHandlerData wrapHandler = (WrapHandlerData)exceptionTypeData.ExceptionHandlers.Get(1);
Assert.AreEqual(wrapExceptionMessage, wrapHandler.ExceptionMessage);
}
public void CanGetExceptionMessageFromResource()
{
const string resourceName = "ExceptionMessage";
ExceptionPolicyData exceptionPolicyData = new ExceptionPolicyData("policy");
settings.ExceptionPolicies.Add(exceptionPolicyData);
ExceptionTypeData exceptionTypeData = new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException);
exceptionPolicyData.ExceptionTypes.Add(exceptionTypeData);
WrapHandlerData exceptionHandlerData = new WrapHandlerData("handler1", "wrapped", typeof(ArgumentException).AssemblyQualifiedName);
exceptionHandlerData.ExceptionMessageResourceName = resourceName;
exceptionHandlerData.ExceptionMessageResourceType = typeof(Resources).AssemblyQualifiedName;
string resourceValue = Resources.ExceptionMessage;
exceptionTypeData.ExceptionHandlers.Add(exceptionHandlerData);
container.AddExtension(new ExceptionHandlingBlockExtension());
ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy");
Exception originalException = new Exception("to be wrapped");
try
{
policy.HandleException(originalException);
Assert.Fail("a new exception should have been thrown");
}
catch (ArgumentException e)
{
Assert.AreEqual(resourceValue, e.Message);
Assert.AreSame(originalException, e.InnerException);
}
}
public void CanCreatePolicyWithSimpleExceptionHandler()
{
ExceptionPolicyData exceptionPolicyData = new ExceptionPolicyData("policy");
settings.ExceptionPolicies.Add(exceptionPolicyData);
ExceptionTypeData exceptionTypeData = new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException);
exceptionPolicyData.ExceptionTypes.Add(exceptionTypeData);
ExceptionHandlerData exceptionHandlerData = new WrapHandlerData("handler1", "message",
typeof(ArgumentException).AssemblyQualifiedName);
exceptionTypeData.ExceptionHandlers.Add(exceptionHandlerData);
container.AddExtension(new ExceptionHandlingBlockExtension());
ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy");
try
{
policy.HandleException(new Exception("to be wrapped"));
Assert.Fail("a new exception should have been thrown");
}
catch (ArgumentException e)
{
Assert.AreEqual("message", e.Message);
}
}
public void Then_WrapExceptionTypeIsProvided()
{
var exceptionTypeData = GetExceptionTypeData();
WrapHandlerData wrapHandler = (WrapHandlerData)exceptionTypeData.ExceptionHandlers.Get(1);
Assert.AreEqual(typeof(InvalidCastException), wrapHandler.WrapExceptionType);
}
/// <summary>
/// Initialize a new instance of the <see cref="WrapHandlerNode"/> class with a <see cref="WrapHandlerData"/> instance.
/// </summary>
/// <param name="wrapHandlerData">A <see cref="WrapHandlerData"/> instance</param>
public WrapHandlerNode(WrapHandlerData wrapHandlerData)
{
if (null == wrapHandlerData) throw new ArgumentNullException("wrapHandlerData");
Rename(wrapHandlerData.Name);
this.message = wrapHandlerData.ExceptionMessage;
this.type = wrapHandlerData.WrapExceptionType;
}
public static bool SaveChanges(WrapHandlerSetting wrapHandlerSettingSetting,
ConfigurationElement sourceElement)
{
WrapHandlerData element = (WrapHandlerData)sourceElement;
element.WrapExceptionTypeName = wrapHandlerSettingSetting.WrapExceptionType;
element.ExceptionMessage = wrapHandlerSettingSetting.ExceptionMessage;
return true;
}
public void SetUp()
{
provider = new ConfigurationElementManageabilityProviderWrapper(new WrapHandlerDataManageabilityProvider());
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
wmiSettings = new List <ConfigurationSetting>();
configurationObject = new WrapHandlerData();
}
public void Setup()
{
handlerData = new WrapHandlerData("wrap", "exception", typeof(Exception).AssemblyQualifiedName)
{
ExceptionMessageResourceName = "ExceptionMessage",
ExceptionMessageResourceType = typeof(Resources).AssemblyQualifiedName
};
}
public static void GenerateWmiObjects(WrapHandlerData configurationObject,
ICollection<ConfigurationSetting> wmiSettings)
{
wmiSettings.Add(
new WrapHandlerSetting(configurationObject,
configurationObject.Name,
configurationObject.ExceptionMessage,
configurationObject.WrapExceptionType.AssemblyQualifiedName));
}
public void Then_WrapExceptionHandlersHasApproriateMessage()
{
var exceptionTypeData = GetExceptionTypeData();
WrapHandlerData wrapHandler = (WrapHandlerData)exceptionTypeData.ExceptionHandlers.Get(1);
Assert.AreEqual(wrapExceptionType, wrapHandler.WrapExceptionType);
Assert.AreEqual(wrapMessageResourceName, wrapHandler.ExceptionMessageResourceName);
Assert.AreEqual(wrapMessageResourceType.AssemblyQualifiedName, wrapHandler.ExceptionMessageResourceType);
}
public void CanGetExceptionMessageFromResourceForDifferentLocales()
{
const string resourceName = "ExceptionMessage";
ExceptionPolicyData exceptionPolicyData = new ExceptionPolicyData("policy");
settings.ExceptionPolicies.Add(exceptionPolicyData);
ExceptionTypeData exceptionTypeData = new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException);
exceptionPolicyData.ExceptionTypes.Add(exceptionTypeData);
WrapHandlerData exceptionHandlerData = new WrapHandlerData("handler1", "wrapped", typeof(ArgumentException).AssemblyQualifiedName);
exceptionHandlerData.ExceptionMessageResourceName = resourceName;
exceptionHandlerData.ExceptionMessageResourceType = typeof(Resources).AssemblyQualifiedName;
exceptionTypeData.ExceptionHandlers.Add(exceptionHandlerData);
container.AddExtension(new ExceptionHandlingBlockExtension());
ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy");
Exception originalException = new Exception("to be wrapped");
string enMessage = null;
string esMessage = null;
CultureInfo currentUICulture = CultureInfo.CurrentUICulture;
try
{
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en");
try
{
policy.HandleException(originalException);
Assert.Fail("a new exception should have been thrown");
}
catch (ArgumentException e)
{
Assert.AreEqual(Resources.ExceptionMessage, e.Message);
Assert.AreSame(originalException, e.InnerException);
enMessage = e.Message;
}
Thread.CurrentThread.CurrentUICulture = new CultureInfo("es");
try
{
policy.HandleException(originalException);
Assert.Fail("a new exception should have been thrown");
}
catch (ArgumentException e)
{
Assert.AreEqual(Resources.ExceptionMessage, e.Message);
Assert.AreSame(originalException, e.InnerException);
esMessage = e.Message;
}
Assert.AreNotEqual(enMessage, esMessage);
}
finally
{
Thread.CurrentThread.CurrentUICulture = currentUICulture;
}
}
public ExceptionConfigurationWrapHandlerBuilder(IExceptionConfigurationAddExceptionHandlers context, Type wrappingExceptionType)
: base(context)
{
handlerData = new WrapHandlerData()
{
Name = wrappingExceptionType.FullName,
WrapExceptionType = wrappingExceptionType
};
CurrentExceptionTypeData.ExceptionHandlers.Add(handlerData);
}
protected override void Arrange()
{
var data = new WrapHandlerData
{
Name = ExpectedName,
ExceptionMessage = ExpectedExceptionMessage,
WrapExceptionTypeName = ExpectedExceptionTypeName
};
HandlerData = data;
}
/// <summary>
/// Initialize a new instance of the <see cref="WrapHandlerNode"/> class with a <see cref="WrapHandlerData"/> instance.
/// </summary>
/// <param name="wrapHandlerData">A <see cref="WrapHandlerData"/> instance</param>
public WrapHandlerNode(WrapHandlerData wrapHandlerData)
{
if (null == wrapHandlerData)
{
throw new ArgumentNullException("wrapHandlerData");
}
Rename(wrapHandlerData.Name);
this.message = wrapHandlerData.ExceptionMessage;
this.type = wrapHandlerData.WrapExceptionType;
}
public void WrapHandlerPropertiesTest()
{
WrapHandlerData data = new WrapHandlerData();
string exceptionMessage = "test message";
string wrapExceptionTypeName = "System.Exception, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
data.ExceptionMessage = exceptionMessage;
data.WrapExceptionTypeName = wrapExceptionTypeName;
Assert.AreEqual(exceptionMessage, data.ExceptionMessage);
Assert.AreEqual(wrapExceptionTypeName, data.WrapExceptionTypeName);
}
/// <summary>
/// <para>Initializes the provider with a <see cref="ExceptionHandlingConfigurationView"/>.</para>
/// </summary>
/// <param name="configurationView">
/// <para>A <see cref="ExceptionHandlingConfigurationView"/> object.</para>
/// </param>
public override void Initialize(ConfigurationView configurationView)
{
ArgumentValidation.CheckForNullReference(configurationView, "configurationView");
ArgumentValidation.CheckExpectedType(configurationView, typeof(ExceptionHandlingConfigurationView));
ExceptionHandlingConfigurationView exceptionHandlingConfigurationView = (ExceptionHandlingConfigurationView)configurationView;
ExceptionHandlerData exceptionHandlerData = exceptionHandlingConfigurationView.GetExceptionHandlerData(CurrentPolicyName, CurrentExceptionTypeName, ConfigurationName);
ArgumentValidation.CheckExpectedType(exceptionHandlerData, typeof(WrapHandlerData));
wrapHandlerData = (WrapHandlerData)exceptionHandlerData;
}
public void SavesChangesToConfigurationObject()
{
WrapHandlerData sourceElement = new WrapHandlerData("name",
"ExceptionMessage",
"System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
List <ConfigurationSetting> settings = new List <ConfigurationSetting>(1);
WrapHandlerDataWmiMapper.GenerateWmiObjects(sourceElement, settings);
Assert.AreEqual(1, settings.Count);
WrapHandlerSetting setting = settings[0] as WrapHandlerSetting;
Assert.IsNotNull(setting);
setting.Commit();
Assert.AreEqual(setting.ExceptionMessage, sourceElement.ExceptionMessage);
Assert.AreEqual(setting.WrapExceptionType, sourceElement.WrapExceptionTypeName);
}
public void WrapHandlerGetDataTest()
{
WrapHandlerData data = new WrapHandlerData();
string wrapExceptionTypeName = "System.ArgumentException, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
string name = "WrapHandler";
data.WrapExceptionTypeName = wrapExceptionTypeName;
data.Name = name;
WrapHandlerNode node = new WrapHandlerNode(data);
CreateHierarchyAndAddToHierarchyService(node, CreateDefaultConfiguration());
WrapHandlerData nodeData = (WrapHandlerData)node.ExceptionHandlerData;
Assert.IsNull(nodeData.ExceptionMessage);
Assert.AreEqual(wrapExceptionTypeName, nodeData.WrapExceptionTypeName);
Assert.AreEqual(name, nodeData.Name);
}
public void PoliciesForExceptionPoliciesCanHandleRepeatedTypesWithRepeatedHandlers()
{
ExceptionPolicyData exceptionPolicy1Data = new ExceptionPolicyData("policy1");
settings.ExceptionPolicies.Add(exceptionPolicy1Data);
ExceptionTypeData exceptionTypeData11
= new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException);
exceptionPolicy1Data.ExceptionTypes.Add(exceptionTypeData11);
ExceptionHandlerData exceptionHandlerData11 = new WrapHandlerData("handler1", "message1",
typeof(ArgumentException).AssemblyQualifiedName);
exceptionTypeData11.ExceptionHandlers.Add(exceptionHandlerData11);
ExceptionPolicyData exceptionPolicy2Data = new ExceptionPolicyData("policy2");
settings.ExceptionPolicies.Add(exceptionPolicy2Data);
ExceptionTypeData exceptionTypeData21
= new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException);
exceptionPolicy2Data.ExceptionTypes.Add(exceptionTypeData21);
ExceptionHandlerData exceptionHandlerData21 = new WrapHandlerData("handler1", "message2",
typeof(ArgumentException).AssemblyQualifiedName);
exceptionTypeData21.ExceptionHandlers.Add(exceptionHandlerData21);
using (var container = new UnityContainer().AddExtension(new EnterpriseLibraryCoreExtension(configurationSource)))
{
ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy1");
try
{
policy.HandleException(new Exception("to be wrapped"));
Assert.Fail("a new exception should have been thrown");
}
catch (ArgumentException e)
{
Assert.AreEqual("message1", e.Message, "Policy 1 is using the handler definitions from policy 2");
}
}
}
void IContainerPolicyCreator.CreatePolicies(
IPolicyList policyList,
string instanceName,
ConfigurationElement configurationObject,
IConfigurationSource configurationSource)
{
WrapHandlerData castConfigurationObject = (WrapHandlerData)configurationObject;
new PolicyBuilder <WrapHandler, WrapHandlerData>(
NamedTypeBuildKey.Make <WrapHandler>(instanceName),
castConfigurationObject,
c => new WrapHandler(
new ResourceStringResolver(
c.ExceptionMessageResourceType,
c.ExceptionMessageResourceName,
c.ExceptionMessage),
c.WrapExceptionType))
.AddPoliciesToPolicyList(policyList);
}
public void WrapHandlerNodeDataTest()
{
string name = "some name";
string message = "some message";
Type wrapExceptionType = typeof(ApplicationException);
WrapHandlerData wrapHandlerData = new WrapHandlerData();
wrapHandlerData.Name = name;
wrapHandlerData.ExceptionMessage = message;
wrapHandlerData.WrapExceptionType = wrapExceptionType;
WrapHandlerNode wrapHandlerNode = new WrapHandlerNode(wrapHandlerData);
WrapHandlerData nodeData = (WrapHandlerData)wrapHandlerNode.ExceptionHandlerData;
Assert.AreEqual(name, nodeData.Name);
Assert.AreEqual(message, nodeData.ExceptionMessage);
Assert.AreEqual(wrapExceptionType, nodeData.WrapExceptionType);
}
public void WrapHandlerDataTest()
{
string name = "some name";
string message = "some message";
Type exceptionType = typeof(AppDomainUnloadedException);
Type wrapExceptionType = typeof(ApplicationException);
WrapHandlerData data = new WrapHandlerData();
data.Name = name;
data.ExceptionMessage = message;
data.Type = exceptionType;
data.WrapExceptionType = wrapExceptionType;
WrapHandlerNode node = new WrapHandlerNode(data);
Assert.AreEqual(name, node.Name);
Assert.AreEqual(message, node.ExceptionMessage);
Assert.AreEqual(wrapExceptionType, node.WrapExceptionType);
}
public void WrapperHandlerCanGetExceptionMessageFromResource()
{
const string resourceName = "ExceptionMessage";
ExceptionPolicyData exceptionPolicyData = new ExceptionPolicyData("policy");
settings.ExceptionPolicies.Add(exceptionPolicyData);
ExceptionTypeData exceptionTypeData = new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException);
exceptionPolicyData.ExceptionTypes.Add(exceptionTypeData);
WrapHandlerData exceptionHandlerData = new WrapHandlerData("handler1", "message",
typeof(ArgumentException).AssemblyQualifiedName);
exceptionHandlerData.ExceptionMessageResourceName = resourceName;
exceptionHandlerData.ExceptionMessageResourceType = typeof(Resources).AssemblyQualifiedName;
string resourceValue = Resources.ExceptionMessage;
exceptionTypeData.ExceptionHandlers.Add(exceptionHandlerData);
using (var container = new UnityContainer().AddExtension(new EnterpriseLibraryCoreExtension(configurationSource)))
{
ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy");
try
{
policy.HandleException(new Exception("to be wrapped"));
Assert.Fail("a new exception should have been thrown");
}
catch (ArgumentException e)
{
Assert.AreEqual(resourceValue, e.Message);
}
}
}
/// <summary>
/// Constructs the node with config data.
/// </summary>
/// <param name="wrapHandlerData">The config data to initialize this node.</param>
public WrapHandlerNode(WrapHandlerData wrapHandlerData) : base(wrapHandlerData)
{
this.wrapHandlerData = wrapHandlerData;
}
public void WrapHandlerGetDataTest()
{
WrapHandlerData data = new WrapHandlerData();
string wrapExceptionTypeName = "System.ArgumentException, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
string name = "WrapHandler";
data.WrapExceptionTypeName = wrapExceptionTypeName;
data.Name = name;
WrapHandlerNode node = new WrapHandlerNode(data);
CreateHierarchyAndAddToHierarchyService(node, CreateDefaultConfiguration());
WrapHandlerData nodeData = (WrapHandlerData) node.ExceptionHandlerData;
Assert.IsNull(nodeData.ExceptionMessage);
Assert.AreEqual(wrapExceptionTypeName, nodeData.WrapExceptionTypeName);
Assert.AreEqual(name, nodeData.Name);
}
public void WrapHandlerPropertiesTest()
{
WrapHandlerData data = new WrapHandlerData();
string exceptionMessage = "test message";
string wrapExceptionTypeName = "System.Exception, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
data.ExceptionMessage = exceptionMessage;
data.WrapExceptionTypeName = wrapExceptionTypeName;
Assert.AreEqual(exceptionMessage, data.ExceptionMessage);
Assert.AreEqual(wrapExceptionTypeName, data.WrapExceptionTypeName);
}
public void Setup()
{
handlerData = new WrapHandlerData("wrap", "exception", typeof(Exception).AssemblyQualifiedName);
}
/// <summary>
/// Constructs the node with config data.
/// </summary>
/// <param name="wrapHandlerData">The config data to initialize this node.</param>
public WrapHandlerNode(WrapHandlerData wrapHandlerData)
: base(wrapHandlerData)
{
this.wrapHandlerData = wrapHandlerData;
}
public void Setup()
{
handlerData = new WrapHandlerData("wrap", "exception", typeof(Exception).AssemblyQualifiedName);
}
public void Setup()
{
handlerData = new WrapHandlerData("wrap", "exception", typeof(Exception).AssemblyQualifiedName)
{
ExceptionMessageResourceName = "ExceptionMessage",
ExceptionMessageResourceType = typeof(Resources).AssemblyQualifiedName
};
}
