public void ResultCallbackIsCalledWithCorrectResults()
        {
            int classCounter = 0;
            int errorCounter = 0;
            int failedCounter = 0;
            int passedCounter = 0;
            int skippedCounter = 0;

            StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));

            TestClassCommandRunner.Execute(command, null, null,
                                           result =>
                                           {
                                               if (result is PassedResult)
                                                   passedCounter++;
                                               else if (result is FailedResult)
                                                   failedCounter++;
                                               else if (result is SkipResult)
                                                   skippedCounter++;
                                               else if (result is ClassResult)
                                                   classCounter++;
                                               else
                                                   errorCounter++;

                                               return true;
                                           });

            Assert.Equal(1, passedCounter);
            Assert.Equal(1, failedCounter);
            Assert.Equal(1, skippedCounter);
            Assert.Equal(1, classCounter);
            Assert.Equal(0, errorCounter);
        }
        public void StartCallbackIsCalled()
        {
            int count = 0;
            string passName = typeof(VarietyTestClass).FullName + ".PassedTest";
            string failName = typeof(VarietyTestClass).FullName + ".FailedTest";
            string skipName = typeof(VarietyTestClass).FullName + ".SkippedTest";
            bool foundPass = false;
            bool foundFail = false;
            bool foundSkip = false;

            StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));

            TestClassCommandRunner.Execute(command, null,
                                           cmd =>
                                           {
                                               ++count;
                                               if (cmd.DisplayName == passName)
                                                   foundPass = true;
                                               if (cmd.DisplayName == failName)
                                                   foundFail = true;
                                               if (cmd.DisplayName == skipName)
                                                   foundSkip = true;
                                               return true;
                                           }, null);

            Assert.Equal(3, count);
            Assert.True(foundPass);
            Assert.True(foundFail);
            Assert.True(foundSkip);
        }
        public void ExecuteWithNullMethodsRunAllTestMethods()
        {
            StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));

            ClassResult result = TestClassCommandRunner.Execute(command, null, null, null);

            Assert.Equal(VarietyTestClass.TestMethodCount, result.Results.Count);
        }
    public void ExecuteWithNullMethodsRunAllTestMethods()
    {
        StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));

        ClassResult result = TestClassCommandRunner.Execute(command, null, null, null);

        Assert.Equal(VarietyTestClass.TestMethodCount, result.Results.Count);
    }
    public void ClassFinishException()
    {
        StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));
        command.ClassFinish__Result = new Exception();

        ClassResult result = TestClassCommandRunner.Execute(command, null, null, null);

        Assert.Equal(typeof(Exception) + " : " + command.ClassFinish__Result.Message, result.Message);
        Assert.Equal(command.ClassFinish__Result.StackTrace, result.StackTrace);
    }
        public void ExecuteWillNotRunRequestedNonTestMethod()
        {
            StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));
            List <IMethodInfo>   methods = new List <IMethodInfo> {
                Reflector.Wrap(typeof(VarietyTestClass).GetMethod("NonTestMethod"))
            };

            ClassResult result = TestClassCommandRunner.Execute(command, methods, null, null);

            Assert.Equal(0, result.Results.Count);
        }
        public void ClassFinishException()
        {
            StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));

            command.ClassFinish__Result = new Exception();

            ClassResult result = TestClassCommandRunner.Execute(command, null, null, null);

            Assert.Equal(typeof(Exception) + " : " + command.ClassFinish__Result.Message, result.Message);
            Assert.Equal(command.ClassFinish__Result.StackTrace, result.StackTrace);
        }
        public void ExecuteWithSpecificMethodOnlyRunsThatMethod()
        {
            StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));
            List <IMethodInfo>   methods = new List <IMethodInfo> {
                Reflector.Wrap(typeof(VarietyTestClass).GetMethod("PassedTest"))
            };

            ClassResult result = TestClassCommandRunner.Execute(command, methods, null, null);

            Assert.Single(result.Results);
        }
    public void ExecuteWithSpecificMethodOnlyRunsThatMethod()
    {
        StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));
        List<IMethodInfo> methods = new List<IMethodInfo> {
            Reflector.Wrap(typeof(VarietyTestClass).GetMethod("PassedTest"))
        };

        ClassResult result = TestClassCommandRunner.Execute(command, methods, null, null);

        Assert.Single(result.Results);
    }
    public void ExecuteWillNotRunRequestedNonTestMethod()
    {
        StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));
        List<IMethodInfo> methods = new List<IMethodInfo> {
            Reflector.Wrap(typeof(VarietyTestClass).GetMethod("NonTestMethod"))
        };

        ClassResult result = TestClassCommandRunner.Execute(command, methods, null, null);

        Assert.Equal(0, result.Results.Count);
    }
    public void ClassStartExceptionDoesNotRunTestsButDoesCallClassFinish()
    {
        StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));
        command.ClassStart__Result = new Exception();

        ClassResult result = TestClassCommandRunner.Execute(command, null, null, null);

        Assert.True(command.ClassStart__Called);
        Assert.True(command.ClassFinish__Called);
        Assert.Equal(typeof(Exception) + " : " + command.ClassStart__Result.Message, result.Message);
        Assert.Equal(command.ClassStart__Result.StackTrace, result.StackTrace);
        Assert.Equal(0, result.Results.Count);
    }
    public void IncludesTimeoutCommandWhenTestCommandSaysTheresATimeout()
    {
        MethodInfo method = typeof(TestCommandFactoryTests).GetMethod("PublicTestMethod");
        List<ITestCommand> testCommands = new List<ITestCommand>();
        StubTestClassCommand classCommand = new StubTestClassCommand();
        testCommands.Add(new StubTestCommand { Timeout__Result = 153 });
        classCommand.EnumerateTestCommands__Result = testCommands;

        List<ITestCommand> result = new List<ITestCommand>(TestCommandFactory.Make(classCommand, Reflector.Wrap(method)));

        Assert.Same(method, classCommand.EnumerateTestCommands_TestMethod.MethodInfo);
        Assert.Equal(testCommands.Count, result.Count);
        Assert.IsType<TimeoutCommand>(result[0]);
    }
        public void ClassStartExceptionDoesNotRunTestsButDoesCallClassFinish()
        {
            StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));

            command.ClassStart__Result = new Exception();

            ClassResult result = TestClassCommandRunner.Execute(command, null, null, null);

            Assert.True(command.ClassStart__Called);
            Assert.True(command.ClassFinish__Called);
            Assert.Equal(typeof(Exception) + " : " + command.ClassStart__Result.Message, result.Message);
            Assert.Equal(command.ClassStart__Result.StackTrace, result.StackTrace);
            Assert.Equal(0, result.Results.Count);
        }
        public void UsesProvidedObjectInstanceForAllTests()
        {
            InstanceSpy          originalObject = new InstanceSpy();
            StubTestClassCommand command        = new StubTestClassCommand(typeof(InstanceSpy));

            command.ObjectUnderTest__Result = originalObject;
            InstanceSpy.Reset();

            TestClassCommandRunner.Execute(command, null, null, null);

            Assert.Equal(3, InstanceSpy.instances.Count);
            foreach (object obj in InstanceSpy.instances)
            {
                Assert.Same(originalObject, obj);
            }
        }
        public void ResultCallbackIsCalledWithCorrectResults()
        {
            int classCounter   = 0;
            int errorCounter   = 0;
            int failedCounter  = 0;
            int passedCounter  = 0;
            int skippedCounter = 0;

            StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));

            TestClassCommandRunner.Execute(
                command,
                null,
                null,
                result =>
            {
                if (result is PassedResult)
                {
                    passedCounter++;
                }
                else if (result is FailedResult)
                {
                    failedCounter++;
                }
                else if (result is SkipResult)
                {
                    skippedCounter++;
                }
                else if (result is ClassResult)
                {
                    classCounter++;
                }
                else
                {
                    errorCounter++;
                }

                return(true);
            }
                );

            Assert.Equal(1, passedCounter);
            Assert.Equal(1, failedCounter);
            Assert.Equal(1, skippedCounter);
            Assert.Equal(1, classCounter);
            Assert.Equal(0, errorCounter);
        }
