Beispiel #1
0
        public void it_should_map_failed_example()
        {
            var someError = new DummyTestException();

            var someExample = new ExecutedExample()
            {
                FullName            = "nspec. some context. some failing example.",
                Pending             = false,
                Failed              = true,
                ExceptionMessage    = someError.Message,
                ExceptionStackTrace = someError.StackTrace,
            };

            var someTestCase = BuildTestCase(someExample);

            var expected = new TestResult(someTestCase)
            {
                Outcome         = TestOutcome.Failed,
                ErrorMessage    = someError.Message,
                ErrorStackTrace = someError.StackTrace,
            };

            var actual = mapper.FromExecutedExample(someExample, somePath);

            actual.ShouldBeEquivalentTo(expected, TestResultMatchingOptions);
        }
Beispiel #2
0
        public override void before_each()
        {
            base.before_each();

            expectedEx = new DummyTestException();

            remoteRunner
            .Run(somePath,
                 Arg.Any <Func <IProxyableTestExecutor, int> >(),
                 Arg.Any <Func <Exception, string, int> >())
            .Returns(callInfo =>
            {
                var path = callInfo.Arg <string>();
                var fail = callInfo.Arg <Func <Exception, string, int> >();

                return(fail(expectedEx, path));
            });
        }
Beispiel #3
0
        public override void before_each()
        {
            base.before_each();

            expectedEx = new DummyTestException();

            remoteRunner
            .Run(somePath,
                 Arg.Any <Func <IProxyableTestDiscoverer, DiscoveredExample[]> >(),
                 Arg.Any <Func <Exception, string, DiscoveredExample[]> >())
            .Returns(callInfo =>
            {
                var path = callInfo.Arg <string>();
                var fail = callInfo.Arg <Func <Exception, string, DiscoveredExample[]> >();

                return(fail(expectedEx, path));
            });

            actuals = discoverer.Discover(somePath, logger, crossDomainLogger);
        }
        public void it_should_map_failed_example()
        {
            var someError = new DummyTestException();

            var someExample = new Example("some failed example", tagText, someAction, false)
            {
                Context   = someContext,
                HasRun    = true,
                Exception = someError,
            };

            var expected = new ExecutedExample()
            {
                FullName            = someExample.FullName(),
                Failed              = true,
                ExceptionMessage    = someError.Message,
                ExceptionStackTrace = someError.StackTrace,
            };

            var actual = mapper.FromExample(someExample);

            actual.ShouldBeEquivalentTo(expected);
        }
        public override void before_each()
        {
            base.before_each();

            expectedEx = new DummyTestException("This is supposed to fail");
        }