public void AddedProperty_WhenFilterIsNotSetToIgnoreIt_IsIncluded()
        {
            // Arrange
            var properties = new ExceptionPropertiesBag(
                new Exception(),
                new IgnorePropertyByNameExceptionFilter(new[] { "not key" }));

            // Act
            properties.AddProperty("key", "value");

            // Assert
            var results = properties.GetResultDictionary();

            Assert.Equal(1, results.Count);
            Assert.Contains("key", results.Keys);
            var value = results["key"];

            Assert.Equal("value", value);
        }
Example #2
0
        private static void Test_ResultOfReflectionDestructurerShouldBeEquivalentToCustomOne(
            Exception exception,
            IExceptionDestructurer customDestructurer)
        {
            // Arrange
            var reflectionBasedResult       = new ExceptionPropertiesBag(exception);
            var customBasedResult           = new ExceptionPropertiesBag(exception);
            var reflectionBasedDestructurer = CreateReflectionBasedDestructurer();

            // Act
            reflectionBasedDestructurer.Destructure(exception, reflectionBasedResult, InnerDestructurer(reflectionBasedDestructurer));
            customDestructurer.Destructure(exception, customBasedResult, InnerDestructurer(new ArgumentExceptionDestructurer()));

            // Assert
            var reflectionBasedDictionary = (Dictionary <string, object>)reflectionBasedResult.GetResultDictionary();
            var customBasedDictionary     = (Dictionary <string, object>)customBasedResult.GetResultDictionary();

            reflectionBasedDictionary.Should().BeEquivalentTo(customBasedDictionary);
        }
        public void CanDestructureObjectWithHiddenProperty()
        {
            var derived = new DerivedClass <int>
            {
                HiddenProperty = 123,
            };
            var baseClass = (BaseClass)derived;

            baseClass.HiddenProperty = 456;
            var exception = new HiddenException("test", derived);

            var propertiesBag = new ExceptionPropertiesBag(exception);

            CreateReflectionBasedDestructurer().Destructure(exception, propertiesBag, EmptyDestructurer());

            var properties = propertiesBag.GetResultDictionary();
            var info       = properties[nameof(HiddenException.Info)] as IDictionary <string, object>;

            Assert.Equal(derived.HiddenProperty, info[nameof(DerivedClass <object> .HiddenProperty)]);
            Assert.Equal(baseClass.HiddenProperty, info[$"{typeof(BaseClass).FullName}.{nameof(BaseClass.HiddenProperty)}"]);
        }
        public void CanDestructureUriDataItem()
        {
            const string uriValue  = "http://localhost/data-item";
            var          exception = new Exception("test")
            {
                Data =
                {
                    { "UriDataItem", new Uri(uriValue) },
                },
            };

            var propertiesBag = new ExceptionPropertiesBag(exception);

            CreateReflectionBasedDestructurer().Destructure(exception, propertiesBag, EmptyDestructurer());

            var properties   = propertiesBag.GetResultDictionary();
            var data         = (IDictionary)properties[nameof(Exception.Data)];
            var uriDataValue = data["UriDataItem"];

            Assert.IsType <string>(uriDataValue);
            Assert.Equal(uriValue, uriDataValue);
        }
        public void CanDestructureStructDataItem()
        {
            // Arrange
            var exception = new Exception("test");

            exception.Data["data"] = new TestStruct()
            {
                ValueType     = 10,
                ReferenceType = "ABC",
            };
            var propertiesBag = new ExceptionPropertiesBag(exception);

            // Act
            CreateReflectionBasedDestructurer().Destructure(exception, propertiesBag, EmptyDestructurer());

            // Assert
            var properties          = propertiesBag.GetResultDictionary();
            var data                = (IDictionary)properties[nameof(Exception.Data)];
            var testStructDataValue = data["data"];

            Assert.IsAssignableFrom <TestStruct>(testStructDataValue);
        }