Example #16
0
        public void IncludesTimeoutCommandWhenTestCommandSaysTheresATimeout()
        {
            MethodInfo           method       = typeof(TestCommandFactoryTests).GetMethod("PublicTestMethod");
            List <ITestCommand>  testCommands = new List <ITestCommand>();
            StubTestClassCommand classCommand = new StubTestClassCommand();

            testCommands.Add(new StubTestCommand {
                Timeout__Result = 153
            });
            classCommand.EnumerateTestCommands__Result = testCommands;

            List <ITestCommand> result = new List <ITestCommand>(TestCommandFactory.Make(classCommand, Reflector.Wrap(method)));

            Assert.Same(method, classCommand.EnumerateTestCommands_TestMethod.MethodInfo);
            Assert.Equal(testCommands.Count, result.Count);
            Assert.IsType <TimeoutCommand>(result[0]);
        }
    public void CallsTestClassCommandToGetTestCommandsAndWrapsTheminTimedCommands()
    {
        MethodInfo method = typeof(TestCommandFactoryTests).GetMethod("PublicTestMethod");
        List<ITestCommand> testCommands = new List<ITestCommand>();
        StubTestClassCommand classCommand = new StubTestClassCommand();
        testCommands.Add(new StubTestCommand());
        classCommand.EnumerateTestCommands__Result = testCommands;

        List<ITestCommand> result = new List<ITestCommand>(TestCommandFactory.Make(classCommand, Reflector.Wrap(method)));

        Assert.Same(method, classCommand.EnumerateTestCommands_TestMethod.MethodInfo);
        Assert.Equal(testCommands.Count, result.Count);
        var timedCommand = Assert.IsType<TimedCommand>(result[0]);
        var captureCommand = Assert.IsType<ExceptionAndOutputCaptureCommand>(timedCommand.InnerCommand);
        var lifetimeCommand = Assert.IsType<LifetimeCommand>(captureCommand.InnerCommand);
        var beforeAfterCommand = Assert.IsType<BeforeAfterCommand>(lifetimeCommand.InnerCommand);
        Assert.Same(testCommands[0], beforeAfterCommand.InnerCommand);
    }
    public void DoesNotIncludeCreationCommandWhenTestCommandSaysNotToCreateInstance()
    {
        MethodInfo method = typeof(TestCommandFactoryTests).GetMethod("PublicTestMethod");
        List<ITestCommand> testCommands = new List<ITestCommand>();
        StubTestClassCommand classCommand = new StubTestClassCommand();
        StubTestCommand testCommand = new StubTestCommand();
        testCommand.ShouldCreateInstance__Result = false;
        testCommands.Add(testCommand);
        classCommand.EnumerateTestCommands__Result = testCommands;

        List<ITestCommand> result = new List<ITestCommand>(TestCommandFactory.Make(classCommand, Reflector.Wrap(method)));

        Assert.Same(method, classCommand.EnumerateTestCommands_TestMethod.MethodInfo);
        Assert.Equal(testCommands.Count, result.Count);
        var timedCommand = Assert.IsType<TimedCommand>(result[0]);
        var captureCommand = Assert.IsType<ExceptionAndOutputCaptureCommand>(timedCommand.InnerCommand);
        var beforeAfterCommand = Assert.IsType<BeforeAfterCommand>(captureCommand.InnerCommand);
        Assert.Same(testCommands[0], beforeAfterCommand.InnerCommand);
    }
