public void ExecuteShouldNotThrowWhenSpecimenIsValidNonMockSpecimen(object validNonMockSpecimen)
 {
     // Fixture setup
     var context = new Mock<ISpecimenContext>();
     var sut = new MockVirtualMethodsCommand();
     // Exercise system and verify outcome
     Assert.DoesNotThrow(
         () => sut.Execute(validNonMockSpecimen, context.Object));
     // Teardown
 }
예제 #2
0
        public void ExecuteShouldNotThrowWhenSpecimenIsValidNonMockSpecimen(object validNonMockSpecimen)
        {
            // Arrange
            var context = new Mock <ISpecimenContext>();
            var sut     = new MockVirtualMethodsCommand();

            // Act & Assert
            Assert.Null(
                Record.Exception(() => sut.Execute(validNonMockSpecimen, context.Object)));
        }
예제 #3
0
        public void SetupThrowsWhenContextIsNull()
        {
            // Arrange
            var mock = new Mock <object>();
            var sut  = new MockVirtualMethodsCommand();

            // Act & Assert
            Assert.Throws <ArgumentNullException>(
                () => sut.Execute(mock, null));
        }
 public void SetupThrowsWhenContextIsNull()
 {
     // Fixture setup
     var mock = new Mock<object>();
     var sut = new MockVirtualMethodsCommand();
     // Exercise system and verify outcome
     Assert.Throws<ArgumentNullException>(
         () => sut.Execute(mock, null));
     // Teardown
 }
 public void SetupThrowsWhenMockIsNull()
 {
     // Fixture setup
     var context = new Mock<ISpecimenContext>();
     var sut = new MockVirtualMethodsCommand();
     // Exercise system and verify outcome
     Assert.Throws<ArgumentNullException>(
         () => sut.Execute(null, context.Object));
     // Teardown
 }
예제 #6
0
        public void ExecuteShouldNotThrowWhenSpecimenIsValidNonMockSpecimen(object validNonMockSpecimen)
        {
            // Fixture setup
            var context = new Mock <ISpecimenContext>();
            var sut     = new MockVirtualMethodsCommand();

            // Exercise system and verify outcome
            Assert.DoesNotThrow(
                () => sut.Execute(validNonMockSpecimen, context.Object));
            // Teardown
        }
예제 #7
0
        public void IgnoresStaticMethods()
        {
            // Arrange
            var fixture = new Fixture();
            var mock    = new Mock <TypeWithStaticMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Act & Assert
            Assert.Null(Record.Exception(() => sut.Execute(mock, new SpecimenContext(fixture))));
        }
        public void IgnoresStaticMethods()
        {
            // Fixture setup
            var fixture = new Fixture();
            var mock    = new Mock <TypeWithStaticMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(mock, new SpecimenContext(fixture)));
        }
        public void SetupThrowsWhenContextIsNull()
        {
            // Fixture setup
            var mock = new Mock <object>();
            var sut  = new MockVirtualMethodsCommand();

            // Exercise system and verify outcome
            Assert.Throws <ArgumentNullException>(
                () => sut.Execute(mock, null));
            // Teardown
        }
        public void SetupThrowsWhenMockIsNull()
        {
            // Fixture setup
            var context = new Mock <ISpecimenContext>();
            var sut     = new MockVirtualMethodsCommand();

            // Exercise system and verify outcome
            Assert.Throws <ArgumentNullException>(
                () => sut.Execute(null, context.Object));
            // Teardown
        }
예제 #11
0
        public void IgnoresMethodsWithRefParameters()
        {
            // Arrange
            var fixture = new Fixture();
            var mock    = new Mock <IInterfaceWithRefMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Act & Assert
            Assert.Null(Record.Exception(() => sut.Execute(mock, new SpecimenContext(fixture))));
        }
        public void IgnoresVoidMethods()
        {
            // Fixture setup
            var fixture = new Fixture();
            var mock    = new Mock <IInterfaceWithVoidMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Exercise system and verify outcome
            Assert.Null(Record.Exception(() => sut.Execute(mock, new SpecimenContext(fixture))));
        }
예제 #13
0
        public void IgnoresNonMockSpecimens()
        {
            // Arrange
            // The context mock has a strict behaviour - if any of its members are invoked, an exception will be thrown
            var context  = new Mock <ISpecimenContext>(MockBehavior.Strict);
            var specimen = new TypeWithVirtualMembers();

            var sut = new MockVirtualMethodsCommand();

            // Act & Assert
            Assert.Null(Record.Exception(() => sut.Execute(specimen, context.Object)));
        }
        public void IgnoresNonMockSpecimens()
        {
            // Fixture setup
            // The context mock has a strict behaviour - if any of its members are invoked, an exception will be thrown
            var context  = new Mock <ISpecimenContext>(MockBehavior.Strict);
            var specimen = new TypeWithVirtualMembers();

            var sut = new MockVirtualMethodsCommand();

            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(specimen, context.Object));
        }
