public void Post_ValidRestaurantIsSavedInRepository()
{
var restaurant = new Restaurant();
_repo.Setup(repo => repo.Add(It.IsAny <Restaurant>())).Returns(() => {
return(restaurant);
});
var urlHelperMock = new Mock <UrlHelper>();
urlHelperMock.Setup(u => u.Link(It.IsAny <string>(), It.IsAny <object>())).Returns(() => Guid.NewGuid().ToString());
_controller.Url = urlHelperMock.Object;
var actionResult = _controller.Post(restaurant) as CreatedAtRouteNegotiatedContentResult <Restaurant>;
Assert.That(actionResult, Is.Not.Null);
Assert.That(actionResult.Content.Id, Is.GreaterThan(0));
Assert.That(actionResult.Content.Country, Is.EqualTo(restaurant.Country));
Assert.That(actionResult.Content.City, Is.EqualTo(restaurant.City));
Assert.That(actionResult.Content.Name, Is.EqualTo(restaurant.Name));
urlHelperMock.Verify(u => u.Link("DefaultApi", It.IsAny <object>()), Times.Once);
_repo.Verify(repo => repo.Add(restaurant), Times.Once);
}
public void Search_ExplicitParams_ReturnsList()
{
IEnumerable <Restaurant> expected = new List <Restaurant> {
new Restaurant {
Id = 1,
Name = "test"
},
new Restaurant {
Id = 2,
Name = "test2"
}
};
var restaurantRepository = new Mock <IRestaurantRepository>();
DbFilter <Restaurant> actualFilter = null;
restaurantRepository.Setup(x => x.GetRestaurantsAsync(3, 2, It.IsAny <DbFilter <Restaurant> >()))
.Callback <int, int, DbFilter <Restaurant> >((page, pagesize, filter) => { actualFilter = filter; })
.Returns(Task.FromResult <IEnumerable <Restaurant> >(expected));
var filterParam = new FilterParam {
Field = "Name", Operator = OperatorEnum.Like, Value = "Burger*"
};
var sut = new RestaurantsController(restaurantRepository.Object);
var actual = sut.Post(filterParam, 3, 2).Result;
Assert.AreEqual(expected, actual);
Assert.IsNotNull(actualFilter);
Assert.AreEqual("Name", actualFilter.Field);
Assert.AreEqual(OperatorEnum.Like, actualFilter.Operator);
Assert.AreEqual("Burger*", actualFilter.Value);
restaurantRepository.VerifyAll();
}
public void PostNewRestaurant_ValidInput_OkWithUrl()
{
//arrange
var cuisineName = "Mexican";
var cuisineId = 10;
var restName = "No1 Mexican Restaurant";
var expectedRestId = 155;
var createdUser = 1;
var cuisine = new Cuisine
{
Name = cuisineName,
Id = cuisineId,
CreatedBy = createdUser,
UpdatedBy = createdUser
};
var expectedResponse = new API.ViewModels.Restaurant
{
Id = expectedRestId,
AverageRating = 0,
CuisineName = cuisineName,
CuisineId = cuisineId,
Name = restName,
ReviewCount = 0
};
var transactionRequest = new AddRestaurantRequestModel
{
CuisineId = cuisineId,
Name = restName,
UserId = createdUser
};
MockRepository.Setup(m => m.AddRestaurentGetNewId(transactionRequest)).Returns(expectedRestId);
MockRepository.Setup(m => m.GetCuisineById(It.IsAny <int>())).Returns(cuisine);
MockIdentity.Setup(m => m.GetRequestingUserId()).Returns(createdUser);
var ctrl = new RestaurantsController(MockRepository.Object, MockLogger.Object, MockIdentity.Object);
//act
var actionResult = ctrl.Post(new API.ViewModels.Restaurant {
CuisineId = cuisineId, Name = restName
});
var createdResult = actionResult as CreatedAtRouteNegotiatedContentResult <API.ViewModels.Restaurant>;
//assert
Assert.IsNotNull(createdResult, "created-201 status was not returned");
Assert.AreEqual("DefaultRouting", createdResult.RouteName);
Assert.AreEqual(expectedRestId, createdResult.RouteValues["id"]);
//validate response
ValidateRestaurantResponse(createdResult.Content, expectedResponse);
}
public void PostTest_FailedReturnsNotFound()
{
var RC = new RestaurantsController(connection);
var restaurant = new Restaurant();
restaurant.City = "bad!!! city1234";
restaurant.Name = "good name";
var result = RC.Post(restaurant);
Assert.IsType <ObjectResult>(result);
}
public void PostTest_SuccessReturnsOK()
{
var RC = new RestaurantsController(connection);
var restaurant = new Restaurant();
restaurant.Name = "My Test Restaurant";
restaurant.City = "Pittsburgh";
var result = RC.Post(restaurant);
Assert.IsType <OkObjectResult>(result);
}
public void Post_ValidRestaurantIsSavedInRepository()
{
//Arrange
var newRestaurant = new RestaurantBuilder().Build();
_restaurantRepositoryMock.Setup(repo => repo.Add(It.IsAny <Restaurant>())).Returns(() =>
{
newRestaurant.Id = _random.Next();
return(newRestaurant);
});
//Act
var createdResult = _controller.Post(newRestaurant) as CreatedAtRouteResult;
//Assert
Assert.That(createdResult, Is.Not.Null);
_restaurantRepositoryMock.Verify(r => r.Add(newRestaurant), Times.Once);
Assert.That(createdResult.Value, Is.EqualTo(newRestaurant));
Assert.That(createdResult.RouteName, Is.EqualTo("DefaultApi"));
Assert.That(createdResult.RouteValues.Count, Is.EqualTo(2));
Assert.That(createdResult.RouteValues["controller"], Is.EqualTo("Restaurants"));
Assert.That(createdResult.RouteValues["id"], Is.EqualTo(((Restaurant)createdResult.Value).Id));
}
public void PostNewRestaurant_ServerException_InternalError()
{
//arrange
var cuisineId = 10;
var restName = "No1 Mexican Restaurant";
MockIdentity.Setup(m => m.GetRequestingUserId()).Throws(new Exception());
var ctrl = new RestaurantsController(MockRepository.Object, MockLogger.Object, MockIdentity.Object);
//act
var actionResult = ctrl.Post(new API.ViewModels.Restaurant {
CuisineId = cuisineId, Name = restName
});
// assert
Assert.IsInstanceOfType(actionResult, typeof(InternalServerErrorResult));
}
public void PostNewRestaurant_NameAlreadyExistsException_BadData()
{
//arrange
var cuisineId = 10;
var restName = "No1 Mexican Restaurant";
MockRepository.Setup(m => m.AddRestaurentGetNewId(It.IsAny <AddRestaurantRequestModel>()))
.Throws(new RestaurantAlreadyExistsException());
MockIdentity.Setup(m => m.GetRequestingUserId()).Returns(10);
var ctrl = new RestaurantsController(MockRepository.Object, MockLogger.Object, MockIdentity.Object);
//act
var actionResult = ctrl.Post(new API.ViewModels.Restaurant {
CuisineId = cuisineId, Name = restName
});
// assert
Assert.IsInstanceOfType(actionResult, typeof(BadRequestResult));
}
public void Post_CallsRepository_ReturnsRestaurant()
{
var expected = new Restaurant
{
Id = 1,
Name = "test",
Address = "123 somestreet",
City = "FakeCity"
};
var restaurantRepository = new Mock <IRestaurantRepository>();
restaurantRepository.Setup(x => x.CreateRestaurantAsync(expected.Name, expected.Address, expected.City)).Returns(Task.FromResult <Restaurant>(expected));
var sut = new RestaurantsController(restaurantRepository.Object);
var actual = sut.Post(expected).Result;
Assert.AreEqual(expected, actual);
restaurantRepository.VerifyAll();
}
public void Search_DefaultParams_ReturnsList()
{
IEnumerable <Restaurant> expected = new List <Restaurant> {
new Restaurant {
Id = 1,
Name = "test"
},
new Restaurant {
Id = 2,
Name = "test2"
}
};
var restaurantRepository = new Mock <IRestaurantRepository>();
restaurantRepository.Setup(x => x.GetRestaurantsAsync(1, 1000, null)).Returns(Task.FromResult <IEnumerable <Restaurant> >(expected));
var sut = new RestaurantsController(restaurantRepository.Object);
var actual = sut.Post(null, null, null).Result;
Assert.AreEqual(expected, actual);
restaurantRepository.VerifyAll();
}