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 Setup() { handlerData = new WrapHandlerData("wrap", "exception", typeof(Exception).AssemblyQualifiedName); }