예제 #15
0
        public void IgnoresGenericMethods()
        {
            // Arrange
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var mock         = new Mock <IInterfaceWithGenericMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Act & Assert
            Assert.Null(Record.Exception(() => sut.Execute(mock, new SpecimenContext(fixture))));
            Assert.NotEqual(frozenString, mock.Object.GenericMethod <string>());
        }
        public void IgnoresGenericMethods()
        {
            // Fixture setup
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var mock         = new Mock <IInterfaceWithGenericMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(mock, new SpecimenContext(fixture)));
            Assert.NotEqual(frozenString, mock.Object.GenericMethod <string>());
        }
        public void IgnoresSealedMethods()
        {
            // Fixture setup
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var mock         = new Mock <TypeWithSealedMembers>();

            var sut = new MockVirtualMethodsCommand();

            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(mock, new SpecimenContext(fixture)));
            Assert.NotEqual(frozenString, mock.Object.ImplicitlySealedMethod());
            Assert.NotEqual(frozenString, mock.Object.ExplicitlySealedMethod());
        }
예제 #18
0
        public void IgnoresSealedMethods()
        {
            // Arrange
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var mock         = new Mock <TypeWithSealedMembers>();

            var sut = new MockVirtualMethodsCommand();

            // Act & Assert
            Assert.Null(Record.Exception(() => sut.Execute(mock, new SpecimenContext(fixture))));
            Assert.NotEqual(frozenString, mock.Object.ImplicitlySealedMethod());
            Assert.NotEqual(frozenString, mock.Object.ExplicitlySealedMethod());
        }
예제 #19
0
        public void SetsUpMethodsLazily()
        {
            // Arrange
            var context = new Mock <ISpecimenContext>();
            var mock    = new Mock <IInterfaceWithParameterlessMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Act
            sut.Execute(mock, context.Object);
            // Assert
            context.Verify(ctx => ctx.Resolve(It.IsAny <object>()), Times.Never());
            mock.Object.Method();
            context.Verify(ctx => ctx.Resolve(It.IsAny <object>()), Times.Once());
        }
예제 #20
0
        public void IgnoresVirtualPropertiesWithGettersAndSetters()
        {
            // Fixture setup
            var fixture = new Fixture();
            var mock    = new Mock <TypeWithVirtualMembers>();

            var sut = new MockVirtualMethodsCommand();

            // Exercise system
            sut.Execute(mock, new SpecimenContext(fixture));
            // Verify outcome
            var result = mock.Object;

            Assert.Null(result.VirtualProperty);
        }
예제 #21
0
        public void IgnoresPropertiesWithGettersAndSettersFromInheritedInterface()
        {
            // Arrange
            var fixture = new Fixture();
            var mock    = new Mock <IDerivedInterfaceWithProperty>();

            var sut = new MockVirtualMethodsCommand();

            // Act
            sut.Execute(mock, new SpecimenContext(fixture));
            // Assert
            var result = mock.Object;

            Assert.Null(result.Property);
        }
        public void SetsUpInterfaceNewMethods_ToRetrieveReturnValueFromContext()
        {
            // Fixture setup
            var fixture = new Fixture();
            var frozenString = fixture.Freeze<string>();
            var mock = new Mock<IInterfaceWithNewMethod>();

            var sut = new MockVirtualMethodsCommand();
            // Exercise system
            sut.Execute(mock, new SpecimenContext(fixture));
            // Verify outcome
            var result = mock.Object.Method(0);
            Assert.Same(frozenString, result);
            // Teardown
        }
예제 #23
0
        public void IgnoresVirtualPropertiesWithGettersAndSetters()
        {
            // Arrange
            var fixture = new Fixture();
            var mock    = new Mock <TypeWithVirtualMembers>();

            var sut = new MockVirtualMethodsCommand();

            // Act
            sut.Execute(mock, new SpecimenContext(fixture));
            // Assert
            var result = mock.Object;

            Assert.Null(result.VirtualProperty);
        }
예제 #24
0
        public void SetsUpVirtualPropertyGetters_ToRetrieveReturnValueFromContext()
        {
            // Arrange
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var mock         = new Mock <TypeWithVirtualMembers>();

            var sut = new MockVirtualMethodsCommand();

            // Act
            sut.Execute(mock, new SpecimenContext(fixture));
            // Assert
            var result = mock.Object.VirtualGetOnlyProperty;

            Assert.Equal(frozenString, result);
        }
