C# Moq.Mock.SetupGet方法代码示例

		public static Mock<IPublishedContent> Content(string name, IEnumerable<IPublishedContent> children)
		{
			var mockedItem = new Moq.Mock<IPublishedContent>();
			mockedItem.SetupGet(m => m.Id).Returns(1);
			mockedItem.SetupGet(m => m.Name).Returns(name);
			mockedItem.SetupGet(m => m.Children).Returns(children);

			return mockedItem;
		}

        public void Setup()
        {
            var httpContextBaseMock = new Moq.Mock<HttpContextBase>();

            var httpRequestBase = new Moq.Mock<HttpRequestBase>();
            httpRequestBase.SetupGet(r => r.ApplicationPath).Returns(@"\");
            httpContextBaseMock.SetupGet(c => c.Items).Returns(new Dictionary<string, object>());
            httpRequestBase.SetupGet(r => r.Cookies).Returns(new HttpCookieCollection());
            httpRequestBase.Object.Cookies.Add(new HttpCookie(GlimpseConstants.CookieModeKey, "On"));

            httpContextBaseMock.SetupGet(c => c.Request).Returns(httpRequestBase.Object);
            httpContext = httpContextBaseMock.Object;
        }

        public void TickTaskWithRemainingTime()
        {
            var result = new Moq.Mock<ITaskResult>(MockBehavior.Strict);
            var mock = new Moq.Mock<ITask>(MockBehavior.Strict);

            mock.Setup(x => x.Execute()).Returns(result.Object);
            result.SetupGet(f => f.TimeRemaining).Returns(1);

            var queue = new TaskQueue();
            queue.Add(mock.Object);

            var count = queue.Tick();
            Assert.That(count, Is.EqualTo(0));
            Assert.That(queue.Count, Is.EqualTo(1));
        }

        public void ReadsCorrectly()
        {
            // arrange
            var converter = new EnumConverter();
            var reader1 = new Moq.Mock<JsonReader>();
            reader1.SetupGet(x => x.Value).Returns(null);
            var reader2 = new Moq.Mock<JsonReader>();
            reader2.SetupGet(x => x.Value).Returns("0");
            var reader3 = new Moq.Mock<JsonReader>();
            reader3.SetupGet(x => x.Value).Returns("1");

            // act
            var object1 = converter.ReadJson(reader1.Object, typeof(System.ConsoleColor), null, null);
            var object2 = converter.ReadJson(reader1.Object, typeof(System.ConsoleColor?), null, null);
            var object3 = converter.ReadJson(reader2.Object, typeof(System.ConsoleColor), null, null);
            var object4 = converter.ReadJson(reader3.Object, typeof(System.ConsoleColor), null, null);

            // assert
            Assert.IsNull(object1);
            Assert.IsNull(object2);
            Assert.AreEqual(System.ConsoleColor.Black, (System.ConsoleColor)object3);
            Assert.AreEqual(System.ConsoleColor.DarkBlue, (System.ConsoleColor)object4);
        }

        public void ReadsCorrectly()
        {
            // arrange
            var converter = new BoolConverter();
            var reader1 = new Moq.Mock<JsonReader>();
            reader1.SetupGet(x => x.Value).Returns(null);
            var reader2 = new Moq.Mock<JsonReader>();
            reader2.SetupGet(x => x.Value).Returns("0");
            var reader3 = new Moq.Mock<JsonReader>();
            reader3.SetupGet(x => x.Value).Returns("1");

            // act
            var object1 = converter.ReadJson(reader1.Object, typeof(bool), null, null);
            var object2 = converter.ReadJson(reader1.Object, typeof(bool?), null, null);
            var object3 = converter.ReadJson(reader2.Object, typeof(bool), null, null);
            var object4 = converter.ReadJson(reader3.Object, typeof(bool), null, null);

            // assert
            Assert.IsAssignableFrom<bool>(object1);
            Assert.IsFalse((bool)object1);
            Assert.IsNull(object2);
            Assert.IsFalse((bool)object3);
            Assert.IsTrue((bool)object4);
        }

        public void ProcessLimitsTest(
      string configurationName,
      SLimits limits, 
      bool logStatistic, 
      int apiUsageThreshold, 
      int dataStorageThreshold,
      Times[] result)
        {
            var mockedApiDailyRequestsLoger = new Moq.Mock<ILimitLoger>();
              if (limits != null)
              {
            var apiDailyRequestsLoger = new ApiDailyRequestsLoger(configurationName, limits.DailyApiRequests);
            mockedApiDailyRequestsLoger.SetupGet(p => p.UsedAmount).Returns(apiDailyRequestsLoger.UsedAmount);
            mockedApiDailyRequestsLoger.SetupGet(p => p.UsedPercents).Returns(apiDailyRequestsLoger.UsedPercents);
              }

              mockedApiDailyRequestsLoger.Setup(m => m.LogPointWarning()).Verifiable();
              mockedApiDailyRequestsLoger.Setup(m => m.LogHasReachedError()).Verifiable();

              var mockedDataStorageLoger = new Moq.Mock<ILimitLoger>();
              if (limits != null)
              {
            var dataStorageLoger = new ApiDailyRequestsLoger(configurationName, limits.DataStorageMb);
            mockedDataStorageLoger.SetupGet(p => p.UsedAmount).Returns(dataStorageLoger.UsedAmount);
            mockedDataStorageLoger.SetupGet(p => p.UsedPercents).Returns(dataStorageLoger.UsedPercents);
              }

              mockedDataStorageLoger.Setup(m => m.LogPointWarning()).Verifiable();
              mockedDataStorageLoger.Setup(m => m.LogHasReachedError()).Verifiable();

              var mockedLoger = new Moq.Mock<ILimitsLoger>();
              mockedLoger.SetupGet(p => p.ApiDailyRequestsLoger).Returns(mockedApiDailyRequestsLoger.Object);
              mockedLoger.SetupGet(p => p.DataStorageLoger).Returns(mockedDataStorageLoger.Object);
              mockedLoger.Setup(m => m.LogStatisticInfo()).Verifiable();
              mockedLoger.Setup(m => m.LogInformationAreNotAvailableWarning()).Verifiable();

              var agent = new LimitsAgent();
              agent.LogStatistic = logStatistic;
              agent.ApiUsageThreshold = apiUsageThreshold;
              agent.DataStorageThreshold = dataStorageThreshold;
              var logerField = typeof(LimitsAgent).GetField("loger", BindingFlags.Instance | BindingFlags.NonPublic);
              if (logerField != null)
              {
            logerField.SetValue(agent, mockedLoger.Object);
              }

              agent.ProcessLimits(limits);

              mockedLoger.Verify(m => m.LogStatisticInfo(), result[0]);
              mockedLoger.Verify(m => m.LogInformationAreNotAvailableWarning(), result[1]);
              mockedApiDailyRequestsLoger.Verify(m => m.LogPointWarning(), result[2]);
              mockedApiDailyRequestsLoger.Verify(m => m.LogHasReachedError(), result[3]);
              mockedDataStorageLoger.Verify(m => m.LogPointWarning(), result[4]);
              mockedDataStorageLoger.Verify(m => m.LogHasReachedError(), result[5]);
        }

            public EventControllerBuilder WithUserLogged()
            {
                var httpContext = new Mock<HttpContext>();

                var controllerContext = new Mock<ControllerContext>();
                var principal = new Moq.Mock<ClaimsPrincipal>();


                principal.Setup(p => p.IsInRole("Administrator")).Returns(true);
                principal.SetupGet(x => x.Identity.Name).Returns("userName");

                httpContext.Setup(x => x.User).Returns(principal.Object);
                controllerContext.Object.HttpContext = httpContext.Object;
                _controllerContext = controllerContext.Object;

                return this;
            }

        internal MockResults SetupHttpAbstractionMocking()
        {
            var results = new MockResults();
            // Locate the test manager so we can override the lower layer.
            var manager = ServiceLocator.Instance.Locate<IServiceLocationIndividualTestManager>();

            // Create a Mock of the HTTP layer response.
            var moqResponse = new Moq.Mock<IHttpResponseMessageAbstraction>(MockBehavior.Loose);
            // Always return 200 OK
            moqResponse.SetupGet(res => res.StatusCode)
                       .Returns(HttpStatusCode.OK);

            // Create a mock of the Request client.
            var moqClient = new Moq.Mock<IHttpClientAbstraction>(MockBehavior.Loose);

            // Mock the return to set the request headers.
            moqClient.SetupGet(client => client.RequestHeaders)
                     .Returns(() => results.Headers);

            // Mock the return to set the request uri.
            moqClient.SetupGet(client => client.RequestUri)
                     .Returns(() => results.RequestUri);

            // Mock the return to set the request uri.
            moqClient.SetupSet(abstraction => abstraction.RequestUri = It.IsAny<Uri>()).Callback<Uri>(uri => results.RequestUri = uri);

            // Mock the return to set the http method.
            moqClient.SetupGet(client => client.Method)
                     .Returns(() => results.Method);

            // Mock the return to set the http method.
            moqClient.SetupSet(abstraction => abstraction.Method = It.IsAny<HttpMethod>()).Callback<HttpMethod>(method => results.Method = method);

            // Mock the return to set the content.
            moqClient.SetupGet(client => client.Content)
                     .Returns(() => results.Content);

            moqClient.SetupSet(abstraction => abstraction.Content = It.IsAny<HttpContent>()).Callback<HttpContent>(content => results.Content = content);

            // Mock the SendAsync method (to just return the response object previously created).
            moqClient.Setup(c => c.SendAsync())
                     .Returns(() => Task.Run(() =>
                     {
                         results.SendAsyncCalled = true;
                         return moqResponse.Object;
                     }));

            // Mock the factory to return our mock client.
            var moqFactory = new Moq.Mock<IHttpClientAbstractionFactory>();

            // Overload both create methods.
            moqFactory.Setup(fac => fac.Create(It.IsAny<X509Certificate2>(), It.IsAny<HDInsight.IAbstractionContext>(), false))
                      .Returns(() => moqClient.Object);
            moqFactory.Setup(fac => fac.Create(It.IsAny<HDInsight.IAbstractionContext>(), false))
                      .Returns(() => moqClient.Object);

            // Override the factory in the Service Locator (for this test only).
            manager.Override<IHttpClientAbstractionFactory>(moqFactory.Object);
           
            return results;
        }