public void WhenObjectContainsCyclicReferencesInList_ThenRecursiveDestructureIsImmediatelyStopped() { // Arrange var cyclic = new MyObjectCollection { Foo = "Cyclic", }; cyclic.Reference = cyclic; var exception = new Cyclic2Exception { MyObjectCollection = new MyObjectCollection(), }; exception.MyObjectCollection.Foo = "bar"; exception.MyObjectCollection.Reference = cyclic; // Act var result = new ExceptionPropertiesBag(new Exception()); var destructurer = new ReflectionBasedDestructurer(10); destructurer.Destructure(exception, result, EmptyDestructurer()); // Assert var myObject = (List <object>)result.GetResultDictionary()[nameof(Cyclic2Exception.MyObjectCollection)]; // exception.MyObjectCollection[0] is still list var firstLevelList = Assert.IsType <List <object> >(myObject[0]); // exception.MyObjectCollection[0][0] we notice that we would again destructure "cyclic" var secondLevelList = Assert.IsType <Dictionary <string, object> >(firstLevelList[0]); Assert.Equal("Cyclic reference", secondLevelList["$ref"]); }
public void DestructuringDepthIsLimitedByConfiguredDepth() { // Arrange var exception = new RecursiveException() { Node = new RecursiveNode() { Name = "PARENT", Child = new RecursiveNode() { Name = "CHILD 1", Child = new RecursiveNode() { Name = "CHILD 2", }, }, }, }; var destructurer = new ReflectionBasedDestructurer(1); // Act var propertiesBag = new ExceptionPropertiesBag(exception); destructurer.Destructure(exception, propertiesBag, EmptyDestructurer()); // Assert // Parent is depth 1 // First child is depth 2 var properties = propertiesBag.GetResultDictionary(); var parent = (IDictionary <string, object>)properties[nameof(RecursiveException.Node)]; Assert.Equal("PARENT", parent[nameof(RecursiveNode.Name)]); Assert.IsType <RecursiveNode>(parent[nameof(RecursiveNode.Child)]); }
public void WhenObjectContainsCyclicReferences_ThenNoStackoverflowExceptionIsThrown() { // Arrange var exception = new CyclicException { MyObject = new MyObject(), }; exception.MyObject.Foo = "bar"; exception.MyObject.Reference = exception.MyObject; exception.MyObject.Reference2 = exception.MyObject; // Act var result = new ExceptionPropertiesBag(new Exception()); var destructurer = new ReflectionBasedDestructurer(10); destructurer.Destructure(exception, result, EmptyDestructurer()); // Assert var myObject = (Dictionary <string, object>)result.GetResultDictionary()["MyObject"]; Assert.Equal("bar", myObject["Foo"]); Assert.Equal(myObject["$id"], ((Dictionary <string, object>)myObject["Reference"])["$ref"]); Assert.Equal(myObject["$id"], ((Dictionary <string, object>)myObject["Reference2"])["$ref"]); Assert.Equal("1", myObject["$id"]); }
public void When_object_contains_cyclic_references_in_list_then_recursive_destructure_is_immediately_stopped() { // Arrange var cyclic = new MyObjectEnumerable { Foo = "Cyclic" }; cyclic.Reference = cyclic; var exception = new CyclicException2 { MyObjectEnumerable = new MyObjectEnumerable() }; exception.MyObjectEnumerable.Foo = "bar"; exception.MyObjectEnumerable.Reference = cyclic; // Act var result = new Dictionary <string, object>(); var destructurer = new ReflectionBasedDestructurer(new List <string>()); destructurer.Destructure(exception, result, null); // Assert var myObject = (List <object>)result["MyObjectEnumerable"]; // exception.MyObjectEnumerable[0] is still list var firstLevelList = Assert.IsType <List <object> >(myObject[0]); // exception.MyObjectEnumerable[0][0] we notice that we would again destructure "cyclic" var secondLevelList = Assert.IsType <Dictionary <string, object> >(firstLevelList[0]); Assert.Equal("Cyclic reference", secondLevelList["$ref"]); }
public void When_object_contains_cyclic_references_then_no_stackoverflow_exception_is_thrown() { // Arrange var exception = new CyclicException { MyObject = new MyObject() }; exception.MyObject.Foo = "bar"; exception.MyObject.Reference = exception.MyObject; exception.MyObject.Reference2 = exception.MyObject; // Act var result = new Dictionary <string, object>(); var destructurer = new ReflectionBasedDestructurer(new List <string>()); destructurer.Destructure(exception, result, null); // Assert var myObject = (Dictionary <string, object>)result["MyObject"]; Assert.Equal("bar", myObject["Foo"]); Assert.Equal(myObject["$id"], ((Dictionary <string, object>)myObject["Reference"])["$ref"]); Assert.Equal(myObject["$id"], ((Dictionary <string, object>)myObject["Reference2"])["$ref"]); Assert.Equal("1", myObject["$id"]); }
public void ReflectionBasedDestructurer_MultiplePropertiesCanBeIgnored() { var exception = this.GetException(); var properties = new Dictionary <string, object>(); var localDestructurer = new ReflectionBasedDestructurer(new List <string> { nameof(TestException.Message), nameof(TestException.Source) }); localDestructurer.Destructure(exception, properties, null); Assert.DoesNotContain(properties.Keys, p => p == nameof(TestException.Message)); Assert.DoesNotContain(properties.Keys, p => p == nameof(TestException.Source)); }
public void ReflectionBasedDestructurer_PropertiesCanBeIgnored() { // Arrange var exception = this.GetException(); var properties = new Dictionary <string, object>(); var localDestructurer = new ReflectionBasedDestructurer(new List <string> { nameof(TestException.Source) }); // Act localDestructurer.Destructure(exception, properties, null); // Assert Assert.DoesNotContain(properties, x => string.Equals(x.Key, nameof(TestException.Source))); }
public void ReflectionBasedDestructurer_NestedPropertiesCanBeIgnored() { // Arrange var exception = this.GetException(); var properties = new Dictionary <string, object>(); var localDestructurer = new ReflectionBasedDestructurer(new List <string> { "NestedPropertyKey" }); // Act localDestructurer.Destructure(exception, properties, null); var nestedProperty = properties[nameof(TestException.NestedProperty)]; var nestedPair = (Dictionary <string, object>)nestedProperty; // Assert Assert.NotNull(nestedPair); Assert.Empty(nestedPair); }
public void ReflectionBasedDestructurer_MultipleNestedPropertiesCanBeIgnored() { var exception = this.GetException(); var properties = new Dictionary <string, object>(); var localDestructurer = new ReflectionBasedDestructurer(new List <string> { nameof(TestException.Source), "NestedPropertyKey" }); localDestructurer.Destructure(exception, properties, null); var nestedProperty = properties[nameof(TestException.NestedProperty)]; var nestedPair = (Dictionary <string, object>)nestedProperty; // Assert Assert.NotNull(nestedPair); Assert.Empty(nestedPair); Assert.DoesNotContain(properties.Keys, p => p == nameof(TestException.Source)); }
public void WhenObjectContainsCyclicReferencesInDict_ThenRecursiveDestructureIsImmediatelyStopped() { // Arrange var cyclic = new MyObjectDict { Foo = "Cyclic", Reference = new Dictionary <string, object>(), }; cyclic.Reference["x"] = cyclic.Reference; var exception = new CyclicDictException { MyObjectDict = cyclic, }; // Act var result = new ExceptionPropertiesBag(new Exception()); var destructurer = new ReflectionBasedDestructurer(10); destructurer.Destructure(exception, result, EmptyDestructurer()); // Assert var myObject = (Dictionary <string, object>)result.GetResultDictionary()["MyObjectDict"]; // exception.MyObjectDict["Reference"] is still regular dictionary var firstLevelDict = Assert.IsType <Dictionary <string, object> >(myObject["Reference"]); var id = firstLevelDict["$id"]; Assert.Equal("1", id); // exception.MyObjectDict["Reference"]["x"] we notice that we are destructuring same dictionary var secondLevelDict = Assert.IsType <Dictionary <string, object> >(firstLevelDict["x"]); var refId = Assert.IsType <string>(secondLevelDict["$ref"]); Assert.Equal(id, refId); }
public void When_object_contains_cyclic_references_in_dict_then_recursive_destructure_is_immediately_stopped() { // Arrange var cyclic = new MyObjectDict { Foo = "Cyclic", Reference = new Dictionary <string, object>() }; cyclic.Reference["x"] = cyclic.Reference; var exception = new CyclicExceptionDict { MyObjectDict = cyclic }; // Act var result = new Dictionary <string, object>(); var destructurer = new ReflectionBasedDestructurer(new List <string>()); destructurer.Destructure(exception, result, null); // Assert var myObject = (Dictionary <string, object>)result["MyObjectDict"]; // exception.MyObjectDict["Reference"] is still regular dictionary var firstLevelDict = Assert.IsType <Dictionary <string, object> >(myObject["Reference"]); var id = firstLevelDict["$id"]; Assert.Equal("1", id); // exception.MyObjectDict["Reference"]["x"] we notice that we are destructuring same dictionary var secondLevelDict = Assert.IsType <Dictionary <string, object> >(firstLevelDict["x"]); var refId = Assert.IsType <string>(secondLevelDict["$ref"]); Assert.Equal(id, refId); }
public ReflectionBasedDestructurerTest() { this.destructurer = new ReflectionBasedDestructurer(new List <string>()); }
public ReflectionBasedDestructurerTest() { this.destructurer = new ReflectionBasedDestructurer(); }