예제 #25
0
        public void SetsUpIndexers()
        {
            // Arrange
            var fixture   = new Fixture();
            var frozenInt = fixture.Freeze <int>();
            var mock      = new Mock <IInterfaceWithIndexer>();

            var sut = new MockVirtualMethodsCommand();

            // Act
            sut.Execute(mock, new SpecimenContext(fixture));
            // Assert
            int result = mock.Object[3];

            Assert.Equal(frozenInt, result);
        }
        public void SetsUpMethodsLazily()
        {
            // Fixture setup
            var context = new Mock <ISpecimenContext>();
            var mock    = new Mock <IInterfaceWithParameterlessMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Exercise system
            sut.Execute(mock, context.Object);
            // Verify outcome
            context.Verify(ctx => ctx.Resolve(It.IsAny <object>()), Times.Never());
            mock.Object.Method();
            context.Verify(ctx => ctx.Resolve(It.IsAny <object>()), Times.Once());
            // Teardown
        }
예제 #27
0
        public void SetsUpMethodsWithParameters()
        {
            // Arrange
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var mock         = new Mock <IInterfaceWithMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Act
            sut.Execute(mock, new SpecimenContext(fixture));
            // Assert
            var result = mock.Object.Method("hi");

            Assert.Same(frozenString, result);
        }
예제 #28
0
        public void SetsUpInterfaceShadowedMethods_ToRetrieveReturnValueFromContext()
        {
            // Arrange
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var mock         = new Mock <IInterfaceWithNewMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Act
            sut.Execute(mock, new SpecimenContext(fixture));
            // Assert
            var result = (mock.Object as IInterfaceWithShadowedMethod).Method(0);

            Assert.Same(frozenString, result);
        }
예제 #29
0
        public void SetsUpInterfaceBaseMethods_ToRetrieveReturnValueFromContext()
        {
            // Arrange
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var mock         = new Mock <IDerivedInterface>();

            var sut = new MockVirtualMethodsCommand();

            // Act
            sut.Execute(mock, new SpecimenContext(fixture));
            // Assert
            var result = mock.Object.Method();

            Assert.Same(frozenString, result);
        }
예제 #30
0
        public void SetsUpMethodsWithOutParameters()
        {
            // Arrange
            var fixture   = new Fixture();
            var frozenInt = fixture.Freeze <int>();
            var mock      = new Mock <IInterfaceWithOutMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Act
            sut.Execute(mock, new SpecimenContext(fixture));
            // Assert
            int outResult;

            mock.Object.Method(out outResult);
            Assert.Equal(frozenInt, outResult);
        }
        public void SetsUpInterfaceNewMethods_ToRetrieveReturnValueFromContext()
        {
            // Fixture setup
            var fixture      = new Fixture();
            var frozenString = fixture.Freeze <string>();
            var mock         = new Mock <IInterfaceWithNewMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Exercise system
            sut.Execute(mock, new SpecimenContext(fixture));
            // Verify outcome
            var result = mock.Object.Method(0);

            Assert.Same(frozenString, result);
            // Teardown
        }
        public void SetsUpIndexers()
        {
            // Fixture setup
            var fixture   = new Fixture();
            var frozenInt = fixture.Freeze <int>();
            var mock      = new Mock <IInterfaceWithIndexer>();

            var sut = new MockVirtualMethodsCommand();

            // Exercise system
            sut.Execute(mock, new SpecimenContext(fixture));
            // Verify outcome
            int result = mock.Object[3];

            Assert.Equal(frozenInt, result);
            // Teardown
        }
        public void SetsUpMethodsWithOutParameters()
        {
            // Fixture setup
            var fixture   = new Fixture();
            var frozenInt = fixture.Freeze <int>();
            var mock      = new Mock <IInterfaceWithOutMethod>();

            var sut = new MockVirtualMethodsCommand();

            // Exercise system
            sut.Execute(mock, new SpecimenContext(fixture));
            // Verify outcome
            int outResult;

            mock.Object.Method(out outResult);
            Assert.Equal(frozenInt, outResult);
            // Teardown
        }
