C# Mock.SetupSet方法代码示例

        public void post_CallsPopulateRequestParameters()
        {
            // Arrange
            var testBundle = new AddImageRequestTestBundle();
            var mockWebRequest = new Mock<IWebRequest>(MockBehavior.Strict);
            var mockLog = new Mock<ILog>();

            testBundle.MockLogProvider.Setup(x => x.GetLogger(It.IsAny<Type>())).Returns(mockLog.Object);
            testBundle.AddImageRequest.FileBytes = new byte[] {1, 2, 3};
            testBundle.AddImageRequest.FileName = "Test.foo";
            testBundle.AddImageRequest.RequestUrl = "http://google.com/";

            mockWebRequest.SetupSet(x => x.Method = "POST");
            mockWebRequest.SetupSet(x => x.ContentType = "application/x-www-form-urlencoded");
            mockWebRequest.SetupSet(x => x.ContentLength = 30);
            mockWebRequest.SetupGet(x => x.Headers).Returns(new WebHeaderCollection());
            mockWebRequest.Setup(x => x.GetRequestStream()).Returns(new MemoryStream());
            mockWebRequest.Setup(x => x.GetResponse()).Returns(new Mock<IHttpWebResponse>().Object);
            testBundle.MockWebRequestFactory.Setup(x => x.Create(It.IsAny<string>())).Returns(mockWebRequest.Object);
            // WebRequestFactory.AddWebRequestMock(mockWebRequest.Object);

            // Act
            testBundle.AddImageRequest.Post();

            // Assert
            Assert.AreEqual("http://google.com/image", testBundle.AddImageRequest.RequestUrl);
        }

        public void ExecuteResult()
        {
            // Arrange
            string content = "Some content.";
            string contentType = "Some content type.";
            Encoding contentEncoding = Encoding.UTF8;

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(content)).Verifiable();

            ContentResult result = new ContentResult
            {
                Content = content,
                ContentType = contentType,
                ContentEncoding = contentEncoding
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        public void op_ExecuteResult_ControllerContext()
        {
            var response = new Mock<HttpResponseBase>(MockBehavior.Strict);
            response
                .SetupSet(x => x.ContentEncoding = Encoding.UTF8)
                .Verifiable();
            response
                .SetupSet(x => x.ContentType = "application/xml")
                .Verifiable();
            response
                .Setup(x => x.Write(It.IsAny<string>()))
                .Verifiable();

            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
            context
                .SetupGet(x => x.Response)
                .Returns(response.Object)
                .Verifiable();

            new XmlSerializationResult(123).ExecuteResult(new ControllerContext
                                                              {
                                                                  HttpContext = context.Object
                                                              });

            response.VerifyAll();
        }

        public void Should_be_able_prepare_a_query()
        {
            const string sql = "select @Id";

            var guid = Guid.NewGuid();
            var mc = new MappedColumn<Guid>("Id", DbType.Guid);
            var query = new RawQuery(sql).AddParameterValue(mc, guid);
            var dataParameterCollection = new Mock<IDataParameterCollection>();
            var dataParameterFactory = new Mock<IDbDataParameterFactory>();

            dataParameterFactory.Setup(m => m.Create("@Id", DbType.Guid, guid));

            var dataSource = new DataSource("data-source", dataParameterFactory.Object);

            var command = new Mock<IDbCommand>();

            dataParameterCollection.Setup(m => m.Add(It.IsAny<IDbDataParameter>())).Verifiable();

            command.SetupGet(m => m.Parameters).Returns(dataParameterCollection.Object);
            command.SetupSet(m => m.CommandText = sql).Verifiable();
            command.SetupSet(m => m.CommandType = CommandType.Text).Verifiable();

            query.Prepare(dataSource, command.Object);

            command.VerifyAll();
            dataParameterFactory.VerifyAll();
        }

        public void op_ExecuteResult_ControllerContext()
        {
            var response = new Mock<HttpResponseBase>(MockBehavior.Strict);
            response
                .SetupSet(x => x.ContentEncoding = Encoding.UTF8)
                .Verifiable();
            response
                .SetupSet(x => x.ContentType = "text/plain")
                .Verifiable();
            response
                .Setup(x => x.Write(It.IsAny<string>()))
                .Verifiable();

            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
            context
                .Setup(x => x.Response)
                .Returns(response.Object)
                .Verifiable();

            new TextResult("test").ExecuteResult(new ControllerContext
                                                     {
                                                         HttpContext = context.Object
                                                     });

            context.VerifyAll();
        }

        public void op_OnActionExecuting_FilterExecutedContext()
        {
            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
            context
                .SetupSet(x => x.Response.BufferOutput = true)
                .Verifiable();
            context
                .SetupSet(x => x.Response.Filter = It.IsAny<WrappedStream>())
                .Verifiable();

            using (var stream = new MemoryStream())
            {
                context
                    .SetupGet(x => x.Response.Filter)
                    .Returns(stream)
                    .Verifiable();

                new ContentMD5Attribute().OnActionExecuting(new ActionExecutingContext
                                                                {
                                                                    HttpContext = context.Object
                                                                });
            }

            context.VerifyAll();
        }

        public void ExecuteResult()
        {
            // Arrange
            object data = _jsonData;
            string contentType = "Some content type.";
            Encoding contentEncoding = Encoding.UTF8;

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(_jsonSerializedData)).Verifiable();

            JsonResult result = new JsonResult
            {
                Data = data,
                ContentType = contentType,
                ContentEncoding = contentEncoding
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        public void ExecuteResultWithDescription() {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusCode = 666).Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusDescription = "Foo Bar").Verifiable();
            HttpStatusCodeResult result = new HttpStatusCodeResult(666, "Foo Bar");

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        protected Mock<IRestClient> GetMockClient(string content)
        {
            var response = new Mock<IRestResponse>(MockBehavior.Strict);
            response.SetupGet(x => x.Content).Returns(content);
            response.SetupGet(x => x.ResponseUri).Returns(new Uri("http://google.com"));
            response.SetupGet(x => x.StatusDescription).Returns("");
            response.SetupGet(x => x.StatusCode).Returns(HttpStatusCode.OK);

            var client = new Mock<IRestClient>(MockBehavior.Strict);
            client.SetupSet(x => x.BaseUrl = It.IsAny<Uri>());
            client.SetupSet(x => x.Authenticator = It.IsAny<IAuthenticator>());
            client.Setup(x => x.Execute(It.IsAny<IRestRequest>())).Returns(response.Object);
            return client;
        }

        public void ExecuteResult() {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusCode = 401).Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusDescription = "Some description").Verifiable();

            HttpUnauthorizedResult result = new HttpUnauthorizedResult("Some description");

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        public void AddingExceptionShouldStoreExceptionInLoggingEvent()
        {
            var loggingEventMock = new Mock<LoggingEvent>();
            loggingEventMock.Object.Tags = new List<string>();

            var loggingEventBuilder = new LoggingEventBuilder(loggingEventMock.Object);

            loggingEventMock.SetupSet(x => x.Text = It.Is<string>(v => v == "exceptionmessage"));
            loggingEventMock.Setup(x => x.Tags.Add(It.Is<string>(v => v == "error")));
            loggingEventMock.SetupSet(x => x.Data["MS_Exception"] = It.IsAny<ExceptionInformation>());

            loggingEventBuilder.AddException(new Exception("exceptionmessage"));

            loggingEventMock.VerifyAll();
        }

 public void SafeResetKeyBindings2()
 {
     var mock = new Mock<Command>(MockBehavior.Strict);
     mock.SetupSet(x => x.Bindings = It.IsAny<object>()).Throws(new COMException()).Verifiable();
     mock.Object.SafeResetBindings();
     mock.Verify();
 }

        public void GetRecommendations_PerformsCorrectRequest()
        {
            //Setup
            UserReqStub request = new UserReqStub("ExternalID", "DevKey", "api.careerbuilder.com", "", "");

            //Mock crap
            RestResponse<List<RecommendJobResult>> response = new RestResponse<List<RecommendJobResult>>();
            response.Data = new List<RecommendJobResult>();
            
            var restReq = new Mock<IRestRequest>();
            restReq.Setup(x => x.AddParameter("DeveloperKey", "DevKey"));
            restReq.Setup(x => x.AddParameter("ExternalID", "ExternalID"));
            restReq.SetupSet(x => x.RootElement = "RecommendJobResults");

            var restClient = new Mock<IRestClient>();
            restClient.SetupSet(x => x.BaseUrl = "https://api.careerbuilder.com/v1/recommendations/foruser");
            restClient.Setup(x => x.Execute<List<RecommendJobResult>>(It.IsAny<IRestRequest>())).Returns(response);

            request.Request = restReq.Object;
            request.Client = restClient.Object;

            //Assert//
            List<RecommendJobResult> resp = request.GetRecommendations();
            restReq.VerifyAll();
            restClient.VerifyAll();
        }

        public void TestWritingResponse()
        {
            TokenResponse response = new TokenResponse
            {
                Body = "body",
                HttpStatusCode = 200
            };

            Mock<HttpResponseBase> mckResponse = new Mock<HttpResponseBase>();
            mckResponse.SetupSet(x => x.ContentType = "application/json");
            mckResponse.SetupSet(x => x.StatusCode = 200);
            mckResponse.Setup(x => x.Write("body"));
            TokenResponseWriter writer = new TokenResponseWriter(mckResponse.Object);
            writer.WriteResponse(response);
            mckResponse.VerifyAll();
        }

        public void Search_PerformsCorrectRequest()
        {
            //Setup
            JobSearchStub request = new JobSearchStub("DevKey", "api.careerbuilder.com","","");
            
            //Mock crap
            RestResponse<ResponseJobSearch> response = new RestResponse<ResponseJobSearch>();
            response.Data = new ResponseJobSearch();
                        
            var restReq = new Mock<IRestRequest>();
            restReq.Setup(x => x.AddParameter("DeveloperKey", "DevKey"));
            restReq.Setup(x => x.AddParameter("CountryCode", "NL"));
            restReq.SetupSet(x => x.RootElement = "ResponseJobSearch");

            var restClient = new Mock<IRestClient>();
            restClient.SetupSet(x => x.BaseUrl = "https://api.careerbuilder.com/v1/jobsearch");
            restClient.Setup(x => x.Execute<ResponseJobSearch>(It.IsAny<IRestRequest>())).Returns(response);

            request.Request = restReq.Object;
            request.Client = restClient.Object;
            
            //Assert
            ResponseJobSearch resp = request.WhereCountryCode(CountryCode.NL).Search();
            restReq.Verify();
            restClient.VerifyAll();
        }