Example #19
0
        public void CallsTestClassCommandToGetTestCommandsAndWrapsTheminTimedCommands()
        {
            MethodInfo           method       = typeof(TestCommandFactoryTests).GetMethod("PublicTestMethod");
            List <ITestCommand>  testCommands = new List <ITestCommand>();
            StubTestClassCommand classCommand = new StubTestClassCommand();

            testCommands.Add(new StubTestCommand());
            classCommand.EnumerateTestCommands__Result = testCommands;

            List <ITestCommand> result = new List <ITestCommand>(TestCommandFactory.Make(classCommand, Reflector.Wrap(method)));

            Assert.Same(method, classCommand.EnumerateTestCommands_TestMethod.MethodInfo);
            Assert.Equal(testCommands.Count, result.Count);
            var timedCommand       = Assert.IsType <TimedCommand>(result[0]);
            var captureCommand     = Assert.IsType <ExceptionAndOutputCaptureCommand>(timedCommand.InnerCommand);
            var lifetimeCommand    = Assert.IsType <LifetimeCommand>(captureCommand.InnerCommand);
            var beforeAfterCommand = Assert.IsType <BeforeAfterCommand>(lifetimeCommand.InnerCommand);

            Assert.Same(testCommands[0], beforeAfterCommand.InnerCommand);
        }
