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

        public void ActivateAd_ActivationTokenDoesNotWork_ReturnModelIsActivatedFalse()
        {
            // Given
            BaseAd ad = new Ad()
            {
                IsActivated = false,
                ActivationToken = "AAA"
            };
            long adId = 78;

            var repoMock = new Moq.Mock<IRepository>();
            repoMock.Setup(x => x.Get<BaseAd>(adId)).Returns(ad);

            AdActivationServices service = new AdActivationServices(repoMock.Object, null, null, null);

            // When
            AdActivationResultModel model = service.ActivateAd(adId, "BBB");

            // Then
            Assert.IsFalse(model.IsActivated);
            Assert.AreEqual(78, model.AdId);
            Assert.AreEqual("Vous ne pouvez pas activer cette annonce.", model.InfoMessage);

            repoMock.Verify(x => x.Save(ad), Moq.Times.Never());
            repoMock.Verify(x => x.Save(Moq.It.IsAny<SearchAdCache>()), Moq.Times.Never());
        }

		public void shouldHaveSynchronizeWithGoogleFunction() {
			var avegaContactServiceMock = new Moq.Mock<IAvegaContactService>();
			avegaContactServiceMock.Setup(x => x.SynchronizeWithGoogleContact(It.IsAny<AvegaContact>()))
				.Returns(new SynchronizationStatus(true, false, false));

			var avetaContactService = avegaContactServiceMock.Object;
			avetaContactService.SynchronizeWithGoogleContact(new AvegaContact("MyContact"));

			avegaContactServiceMock.Verify();
		}

        public void ActivateAd_ActivationTokenWorks_ReturnModelIsActivatedTrueAndActivatesAd()
        {
            // Given
            BaseAd ad = new Ad()
            {
                IsActivated = false,
                ActivationToken = "AAA",
                City = new City(),
                Category = new Category()
            };
            long adId = 78;

            var repoMock = new Moq.Mock<IRepository>();
            repoMock.Setup(x => x.Get<BaseAd>(adId)).Returns(ad);

            AdActivationServices service = new AdActivationServices(repoMock.Object, null, null, null);

            // When
            AdActivationResultModel model = service.ActivateAd(78, "AAA");

            // Then
            Assert.IsTrue(model.IsActivated);
            Assert.AreEqual(78, model.AdId);
            Assert.AreEqual("Merci d'avoir activé votre annonce.", model.InfoMessage);

            repoMock.Verify(x => x.Save(ad), Moq.Times.Once());
            repoMock.Verify(x => x.Save(Moq.It.IsAny<SearchAdCache>()), Moq.Times.Once());
        }

		public void shouldBeAbleToGetAllAvegaContact() {
			var avegaContactServiceMock = new Moq.Mock<IAvegaContactService>();
			avegaContactServiceMock.Setup(x => x.GetAllContacts())
				.Returns(new List<AvegaContact>());

			var avetaContactService = avegaContactServiceMock.Object;
			avetaContactService.GetAllContacts();

			avegaContactServiceMock.Verify();
		}

        public void CancelAsync()
        {
            var element = new ImportNetworkElement();
            var mockMyFx = new Moq.Mock<IImportNetworkFx>();

            mockMyFx.Setup(m => m.CancelAsync());

            element.Fx = mockMyFx.Object;
            element.Cancel();
            mockMyFx.Verify(m => m.CancelAsync(), Times.Exactly(1));
        }

        public void ReadTransactionsFromFile_Valid_ObserverNeverCalled()
        {
            var mockObserver = new Moq.Mock<Observer>();
            List<Observer> ol = new List<Observer>();
            ol.Add(mockObserver.Object);
            List<Product> listOfProducts = new List<Product>();
            TransactionManager tm = new TransactionManager(ol, listOfProducts);

            tm.ReadTransactionsFromFile(new StreamReader(@"C:\Users\vbhujan\Documents\Cart.txt"));

            mockObserver.Verify(o => o.update(), Times.Never);
        }

        public void SafeDisposal()
        {
            var exceptionHandler = new Moq.Mock<IExceptionHandler>(MockBehavior.Strict);
            exceptionHandler.Setup(x => x.Warn(It.IsAny<Exception>())).Returns<Exception>(x => x).Verifiable();

            ExceptionHandler.Initialise(exceptionHandler.Object);

            var t = new ThrowingDisposableObject();
            t.Dispose();

            Assert.That(t.DisposeUnmanagedResourcesCount, Is.EqualTo(1));
            Assert.That(t.DisposeManagedResourcesCount, Is.EqualTo(1));
            exceptionHandler.Verify(x => x.Warn(It.IsAny<Exception>()), Times.Once());
        }

        public void AggregateBus_ShouldSubscribeWhenConfigured()
        {
            var eventBus = new Moq.Mock<IEventBus>();
            eventBus.Setup(e => e.Subscribe<AggregateCacheCleared>(Moq.It.IsAny<Func<AggregateCacheCleared, Task>>())).Verifiable();
            var aggregateCache = new Moq.Mock<IAggregateCache>();
            //aggregateCache.Setup(x => x.Clear(Moq.It.IsAny<Guid>(), Moq.It.IsAny<Type>())).Verifiable();

            AggregateBus.Instance.Configure(eventBus.Object, aggregateCache.Object);

            AggregateBus.Instance.RegisteredAggregateCaches.Should().NotBeNull();
            AggregateBus.Instance.RegisteredAggregateCaches.Contains(aggregateCache.Object).Should().BeTrue();

            eventBus.Verify(e => e.Subscribe<AggregateCacheCleared>(Moq.It.IsAny<Func<AggregateCacheCleared, Task>>()), Moq.Times.Once);
        }

        public void RequestHandlerRetriesTest()
        {
            //This statement will fail, then we will fake the syntax error as a ReadTimeout
            var statement = new SimpleStatement("SELECT WILL FAIL").SetRetryPolicy(DowngradingConsistencyRetryPolicy.Instance);
            var request = Session.GetRequest(statement);
            //We will need a mock to fake the responses of Cassandra
            var mock = new Moq.Mock<RequestHandler<RowSet>>(Session, request, statement);
            var requestHandler = mock.Object;
            //Expect Retry method to be called with a lower consistency level
            mock.Setup(r => r.Retry(It.Is<ConsistencyLevel?>(c => c == ConsistencyLevel.Two))).Verifiable();
            //Fake a Error Result
            requestHandler.ResponseHandler(new ReadTimeoutException(ConsistencyLevel.Three, 2, 3, false), null);

            mock.Verify();
        }

		public async Task Add_new_task()
		{
			// arrange
			var newTask = new TodoItem() { Completed = false, Title = "Test 3" };
			var serviceMock = new Moq.Mock<ITodoService>();
			serviceMock.Setup(x => x.AddAsync(newTask)).ReturnsAsync(newTask);
			var controller = new TodoController(serviceMock.Object);

			// act
			var result = await controller.AddTodo(newTask);

			// assert
			serviceMock.Verify(x => x.AddAsync(newTask), Times.Once);
			Assert.NotNull(result);
			Assert.Equal(newTask, result);
		}

		public async Task Status_not_found_when_deleting_task_that_does_not_exist()
		{
			// arrange
			var taskId = 1;
			var serviceMock = new Moq.Mock<ITodoService>();
			serviceMock.Setup(x => x.DeleteAsync(taskId)).ReturnsAsync(false);
			var controller = new TodoController(serviceMock.Object);

			// act
			var result = await controller.DeleteTodo(taskId);

			// assert
			serviceMock.Verify(x => x.DeleteAsync(taskId), Times.Once);
			Assert.NotNull(result);
			Assert.Equal(HttpStatusCode.NotFound, result.StatusCode);
		}

		public async Task Delete_task()
		{
			// arrange
			var taskId = 1;
			var serviceMock = new Moq.Mock<ITodoService>();
			serviceMock.Setup(x => x.DeleteAsync(taskId)).ReturnsAsync(true);
			var controller = new TodoController(serviceMock.Object);

			// act
			var result = await controller.DeleteTodo(taskId);

			// assert
			serviceMock.Verify(x => x.DeleteAsync(taskId), Times.Once);
			Assert.NotNull(result);
			Assert.Equal(HttpStatusCode.OK, result.StatusCode);
		}

		public async Task Change_completeness_of_task()
		{
			// arrange
			var existingTask = new TodoItem() { Id = 2, Completed = true, Title = "Test 1" };
			var serviceMock = new Moq.Mock<ITodoService>();
			serviceMock.Setup(x => x.UpdateAsync(existingTask.Id, existingTask)).ReturnsAsync(existingTask);
			var controller = new TodoController(serviceMock.Object);

			// act
			var result = await controller.UpdateTodo(existingTask.Id, existingTask);

			// assert
			serviceMock.Verify(x => x.UpdateAsync(existingTask.Id, existingTask), Times.Once);
			Assert.NotNull(result);
			Assert.Equal(existingTask, result);
		}

		public void Status_not_found_when_changing_task_that_does_not_exist()
		{
			// arrange
			var taskId = 4;
			var existingTask = new TodoItem() { Id = 2, Completed = false, Title = "Test 3" };
			var serviceMock = new Moq.Mock<ITodoService>();
			serviceMock.Setup(x => x.UpdateAsync(taskId, existingTask)).ReturnsAsync(null);
			var controller = new TodoController(serviceMock.Object);

			// act
			var exc = Assert.Throws<AggregateException>(() => controller.UpdateTodo(taskId, existingTask).Result);
			var result = exc.InnerExceptions.Cast<HttpResponseException>().FirstOrDefault();

			// assert
			serviceMock.Verify(x => x.UpdateAsync(taskId, existingTask), Times.Once);
			Assert.NotNull(result);
			Assert.Equal(HttpStatusCode.NotFound, result.Response.StatusCode);
		}

		public void shouldReportBackContactFetchProgress() {
			var avegaClientRepositoryMock = new Moq.Mock<IAvegaClientRepository>();
			avegaClientRepositoryMock.Setup(x => x.GetAll())
				.Returns(new List<AvegaContact>(new[] { new AvegaContact("DisplayName"), new AvegaContact("DisplayName") }));

			var avegaClientRepository = avegaClientRepositoryMock.Object;

			avegaClientRepository.ContactDataFetched += (sender, ev) => {
				Console.WriteLine(ev.TotalContacts);
				Console.WriteLine(ev.CurrentContactIndex);
				switch (ev.DataFetched) {
					case DataFetchedType.Image: break;
					case DataFetchedType.ContactInformation: break;
				}
			};

			avegaClientRepository.GetAll();
			avegaClientRepositoryMock.Verify();
		}