C# Mock.ToMock方法代码示例

        public void VerifyGetSetPropertyCallsVerifyGetMethodAndSetMethod()
        {
            var sut = new Mock<ObjectDisposalAssertion>(new Fixture()) { CallBase = true }.Object;
            var property = new Properties<ClassWithMembers>().Select(x => x.PublicProperty);
            sut.ToMock().Setup(x => x.Verify(It.IsAny<MethodInfo>()));

            sut.Verify(property);

            sut.ToMock().Verify(x => x.Verify(property.GetGetMethod()));
            sut.ToMock().Verify(x => x.Verify(property.GetSetMethod()));
        }

        public void VerifyEventMemberCallsVerifyEvent()
        {
            var sut = new Mock<IdiomaticAssertion> { CallBase = true }.Object;
            var @event = typeof(ClassWithMembers).GetEvents().First();

            sut.Verify((MemberInfo)@event);

            sut.ToMock().Verify(x => x.Verify(@event));
        }

        public void VerifyFieldMemberCallsVerifyField()
        {
            var sut = new Mock<IdiomaticAssertion> { CallBase = true }.Object;
            var field = new Fields<ClassWithMembers>().Select(x => x.PublicField);

            sut.Verify((MemberInfo)field);

            sut.ToMock().Verify(x => x.Verify(field));
        }

        public void VerifyMethodMemberCallsVerifyMethod()
        {
            var sut = new Mock<IdiomaticAssertion> { CallBase = true }.Object;
            var method = new Methods<ClassWithMembers>().Select(x => x.PublicMethod());

            sut.Verify((MemberInfo)method);

            sut.ToMock().Verify(x => x.Verify(method));
        }

        public void VerifyConstructorMemberCallsVerifyConstructor()
        {
            var sut = new Mock<IdiomaticAssertion> { CallBase = true }.Object;
            var constructor = Constructors.Select(() => new ClassWithMembers());

            sut.Verify((MemberInfo)constructor);

            sut.ToMock().Verify(x => x.Verify(constructor));
        }

        public void VisitConstructorInfoElementCollectsCorrectAssembliesForMethodBody()
        {
            var visitor = new DelegatingReflectionVisitor<IEnumerable<Assembly>>();
            var sut = new Mock<ReferenceCollector> { CallBase = true }.Object;
            sut.ToMock().Setup(x => x.Visit(It.IsAny<ParameterInfoElement>())).Returns(visitor);
            sut.ToMock().Setup(x => x.Visit(It.IsAny<LocalVariableInfoElement>())).Returns(visitor);
            var expected = new[]
            {
                typeof(IDisposable).Assembly,
                GetType().Assembly,
                typeof(Fixture).Assembly
            };
            var constructorInfoElement = Constructors.Select(() => new ClassForCollectingReference(0)).ToElement();

            var actual = sut.Visit(constructorInfoElement);

            Assert.Equal(visitor, actual);
            Assert.Equal(expected.OrderBy(x => x.ToString()), sut.Value.OrderBy(x => x.ToString()));
        }

        public void VisitLocalVariableInfoElementsReturnsItself()
        {
            var sut = new Mock<MemberReferenceCollector> { CallBase = true }.Object;
            sut.ToMock().Setup(x => x.Visit(It.IsAny<LocalVariableInfoElement>())).Throws<InvalidOperationException>();
            var localVariableInfoElement = new Methods<ClassForCollectingReference>()
                .Select(x => x.ReturnMethod()).GetMethodBody()
                .LocalVariables.First().ToElement();

            var actual = sut.Visit(new[] { localVariableInfoElement });

            Assert.Same(sut, actual);
        }

        public void VerifyAssemblyCorrectlyVerifies()
        {
            var sut = new Mock<IdiomaticAssertion> { CallBase = true }.Object;
            var types = new List<MemberInfo>();
            sut.ToMock().Setup(x => x.Verify(It.IsAny<Type>())).Callback<Type>(types.Add);
            var assembly = typeof(TestBaseAttribute).Assembly;
            var expected = assembly.GetExportedTypes();

            sut.Verify(assembly);

            Assert.Equal(expected, types);
        }

        public void VisitAssemblyElementCallsBaseMethod()
        {
            var assembly = new DelegatingAssembly
            {
                OnGetTypes = () => new[] { typeof(object), typeof(int) }
            };
            var sut = new Mock<ReferenceCollector> { CallBase = true }.Object;
            var visitor1 = new Mock<ReferenceCollector>().Object;
            var visitor2 = new Mock<ReferenceCollector>().Object;
            sut.ToMock().Setup(x => x.Visit(typeof(object).ToElement())).Returns(visitor1);
            visitor1.ToMock().Setup(x => x.Visit(typeof(int).ToElement())).Returns(visitor2);

            var actual = sut.Visit(assembly.ToElement());

            Assert.Equal(visitor2, actual);
        }

        public void VerifyTypeCorrectlyVerifies()
        {
            // Fixture setup
            var arguments = new object[] { new Assembly[0] };
            var sut = new Mock<NotExposedReferenceAssertion>(arguments) { CallBase = true }.Object;

            var members = new List<MemberInfo>();
            sut.ToMock().Setup(x => x.Verify(It.IsAny<MemberInfo>())).Callback<MemberInfo>(members.Add);

            var type = typeof(ClassWithMembers);
            var expected = type.GetIdiomaticMembers();

            // Exercise system
            sut.Verify(type);

            // Verify outcome
            Assert.Equal(expected.OrderBy(m => m.Name), members.OrderBy(m => m.Name));
        }

        public void VerifyAssemblyCorrectlyVerifies()
        {
            // Fixture setup
            var arguments = new object[] { new Assembly[0] };
            var sut = new Mock<NotExposedReferenceAssertion>(arguments) { CallBase = true }.Object;
            
            var types = new List<Type>();
            sut.ToMock().Setup(x => x.Verify(It.IsAny<Type>())).Callback<Type>(types.Add);

            var assembly = typeof(object).Assembly;
            var expected = assembly.GetTypes().ToArray();

            // Exercise system
            sut.Verify(assembly);

            // Verify outcome
            Assert.Equal(expected, types);
        }

        public void VisitTypeElementCollectsCorrectAssemblies()
        {
            var type = typeof(List<ClassImplementingHierarchical>);
            var expected = new[]
            {
                typeof(ClassImplementingMultiple).Assembly,
                typeof(IDisposable).Assembly,
                typeof(IReflectionElement).Assembly,
                typeof(Fixture).Assembly
            };
            var visitor = new DelegatingReflectionVisitor<IEnumerable<Assembly>>();
            var sut = new Mock<ReferenceCollector> { CallBase = true }.Object;
            sut.ToMock().Setup(x => x.Visit(It.IsAny<FieldInfoElement>())).Returns(visitor);
            sut.ToMock().Setup(x => x.Visit(It.IsAny<ConstructorInfoElement>())).Returns(visitor);
            sut.ToMock().Setup(x => x.Visit(It.IsAny<PropertyInfoElement>())).Returns(visitor);
            sut.ToMock().Setup(x => x.Visit(It.IsAny<MethodInfoElement>())).Returns(visitor);
            sut.ToMock().Setup(x => x.Visit(It.IsAny<EventInfoElement>())).Returns(visitor);

            var actual = sut.Visit(type.ToElement());

            Assert.Equal(visitor, actual);
            Assert.Equal(expected.OrderBy(x => x.ToString()), sut.Value.OrderBy(x => x.ToString()));
        }

        public void VisitPropertyInfoElementsCallsBaseMethod()
        {
            var sut = new Mock<ReferenceCollector> { CallBase = true }.Object;
            var visitor = new DelegatingReflectionVisitor<IEnumerable<Assembly>>();
            sut.ToMock().Setup(x => x.Visit(It.IsAny<PropertyInfoElement>())).Returns(visitor);
            var propertyInfoElements = typeof(ClassWithMembers).GetProperties(Bindings)
                .Select(x => x.ToElement()).ToArray();

            var actual = sut.Visit(propertyInfoElements);

            Assert.Equal(visitor, actual);
        }

        public void VisitMethodInfoElementCollectsCorrectAssembliesForMethodCallInMethodBody()
        {
            var visitor = new DelegatingReflectionVisitor<IEnumerable<Assembly>>();
            var sut = new Mock<ReferenceCollector> { CallBase = true }.Object;
            sut.ToMock().Setup(x => x.Visit(It.IsAny<ParameterInfoElement>())).Returns(visitor);
            sut.ToMock().Setup(x => x.Visit(It.IsAny<LocalVariableInfoElement>())).Returns(visitor);
            var expected = new[]
            {
                typeof(IDisposable).Assembly,
                typeof(Enumerable).Assembly
            };
            var methodInfoElement = new Methods<ClassForCollectingReference>()
                .Select(x => x.MethodCallInMethodBody()).ToElement();

            sut.Visit(methodInfoElement);

            Assert.Equal(expected.OrderBy(x => x.ToString()), sut.Value.OrderBy(x => x.ToString()));
        }

        public void VisitMethodInfoElementCollectsAssembliesFromBaseMethod()
        {
            var references = new[] { typeof(ISet<>).Assembly };
            var sut = new Mock<MemberReferenceCollector> { CallBase = true }.Object;
            sut.ToMock().Setup(x => x.Visit(It.IsAny<ParameterInfoElement[]>())).Returns(sut);
            sut.ToMock().Setup(x => x.Visit(It.IsAny<LocalVariableInfoElement[]>()))
                .Returns(new MemberReferenceCollector(references));
            var expected = new[]
            {
                typeof(ClassImplementingMultiple).Assembly,
                typeof(IDisposable).Assembly,
                typeof(ISpecimenContext).Assembly,
                references[0]
            };
            var dummyMethodInfoElement = new Methods<ClassForCollectingReference>()
                .Select(x => x.ReturnMethod()).ToElement();

            var actual = sut.Visit(dummyMethodInfoElement);

            sut.ToMock().VerifyAll();
            Assert.Equal(
                expected.OrderBy(x => x.ToString()),
                actual.Value.OrderBy(x => x.ToString()));
        }