예제 #34
0
        public void DoesNotSetupMethodsWithOutParametersWhenContextReturnsOmitSpecimen()
        {
            // Arrange
            var contextMock = new Mock <ISpecimenContext>();

            contextMock.Setup(ctx => ctx.Resolve(typeof(int)))
            .Returns(new OmitSpecimen());
            var mock = new Mock <IInterfaceWithOutMethod>(MockBehavior.Strict);

            var sut = new MockVirtualMethodsCommand();

            // Act
            sut.Execute(mock, contextMock.Object);
            // Assert
            // The mock has strict behaviour - calling methods that were not setup cause an exception to be thrown
            int outResult;

            Assert.Throws <MockException>(() => mock.Object.Method(out outResult));
        }
        public void SetsUpIndexers()
        {
            // Fixture setup
            var fixture = new Fixture();
            var frozenInt = fixture.Freeze<int>();
            var mock = new Mock<IInterfaceWithIndexer>();

            var sut = new MockVirtualMethodsCommand();
            // Exercise system
            sut.Execute(mock, new SpecimenContext(fixture));
            // Verify outcome
            int result = mock.Object[3];
            Assert.Equal(frozenInt, result);
            // Teardown
        }
        public void SetsUpMethodsWithOutParameters()
        {
            // Fixture setup
            var fixture = new Fixture();
            var frozenInt = fixture.Freeze<int>();
            var mock = new Mock<IInterfaceWithOutMethod>();

            var sut = new MockVirtualMethodsCommand();
            // Exercise system
            sut.Execute(mock, new SpecimenContext(fixture));
            // Verify outcome
            int outResult;
            mock.Object.Method(out outResult);
            Assert.Equal(frozenInt, outResult);
            // Teardown
        }
        public void SetsUpMethodsLazily()
        {
            // Fixture setup
            var context = new Mock<ISpecimenContext>();
            var mock = new Mock<IInterfaceWithParameterlessMethod>();

            var sut = new MockVirtualMethodsCommand();
            // Exercise system
            sut.Execute(mock, context.Object);
            // Verify outcome
            context.Verify(ctx => ctx.Resolve(It.IsAny<object>()), Times.Never());
            mock.Object.Method();
            context.Verify(ctx => ctx.Resolve(It.IsAny<object>()), Times.Once());
            // Teardown
        }
        public void IgnoresSealedMethods()
        {
            // Fixture setup
            var fixture = new Fixture();
            var frozenString = fixture.Freeze<string>();
            var mock = new Mock<TypeWithSealedMembers>();

            var sut = new MockVirtualMethodsCommand();
            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(mock, new SpecimenContext(fixture)));
            Assert.NotEqual(frozenString, mock.Object.ImplicitlySealedMethod());
            Assert.NotEqual(frozenString, mock.Object.ExplicitlySealedMethod());
        }
        public void IgnoresGenericMethods()
        {
            // Fixture setup
            var fixture = new Fixture();
            var frozenString = fixture.Freeze<string>();
            var mock = new Mock<IInterfaceWithGenericMethod>();

            var sut = new MockVirtualMethodsCommand();
            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(mock, new SpecimenContext(fixture)));
            Assert.NotEqual(frozenString, mock.Object.GenericMethod<string>());
        }
        public void IgnoresStaticMethods()
        {
            // Fixture setup
            var fixture = new Fixture();
            var mock = new Mock<TypeWithStaticMethod>();

            var sut = new MockVirtualMethodsCommand();
            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(mock, new SpecimenContext(fixture)));
        }
        public void IgnoresNonMockSpecimens()
        {
            // Fixture setup
            // The context mock has a strict behaviour - if any of its members are invoked, an exception will be thrown
            var context = new Mock<ISpecimenContext>(MockBehavior.Strict);
            var specimen = new TypeWithVirtualMembers();

            var sut = new MockVirtualMethodsCommand();
            // Exercise system and verify outcome
            Assert.DoesNotThrow(() => sut.Execute(specimen, context.Object));
        }
        public void SetsUpOutParametersWithNullWhenContextReturnsNull()
        {
            // Fixture setup
            var contextMock = new Mock<ISpecimenContext>();
            contextMock.Setup(ctx => ctx.Resolve(typeof (string)))
                .Returns(null);
            var mock = new Mock<IInterfaceWithMethodWithOutParameterOfReferenceType>();

            var sut = new MockVirtualMethodsCommand();
            // Exercise system
            sut.Execute(mock, contextMock.Object);
            // Verify outcome
            string outResult;
            mock.Object.Method(out outResult);
            Assert.Null(outResult);
            // Teardown
        }
        public void DoesNotSetupMethodsWithOutParametersWhenContextReturnsOmitSpecimen()
        {
            // Fixture setup
            var contextMock = new Mock<ISpecimenContext>();
            contextMock.Setup(ctx => ctx.Resolve(typeof (int)))
                .Returns(new OmitSpecimen());
            var mock = new Mock<IInterfaceWithOutMethod>(MockBehavior.Strict);

            var sut = new MockVirtualMethodsCommand();
            // Exercise system
            sut.Execute(mock, contextMock.Object);
            // Verify outcome
            // The mock has strict behaviour - calling methods that were not setup cause an exception to be thrown
            int outResult;
            Assert.Throws<MockException>(() => mock.Object.Method(out outResult));
            // Teardown
        }