Example #6
0
        public void CanDestructureTask()
        {
            Task task      = new TaskFactory <int>().StartNew(() => 12, TaskCreationOptions.LongRunning | TaskCreationOptions.PreferFairness);
            var  exception = new TaskCanceledException(task);

            var propertiesBag = new ExceptionPropertiesBag(exception);

            CreateReflectionBasedDestructurer().Destructure(exception, propertiesBag, EmptyDestructurer());

            var properties                 = propertiesBag.GetResultDictionary();
            var destructuredTaskObject     = (IDictionary)properties[nameof(TaskCanceledException.Task)];
            var destructuredTaskProperties = Assert.IsAssignableFrom <IDictionary <string, object> >(destructuredTaskObject);

            destructuredTaskProperties.Should().ContainKey(nameof(Task.Id));
            destructuredTaskProperties.Should().ContainKey(nameof(Task.Status))
            .WhichValue.Should().BeOfType <string>()
            .Which.Should().Be(nameof(TaskStatus.RanToCompletion));
            destructuredTaskProperties.Should().ContainKey(nameof(Task.CreationOptions))
            .WhichValue.Should().BeOfType <string>()
            .Which.Should().Contain(nameof(TaskCreationOptions.LongRunning))
            .And.Contain(nameof(TaskCreationOptions.PreferFairness));
        }
        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 CanDestructureClassDataItem()
        {
            // Arrange
            var exception = new Exception("test");

            exception.Data["data"] = new TestClass()
            {
                ValueType     = 10,
                ReferenceType = "ABC",
            };
            var propertiesBag = new ExceptionPropertiesBag(exception);

            // Act
            CreateReflectionBasedDestructurer().Destructure(exception, propertiesBag, EmptyDestructurer());

            // Assert
            var properties                   = propertiesBag.GetResultDictionary();
            var data                         = (IDictionary)properties[nameof(Exception.Data)];
            var testStructDataValue          = data["data"];
            var destructuredStructDictionary = Assert.IsAssignableFrom <IDictionary <string, object> >(testStructDataValue);

            Assert.Equal(10, destructuredStructDictionary[nameof(TestClass.ValueType)]);
            Assert.Equal("ABC", destructuredStructDictionary[nameof(TestClass.ReferenceType)]);
        }
        public void CanDestructureFaultedTask()
        {
            var taskException = new Exception("INNER EXCEPTION MESSAGE");
            var task          = Task.FromException(taskException);
            var exception     = new TaskException("TASK EXCEPTION MESSAGE", task);

            var propertiesBag = new ExceptionPropertiesBag(exception);

            CreateReflectionBasedDestructurer().Destructure(exception, propertiesBag, InnerDestructurer(CreateReflectionBasedDestructurer()));

            var properties                 = propertiesBag.GetResultDictionary();
            var destructuredTaskObject     = (IDictionary)properties[nameof(TaskCanceledException.Task)];
            var destructuredTaskProperties = Assert.IsAssignableFrom <IDictionary <string, object> >(destructuredTaskObject);

            destructuredTaskProperties.Should().ContainKey(nameof(Task.Id));
            destructuredTaskProperties.Should().ContainKey(nameof(Task.Status))
            .WhichValue.Should().BeOfType <string>()
            .Which.Should().Be(nameof(TaskStatus.Faulted));
            destructuredTaskProperties.Should().ContainKey(nameof(Task.CreationOptions))
            .WhichValue.Should().BeOfType <string>()
            .Which.Should().Be(nameof(TaskCreationOptions.None));
            var taskFirstLevelExceptionDictionary = destructuredTaskProperties.Should().ContainKey(nameof(Task.Exception))
                                                    .WhichValue.Should().BeAssignableTo <IDictionary <string, object> >()
                                                    .Which;

            taskFirstLevelExceptionDictionary.Should().ContainKey("Message")
            .WhichValue.Should().BeOfType <string>()
            .Which.Should().Contain("One or more errors occurred.", "task's first level exception is aggregate exception");
            taskFirstLevelExceptionDictionary.Should().ContainKey("InnerExceptions")
            .WhichValue.Should().BeAssignableTo <IReadOnlyCollection <object> >()
            .Which.Should().ContainSingle()
            .Which.Should().BeAssignableTo <IDictionary <string, object> >()
            .Which.Should().ContainKey("Message")
            .WhichValue.Should().BeOfType <string>()
            .Which.Should().Be("INNER EXCEPTION MESSAGE");
        }