Example #20
0
        public void DoesNotIncludeCreationCommandWhenTestCommandSaysNotToCreateInstance()
        {
            MethodInfo           method       = typeof(TestCommandFactoryTests).GetMethod("PublicTestMethod");
            List <ITestCommand>  testCommands = new List <ITestCommand>();
            StubTestClassCommand classCommand = new StubTestClassCommand();
            StubTestCommand      testCommand  = new StubTestCommand();

            testCommand.ShouldCreateInstance__Result = false;
            testCommands.Add(testCommand);
            classCommand.EnumerateTestCommands__Result = testCommands;

            List <ITestCommand> result = new List <ITestCommand>(TestCommandFactory.Make(classCommand, Reflector.Wrap(method)));

            Assert.Same(method, classCommand.EnumerateTestCommands_TestMethod.MethodInfo);
            Assert.Equal(testCommands.Count, result.Count);
            var timedCommand       = Assert.IsType <TimedCommand>(result[0]);
            var captureCommand     = Assert.IsType <ExceptionAndOutputCaptureCommand>(timedCommand.InnerCommand);
            var beforeAfterCommand = Assert.IsType <BeforeAfterCommand>(captureCommand.InnerCommand);

            Assert.Same(testCommands[0], beforeAfterCommand.InnerCommand);
        }
        public void StartCallbackIsCalled()
        {
            int    count     = 0;
            string passName  = typeof(VarietyTestClass).FullName + ".PassedTest";
            string failName  = typeof(VarietyTestClass).FullName + ".FailedTest";
            string skipName  = typeof(VarietyTestClass).FullName + ".SkippedTest";
            bool   foundPass = false;
            bool   foundFail = false;
            bool   foundSkip = false;

            StubTestClassCommand command = new StubTestClassCommand(typeof(VarietyTestClass));

            TestClassCommandRunner.Execute(
                command,
                null,
                cmd =>
            {
                ++count;
                if (cmd.DisplayName == passName)
                {
                    foundPass = true;
                }
                if (cmd.DisplayName == failName)
                {
                    foundFail = true;
                }
                if (cmd.DisplayName == skipName)
                {
                    foundSkip = true;
                }
                return(true);
            },
                null
                );

            Assert.Equal(3, count);
            Assert.True(foundPass);
            Assert.True(foundFail);
            Assert.True(foundSkip);
        }
    public void UsesProvidedObjectInstanceForAllTests()
    {
        InstanceSpy originalObject = new InstanceSpy();
        StubTestClassCommand command = new StubTestClassCommand(typeof(InstanceSpy));
        command.ObjectUnderTest__Result = originalObject;
        InstanceSpy.Reset();

        TestClassCommandRunner.Execute(command, null, null, null);

        Assert.Equal(3, InstanceSpy.instances.Count);
        foreach (object obj in InstanceSpy.instances)
            Assert.Same(originalObject, obj);
    }