public void CreateReturnsCorrectCommands() { // Fixture setup var testMethod = Reflector.Wrap(new Methods<TestClass>().Select(x => x.TestMethod())); var sut = new TestCaseCommandFactory(); var factory = Mocked.Of<ISpecimenBuilderFactory>(); // Exercise system var actual = sut.Create(testMethod, factory).ToArray(); // Verify outcome Assert.Equal(3, actual.Length); foreach (var testCommand in actual) { var parameterizedCommand = Assert.IsAssignableFrom<ParameterizedCommand>(testCommand); var context = Assert.IsAssignableFrom<TestCaseCommandContext>( parameterizedCommand.TestCommandContext); Assert.Equal(testMethod, context.TestMethod); Assert.Equal(TestClass.Method, context.ActualMethod.MethodInfo); Assert.Equal(TestClass.TestObject, context.ActualObject); Assert.Equal(factory, context.BuilderFactory); Assert.Equal(TestClass.Arguments, context.ExplicitArguments); } }
public void CreateLazilyReturnsCommand() { var sut = new TestCaseCommandFactory(); var testMethod = Reflector.Wrap(new Methods<TestClass>().Select(x => x.ThrowMethod())); Assert.DoesNotThrow(() => { sut.Create(testMethod, Mocked.Of<ISpecimenBuilderFactory>()); }); }
public void CreateReturnsCorrectCommandForParameterizedMethod() { var sut = new TestCaseCommandFactory(); var testMethod = Reflector.Wrap( new Methods<TestClass>().Select(x => x.TestMethod(null, 0, null))); var actual = sut.Create(testMethod, new FakeBuilderFactory()); Assert.True(actual.Any()); }
public void CreateDoesNotCreateTestFixtureForNonParameterizedMethod() { var sut = new TestCaseCommandFactory(); var method = new Methods<TestClass>().Select(x => x.TestMethod()); var factory = Mocked.Of<ISpecimenBuilderFactory>(); sut.Create(Reflector.Wrap(method), factory); factory.ToMock().Verify(x => x.Create(It.IsAny<ITestMethodContext>()), Times.Never()); }
public void CreatePassesCorrectMethodContextForParameterizedMethod() { var sut = new TestCaseCommandFactory(); var method = new Methods<TestClass>().Select(x => x.TestMethod(null, 0, null)); var factory = Mocked.Of<ISpecimenBuilderFactory>(); factory.ToMock() .Setup(x => x.Create(It.IsAny<ITestMethodContext>())) .Returns(new Fixture()) .Callback<ITestMethodContext>(c => { Assert.Equal(method, c.TestMethod); Assert.Equal(method, c.ActualMethod); Assert.IsAssignableFrom<TestClass>(c.TestObject); Assert.IsAssignableFrom<TestClass>(c.ActualObject); }); sut.Create(Reflector.Wrap(method), factory).ToArray(); factory.ToMock().VerifyAll(); }
public void SutIsTestCommandFactory() { var sut = new TestCaseCommandFactory(); Assert.IsAssignableFrom<ITestCommandFactory>(sut); }
public void CreateWithStaticClassReturnsCorrectCommands() { var sut = new TestCaseCommandFactory(); var testMethod = Reflector.Wrap(Methods.Select(() => StaticTestClass.TestMethod())); var actual = sut.Create(testMethod, Mocked.Of<ISpecimenBuilderFactory>()).ToArray(); Assert.Equal(1, actual.Length); }
public void CreateWithNullTestMethodThrows() { var sut = new TestCaseCommandFactory(); Assert.Throws<ArgumentNullException>(() => sut.Create(null, null).ToArray()); }
public void CreateReturnsNonEmptyIfReturnTypeIsCorrect(Type returnType) { var sut = new TestCaseCommandFactory(); var testMethod = new Methods<TestClass>().Select(x => x.TestMethod()); var factory = Mocked.Of<ISpecimenBuilderFactory>(); var actual = sut.Create(Reflector.Wrap(testMethod), factory); Assert.NotEmpty(actual); }
public void CreateReturnsEmptyIfReturnTypeIsIncorrect(Type returnType) { var sut = new TestCaseCommandFactory(); var testMethod = Mocked.Of<IMethodInfo>( m => m.MethodInfo == Mocked.Of<MethodInfo>(i => i.ReturnType == returnType)); var actual = sut.Create(testMethod, null); Assert.Empty(actual); }