public void Should_ReturnAnErrorResponse_When_ItemRepositoryThrowsAnException()
{
//Arrange
var itemDto = BuildFirstItemDtoWithoutId();
var item = BuildFirstItemWithoutId();
MapperMock.Setup(c => c.Map <ItemDto, Item>(itemDto))
.Returns(item);
var saveObject = new Item();
ItemsRepositoryMock.Setup(c => c.Add(It.IsAny <Item>()))
.Callback <Item>((obj) => saveObject = obj);
ItemsRepositoryMock.Setup(c => c.SaveChanges())
.Throws(new Exception());
//Act
var result = ItemsDataService.AddItem("ab70793b-cec8-4eba-99f3-cbad0b1649d0", itemDto);
//Assert
AssertHelper.AssertAll(
() => result.IsSuccess.Should().BeFalse(),
() => result.ErrorMessage.Should().Be("An error occurred while creating item")
);
}
public void Should_AddItem_When_InputParametersAreValid()
{
//Arrange
var itemDto = BuildFirstItemDtoWithoutId();
var item = BuildFirstItemWithoutId();
MapperMock.Setup(c => c.Map <ItemDto, Item>(itemDto))
.Returns(item);
var saveObject = new Item();
ItemsRepositoryMock.Setup(c => c.Add(It.IsAny <Item>()))
.Callback <Item>((obj) => saveObject = obj);
ItemsRepositoryMock.Setup(c => c.SaveChanges());
//Act
var result = ItemsDataService.AddItem("ab70793b-cec8-4eba-99f3-cbad0b1649d0", itemDto);
//Assert
AssertHelper.AssertAll(
() => saveObject.Id.Should().Be(0),
() => saveObject.Name.Should().Be("Bread"),
() => saveObject.NextReplenishmentDate.Should().BeSameDateAs(new DateTime(2020, 10, 06)),
() => saveObject.ReplenishmentPeriod.Should().Be(1)
);
}
public void Should_ReturnASuccessResponse_When_InputParametersAreValid()
{
//Arrange
var itemDto = BuildFirstItemDtoWithoutId();
var item = BuildFirstItemWithoutId();
MapperMock.Setup(c => c.Map <ItemDto, Item>(itemDto))
.Returns(item);
var saveObject = new Item();
ItemsRepositoryMock.Setup(c => c.Add(It.IsAny <Item>()))
.Callback <Item>((obj) => saveObject = obj);
ItemsRepositoryMock.Setup(c => c.SaveChanges());
//Act
var result = ItemsDataService.AddItem("ab70793b-cec8-4eba-99f3-cbad0b1649d0", itemDto);
//Assert
AssertHelper.AssertAll(
() => result.IsSuccess.Should().BeTrue(),
() => result.ErrorMessage.Should().BeNull()
);
}
public void Should_CheckForUserIdEmptyBeforeOtherMethodCalls_When_UserIdIsEmptyString()
{
//Arrange
var itemDto = BuildFirstItemDtoWithoutId();
var item = BuildFirstItemWithoutId();
MapperMock.Setup(c => c.Map <ItemDto, Item>(itemDto))
.Returns(item);
var saveObject = new Item();
ItemsRepositoryMock.Setup(c => c.Add(It.IsAny <Item>()))
.Callback <Item>((obj) => saveObject = obj);
ItemsRepositoryMock.Setup(c => c.SaveChanges());
//Act
var result = ItemsDataService.AddItem(string.Empty, itemDto);
//Assert
AssertHelper.AssertAll(
() => MapperMock.Verify(x => x.Map <ItemDto, Item>(It.IsAny <ItemDto>()), Times.Never()),
() => ItemsRepositoryMock.Verify(x => x.Add(It.IsAny <Item>()), Times.Never()),
() => ItemsRepositoryMock.Verify(x => x.SaveChanges(), Times.Never())
);
}
public async void Should_Return_OkObjectResult_with_one_leaderboard()
{
//Arrange
var expectedResult = new LeaderBoard()
{
LeaderBoardId = 1
};
var finalResult = new LeaderBoardResponse()
{
LeaderBoardId = 1
};
LeaderBoardRepository
.Setup(x => x.Get(expectedResult.LeaderBoardId))
.ReturnsAsync(expectedResult).Verifiable();
UnitofWorkMock
.Setup(m => m.LeaderBoard)
.Returns(LeaderBoardRepository.Object);
MapperMock
.Setup(m => m.Map <LeaderBoardResponse>(expectedResult))
.Returns(finalResult);
//Act
var result = await _uut.Get(expectedResult.LeaderBoardId);
//Assert
LeaderBoardRepository.Verify();
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(finalResult, okResult.Value);
}
public async void Should_return_ok()
{
// Arrange
var bookDto = new BookDto
{
Title = "The Wind in the Willows",
Rating = 5.8,
YearPublished = new DateTime(1970, 1, 1),
YearRead = DateTime.Now
};
var book = new Book
{
Title = "The Wind in the Willows",
Rating = 5.8,
YearPublished = new DateTime(1970, 1, 1),
DateRead = DateTime.Now
};
var toUpdate = MapperMock
.Setup(x => x.Map <Book>(bookDto))
.Returns(book);
var result = new Result();
BasicBookServiceMock
.Setup(x => x.UpdateBookAsync(book))
.ReturnsAsync(result);
// Act
var requestResult = await ControllerUnderTest.UpdateBook(bookDto);
// Assert
var okResult = Assert.IsType <OkObjectResult>(requestResult);
Assert.Equal((int)HttpStatusCode.OK, okResult.StatusCode);
Assert.Equal(result, okResult.Value);
}
public async Task Post_Success(int rateValue, string comment)
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var user = NewDatas.NewUser();
var product = NewDatas.NewProduct();
var rating = NewDatas.NewRating();
rating.User = user;
rating.Product = product;
dbContext.Products.Add(product);
await dbContext.SaveChangesAsync();
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
dbContext.Ratings.Add(rating);
await dbContext.SaveChangesAsync();
var ratingsService = new RatingService(dbContext);
var ratingsController = new RatingsController(ratingsService, mapper);
// Act
var result = await ratingsController.PostRating(user.Id, product.productId, rateValue, comment);
// Assert
var ratingResult = Assert.IsType <CreatedAtActionResult>(result.Result);
Assert.NotNull(ratingResult.Value as Rating);
}
public void Should_ReturnErrorResponse_When_AnExceptionOccursInProjectToMethod()
{
//Arrange
var allItems = new List <Item>().AsQueryable();
ItemsRepositoryMock.Setup(x => x.All()).Returns(allItems);
var filteredItems = new List <Item>();
MapperMock.Setup(c => c.ProjectTo(
It.Is <IQueryable <Item> >(x => ItemsTestHelper.HaveTheSameElements(filteredItems, x)),
null,
It.Is <Expression <Func <ItemNameDto, object> >[]>(x => x.Length == 0)))
.Throws(new Exception());
//Act
var result = ItemsDataService.GetItemsNames("B", "ab70793b-cec8-4eba-99f3-cbad0b1649d0");
//Assert
AssertHelper.AssertAll(
() => result.IsSuccess.Should().BeFalse(),
() => result.ErrorMessage.Should().Be("An error occured while getting items names."),
() => result.Data.Should().BeNull()
);
}
public void Should_ReturnResponseWithCorrectItemName_When_OneItemNameOfThisUserContainSearchWord()
{
//Arrange
var allItems = BuildItemsCollection();
ItemsRepositoryMock.Setup(x => x.All()).Returns(allItems);
var filteredItem = BuildFirstItem();
var filteredItems = new List <Item>()
{
filteredItem
};
var filteredItemNameDto = BuildFirstItemNameDto();
var filteredItemNameDtos = new List <ItemNameDto>()
{
filteredItemNameDto
};
MapperMock
.Setup(c => c.ProjectTo(
It.Is <IQueryable <Item> >(x => ItemsTestHelper.HaveTheSameElements(filteredItems, x)),
null,
It.Is <Expression <Func <ItemNameDto, object> >[]>(x => x.Length == 0)))
.Returns(filteredItemNameDtos.AsQueryable());
//Act
var result = ItemsDataService.GetItemsNames("d", "ab70793b-cec8-4eba-99f3-cbad0b1649d0");
//Assert
result.Data.First().Name.Should().Be("Bread");
}
public void Should_ReturnErrorResponse_When_CurrentUserDoesNotHaveItemWithThisId()
{
//Arrange
var allItems = BuildItemsCollection();
ItemsRepositoryMock.Setup(x => x.All()).Returns(allItems);
var filteredItems = new List <Item>();
var filteredItemDtos = new List <ItemDto>();
MapperMock
.Setup(c => c.ProjectTo(
It.Is <IQueryable <Item> >(x => ItemsTestHelper.HaveTheSameElements(filteredItems, x)),
null,
It.Is <Expression <Func <ItemDto, object> >[]>(x => x.Length == 0)))
.Returns(filteredItemDtos.AsQueryable());
//Act
var result = ItemsDataService.GetItem(2, "925912b0-c59c-4e1b-971a-06e8abab7848");
//Assert
AssertHelper.AssertAll(
() => result.Data.Should().BeNull(),
() => result.IsSuccess.Should().BeFalse(),
() => result.ErrorMessage.Should().Be("Current user does not have item with id 2")
);
}
public void Should_ReturnErrorResponse_When_NoItemsExist()
{
//Arrange
var allItems = new List <Item>().AsQueryable();
ItemsRepositoryMock.Setup(x => x.All()).Returns(allItems);
var filteredItems = new List <Item>();
var filteredItemDtos = new List <ItemDto>();
MapperMock
.Setup(c => c.ProjectTo(
It.Is <IQueryable <Item> >(x => ItemsTestHelper.HaveTheSameElements(filteredItems, x)),
null,
It.Is <Expression <Func <ItemDto, object> >[]>(x => x.Length == 0)))
.Returns(filteredItemDtos.AsQueryable());
//Act
var result = ItemsDataService.GetItem(2, "ab70793b-cec8-4eba-99f3-cbad0b1649d0");
//Assert
AssertHelper.AssertAll(
() => result.Data.Should().BeNull(),
() => result.IsSuccess.Should().BeFalse(),
() => result.ErrorMessage.Should().Be("Current user does not have item with id 2")
);
}
public void Should_ReturnAnErrorResponse_When_UserIdIsEmptyString()
{
//Arrange
var itemDto = BuildFirstItemDtoWithoutId();
var item = BuildFirstItemWithoutId();
MapperMock.Setup(c => c.Map <ItemDto, Item>(itemDto))
.Returns(item);
var saveObject = new Item();
ItemsRepositoryMock.Setup(c => c.Add(It.IsAny <Item>()))
.Callback <Item>((obj) => saveObject = obj);
ItemsRepositoryMock.Setup(c => c.SaveChanges());
//Act
var result = ItemsDataService.AddItem(string.Empty, itemDto);
//Assert
AssertHelper.AssertAll(
() => result.IsSuccess.Should().BeFalse(),
() => result.ErrorMessage.Should().Be("An error occurred while creating item")
);
}
public async void GetAll_Success()
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var user = NewDatas.NewUser();
var product = NewDatas.NewProduct();
var rating = NewDatas.NewRating();
rating.User = user;
rating.Product = product;
dbContext.Products.Add(product);
await dbContext.SaveChangesAsync();
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
dbContext.Ratings.Add(rating);
await dbContext.SaveChangesAsync();
var ratingsService = new RatingService(dbContext);
var ratingsController = new RatingsController(ratingsService, mapper);
// Act
var result = await ratingsController.GetRatings();
// Assert
var ratingResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.NotEmpty(ratingResult.Value as IEnumerable <Rating>);
}
public async Task GetCate_Success()
{
// get MOCK
var mapper = MapperMock.Get();
// initial mock data
var dbContext = _fixture.Context;
dbContext.TypeProducts.Add(new TypeProduct {
Name = "Product Type"
});
var category = new Category {
Name = "Product Category", TypeProductId = 1
};
dbContext.Categories.Add(category);
await dbContext.SaveChangesAsync();
// create dependency
var cateDao = new CategoryDAO(dbContext);
var cateService = new CategoryService(cateDao, mapper);
// test
var result = cateService.GetList(1);
Assert.NotEmpty(result);
}
private IEnumerable <Item> InitializeWithCollection()
{
ItemsTestHelper.InitializeDateTimeProviderMock(DateTimeProviderMock);
var urgentItem = BuildUrgentItem(new DateTime(2020, 10, 02));
var urgentItemDto = BuildUrgentReplenishmentItemDto(new DateTime(2020, 10, 02));
var itemOnFirstReplDate = BuildItemWithReplenishmentOnFirstReplDate(new DateTime(2020, 10, 04));
var itemDtoOnFirstReplDate = BuildItemDtoWithReplenishmentOnFirstReplDate(new DateTime(2020, 10, 04));
var nonUrgentItem = BuildNonUrgentItem(new DateTime(2020, 10, 06));
var nonUrgentItemDto = BuildNonUrgentReplenishmentItemDto(new DateTime(2020, 10, 06));
MapperMock.Setup(c => c.Map <Item, ReplenishmentItemDto>(urgentItem))
.Returns(urgentItemDto);
MapperMock.Setup(c => c.Map <Item, ReplenishmentItemDto>(itemOnFirstReplDate))
.Returns(itemDtoOnFirstReplDate);
MapperMock.Setup(c => c.Map <Item, ReplenishmentItemDto>(nonUrgentItem))
.Returns(nonUrgentItemDto);
var collection = new List <Item>()
{
urgentItem, itemOnFirstReplDate, nonUrgentItem
};
return(collection);
}
public async Task Put_Success()
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var fileService = FileServiceMock.FilesService();
var productToPut = NewDatas.NewProductPutRequest();
var productBeforePut = NewDatas.NewProduct(); productBeforePut.productId = 10; //set productId in order to update
var productAfterPut = NewDatas.ProductAfterPut();
var category = NewDatas.NewCategory();
await dbContext.Categories.AddAsync(category);
await dbContext.Products.AddAsync(productBeforePut);
await dbContext.SaveChangesAsync(); productToPut.categoryId = category.categoryId;
var productsService = new ProductService(dbContext, fileService, mapper);
var productsController = new ProductsController(productsService, fileService);
// Act
var result = await productsController.PutProduct(10, productToPut);
// Assert
Assert.IsType <OkObjectResult>(result.Result);
Assert.Equal(productBeforePut.productName, productAfterPut.productName);
Assert.Equal(productBeforePut.productPrice, productAfterPut.productPrice);
Assert.Equal(productBeforePut.productDescription, productAfterPut.productDescription);
Assert.Equal(productBeforePut.Images.Count, productAfterPut.Images.Count);
Assert.Equal(productBeforePut.Category, category);
}
public async Task CreateAsync_Maps_Posts_And_Throws_HttpRequestException_When_ApiCall_Fails()
{
// Arrange
var expectedWorkoutViewModel = new WorkoutViewModel {
Name = "Test workout 01"
};
var expectedWorkout = new Workout {
Name = "Test workout 01"
};
MapperMock
.Setup(x => x.Map <WorkoutViewModel, Workout>(expectedWorkoutViewModel))
.Returns(expectedWorkout)
.Verifiable();
HttpClientMock
.Setup(x => x.PostEntityAsync(It.IsAny <string>(), expectedWorkout))
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.InternalServerError,
Content = new StringContent("Content as string")
})
.Verifiable();
// Act, Assert
await Assert.ThrowsAsync <HttpRequestException>(() =>
ServiceUnderTest.CreateAsync(expectedWorkoutViewModel));
MapperMock.Verify(x => x.Map <WorkoutViewModel, Workout>(expectedWorkoutViewModel), Times.Once);
HttpClientMock.Verify(x => x.PostEntityAsync(It.IsAny <string>(), expectedWorkout), Times.Once);
}
public async Task CreateAsync_Maps_Posts_And_Completes_When_ApiCall_Succeeds()
{
// Arrange
var expectedWorkoutViewModel = new WorkoutViewModel {
Name = "Test workout 01"
};
var expectedWorkout = new Workout {
Name = "Test workout 01"
};
MapperMock
.Setup(x => x.Map <WorkoutViewModel, Workout>(expectedWorkoutViewModel))
.Returns(expectedWorkout)
.Verifiable();
HttpClientMock
.Setup(x => x.PostEntityAsync(It.IsAny <string>(), expectedWorkout))
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("Content as string")
})
.Verifiable();
// Act
await ServiceUnderTest.CreateAsync(expectedWorkoutViewModel);
// Assert
MapperMock.Verify(x => x.Map <WorkoutViewModel, Workout>(expectedWorkoutViewModel), Times.Once);
HttpClientMock.Verify(x => x.PostEntityAsync(It.IsAny <string>(), expectedWorkout), Times.Once);
}
public async Task ReadOneAsync_Gets_Maps_And_Returns_A_Workout_When_ApiCall_Returns_Workout()
{
// Arrange
const int id = 1;
var expectedWorkout = new Workout {
Name = "Test workout 01", Id = id
};
var expectedWorkoutViewModel = new WorkoutViewModel {
Name = "Test workout 01", Id = id
};
HttpClientMock
.Setup(x => x.GetStringAsync(It.IsAny <string>()))
.ReturnsAsync(JsonConvert.SerializeObject(expectedWorkout))
.Verifiable();
MapperMock
.Setup(x => x.Map <Workout, WorkoutViewModel>(It.IsAny <Workout>()))
.Returns(expectedWorkoutViewModel)
.Verifiable();
// Act
var result = await ServiceUnderTest.ReadOneAsync(id);
// Assert
Assert.Same(expectedWorkoutViewModel, result);
HttpClientMock.Verify(x => x.GetStringAsync(It.IsAny <string>()), Times.Once);
MapperMock.Verify(x => x.Map <Workout, WorkoutViewModel>(It.IsAny <Workout>()), Times.Once);
}
public void Execute_When_called_with_valid_criteria_Then_uses_mapper_to_map_criteria()
{
var request = GetStoreFindRequest();
Command.Execute(request);
MapperMock.Verify(x => x.Map <StoreFindCriteriaDto, StoreFindCriteria>(request.Criteria), Times.Once);
}
public async Task When_Adding_Order_Then_Maps_To_Order_Dto()
{
// Act
await Sut.Handle(Request, default);
// Assert
MapperMock.Verify(x => x.Map <OrderDto>(Order), Times.Once);
}
public void Execute_When_called_with_valid_criteria_Then_uses_mapper_to_map_results()
{
var request = GetStoreFindRequest();
Command.Execute(request);
MapperMock.Verify(x => x.Map <IEnumerable <Entities.StoreModule.Store>, IEnumerable <StoreDto> >(_domainEntities), Times.Once);
}
public void Execute_When_called_Then_uses_mapper_to_map_project()
{
Command.Execute(new StoreGetByIdRequest
{
Id = StoreWithoutAddressId
});
MapperMock.Verify(mock => mock.Map <Entities.StoreModule.Store, StoreDto>(It.Is <Entities.StoreModule.Store>(proj => proj.Id == StoreWithoutAddressId)), Times.Once);
}
static void Main(string[] args)
{
var logger = new LoggerMock();
var mapper = new MapperMock();
var repository = new RepositoryMock();
var filterService = new FilterServiceMock();
var sortService = new SortServiceMock();
new TestEntityQuerySingleHandler(logger, mapper, repository, filterService, sortService);
}
public void PutTest()
{
var model = new DTOs.AddOrUpdateModels.UpdateExpenseModel {
Id = 1, Amount = 1000, CategoryId = 1, ReportId = 1, UserId = 1
};
Controller.PutAsync(model).Wait();
MapperMock.Verify(m => m.Map <DAL.Entities.Expense>(model), Times.Once());
ServiceMock.Verify(s => s.UpdateExpenseAsync(It.IsAny <DAL.Entities.Expense>()), Times.Once());
}
public async Task When_Adding_Order_Then_Send_New_Order_Email(OrderDto orderDto)
{
// Arrange
MapperMock.Setup(x => x.Map <OrderDto>(It.IsAny <Order>())).Returns(orderDto);
// Act
await Sut.Handle(Request, default);
// Assert
EmailServiceMock.Verify(x => x.SendNewOrderEmailAsync(orderDto), Times.Once);
}
public async Task GetSingle_Success()
{
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var fileService = FileServiceMock.FilesService();
var user = NewDatas.NewUser();
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var product1 = NewDatas.NewProduct();
var product2 = NewDatas.NewProduct();
var product3 = NewDatas.NewProduct();
await dbContext.Products.AddRangeAsync(product1, product2, product3);
await dbContext.SaveChangesAsync();
var order = NewDatas.NewOrder();
dbContext.Orders.Add(order);
await dbContext.SaveChangesAsync();
var orderDetail1 = NewDatas.NewOrderDetail();
orderDetail1.productId = product1.productId;
orderDetail1.orderId = order.orderId;
var orderDetail2 = NewDatas.NewOrderDetail();
orderDetail2.productId = product2.productId;
orderDetail2.orderId = order.orderId;
var orderDetail3 = NewDatas.NewOrderDetail();
orderDetail3.productId = product3.productId;
orderDetail3.orderId = order.orderId;
await dbContext.OrderDetails.AddRangeAsync(orderDetail1, orderDetail2, orderDetail3);
await dbContext.SaveChangesAsync();
order.orderDetails = new List <OrderDetail> {
orderDetail1, orderDetail2, orderDetail3
};
order.user = user;
await dbContext.SaveChangesAsync();
var ordersService = new OrderService(dbContext, mapper);
var ordersController = new OrdersController(ordersService, mapper, fileService);
// Act
var result = await ordersController.GetOrder(order.orderId);
// Assert
var ordersResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.NotNull(ordersResult.Value as Order);
}
public void PutTest()
{
var category = new Category {
Name = "test"
};
Controller.PutAsync(category).Wait();
MapperMock.Verify(m => m.Map <DAL.Entities.Category>(category), Times.Once());
ServiceMock.Verify(s => s.UpdateCategoryAsync(It.IsAny <DAL.Entities.Category>()), Times.Once());
}
public async void GetAll_Success()
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var user = NewDatas.NewUser();
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var product1 = NewDatas.NewProduct();
var product2 = NewDatas.NewProduct();
var product3 = NewDatas.NewProduct();
await dbContext.Products.AddRangeAsync(product1, product2, product3);
await dbContext.SaveChangesAsync();
#region create intial order data
var fileService = FileServiceMock.FilesService();
var order = NewDatas.NewOrder();
dbContext.Orders.Add(order);
await dbContext.SaveChangesAsync();
var orderDetail1 = NewDatas.NewOrderDetail();
orderDetail1.productId = product1.productId;
orderDetail1.orderId = order.orderId;
var orderDetail2 = NewDatas.NewOrderDetail();
orderDetail2.productId = product2.productId;
orderDetail2.orderId = order.orderId;
var orderDetail3 = NewDatas.NewOrderDetail();
orderDetail3.productId = product3.productId;
orderDetail3.orderId = order.orderId;
await dbContext.OrderDetails.AddRangeAsync(orderDetail1, orderDetail2, orderDetail3);
await dbContext.SaveChangesAsync();
order.orderDetails = new List <OrderDetail> {
orderDetail1, orderDetail2, orderDetail3
};
order.user = user;
await dbContext.SaveChangesAsync();
#endregion
var ordersService = new OrderService(dbContext, mapper);
var ordersController = new OrdersController(ordersService, mapper, fileService);
// Act
var result = await ordersController.GetOrders();
// Assert
var ordersResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.NotEmpty(ordersResult.Value as IEnumerable <OrderResponse>);
}
public async Task Should_ReturnOk()
{
MapperMock
.Setup(m => m.Map <Contact>(It.IsAny <CreateContactModel>()))
.Returns(new Contact());
ContactsRepositoryMock
.Setup(r => r.CreateAsync(It.IsAny <Contact>()))
.Returns(Task.CompletedTask);
var response = await ControllerMock.Post(It.IsAny <CreateContactModel>());
Assert.IsType <OkResult>(response);
}
