public void ValidGetByIdShouldReturnSelectedHotel()
{
var options = new DbContextOptionsBuilder <BookingsDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidGetByIdShouldReturnSelectedHotel))
.Options;
using (var context = new BookingsDbContext(options))
{
var hotelService = new ReviewService(context);
var controller = new HotelsController(hotelService);
Hotel hotel2 = new Hotel
{
Id = 1,
HotelName = "Transilvania Hotel",
City = "Sibiu",
Capacity = 120,
Rating = 8,
Reviews = new List <Review>()
{
new Review
{
Text = "fain",
Rating = 10,
}
}
};
Hotel hotel1 = new Hotel
{
Id = 2,
HotelName = "Belvedere Hotel",
City = "Sibiu",
Capacity = 120,
Rating = 8,
Reviews = new List <Review>()
{
new Review
{
Text = "fain",
Rating = 10,
}
}
};
hotelService.Create(hotel1);
hotelService.Create(hotel2);
context.Entry(hotel1).State = EntityState.Detached;
context.Entry(hotel2).State = EntityState.Detached;
var response = controller.GetHotelById(1);
var contentResult = response as Hotel;
Assert.IsNotNull(contentResult);
Assert.AreEqual("Transilvania Hotel", contentResult.HotelName);
}
}
public void ValidGetHotelsShouldListAll()
{
var options = new DbContextOptionsBuilder <BookingsDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidGetHotelsShouldListAll))
.Options;
using (var context = new BookingsDbContext(options))
{
var hotelService = new ReviewService(context);
Hotel hotel2 = new Hotel
{
HotelName = "Transilvania Hotel",
City = "Sibiu",
Capacity = 120,
Rating = 8,
Reviews = new List <Review>()
{
new Review
{
Text = "fain",
Rating = 10,
}
}
};
Hotel hotel1 = new Hotel
{
HotelName = "Belvedere Hotel",
City = "Sibiu",
Capacity = 120,
Rating = 8,
Reviews = new List <Review>()
{
new Review
{
Text = "fain",
Rating = 10,
}
}
};
hotelService.Create(hotel1);
hotelService.Create(hotel2);
context.Entry(hotel1).State = EntityState.Detached;
context.Entry(hotel2).State = EntityState.Detached;
Assert.AreEqual(hotelService.GetHotels().Count(), 2);
}
}
public void ValidDeleteShouldDeleteHotel()
{
var options = new DbContextOptionsBuilder <BookingsDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidDeleteShouldDeleteHotel))
.Options;
using (var context = new BookingsDbContext(options))
{
var hotelService = new ReviewService(context);
var addedHotel = hotelService.Create(new HotelBooking.Hotel
{
Id = 100,
HotelName = "Transilvania Hotel",
City = "Sibiu",
Capacity = 120,
Rating = 8,
Reviews = new List <Review>()
{
new Review
{
Text = "fain",
Rating = 10,
}
}
});
hotelService.Delete(100);
Assert.IsNull(hotelService.GetHotelById(100));
}
}
public void ValidCreateShouldCreateANewHotel()
{
var options = new DbContextOptionsBuilder <BookingsDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidCreateShouldCreateANewHotel))
.Options;
using (var context = new BookingsDbContext(options))
{
var hotelService = new ReviewService(context);
var addedHotel = new Hotel
{
HotelName = "Transilvania Hotel",
City = "Sibiu",
Capacity = 120,
Rating = 8,
Reviews = new List <Review>()
{
new Review
{
Text = "fain",
Rating = 10,
}
}
};
var result = hotelService.Create(addedHotel);
Assert.IsNotEmpty(context.Hotels);
}
}
public void UpdateShouldUpdateExistingHotel()
{
var options = new DbContextOptionsBuilder <BookingsDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpdateShouldUpdateExistingHotel))
.Options;
using (var context = new BookingsDbContext(options))
{
var hotelService = new ReviewService(context);
var addedHotel = hotelService.Create(new HotelBooking.Hotel
{
HotelName = "Transilvania Hotel",
City = "Sibiu",
Capacity = 120,
Rating = 8,
Reviews = new List <Review>()
{
new Review
{
Text = "fain",
Rating = 10
}
}
});
context.Entry(addedHotel).State = EntityState.Detached;
Assert.AreEqual("Transilvania Hotel", addedHotel.HotelName);
addedHotel.HotelName = "updated hotel";
var updatedHotel = hotelService.Update(addedHotel.Id, addedHotel);
Assert.AreEqual("updated hotel", updatedHotel.HotelName);
}
}
public void ValidGetHotelByIdShouldGetSpecifiedHotel()
{
var options = new DbContextOptionsBuilder <BookingsDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidGetHotelByIdShouldGetSpecifiedHotel))
.Options;
using (var context = new BookingsDbContext(options))
{
var hotelService = new ReviewService(context);
Hotel hotel = new Hotel
{
HotelName = "Transilvania Hotel",
City = "Sibiu",
Capacity = 120,
Rating = 8,
Reviews = new List <Review>()
{
new Review
{
Text = "fain",
Rating = 10,
}
}
};
hotel.Id = 1;
hotelService.Create(hotel);
context.Entry(hotel).State = EntityState.Detached;
Assert.AreEqual(hotelService.GetHotelById(1).HotelName, "Transilvania Hotel");
}
}
public HttpResponseMessage Create(ReviewCreateRequest review)
{
ItemResponse <int> response = new ItemResponse <int>();
response.Item = ReviewService.Create(review);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public async Task SubmitReviewShouldBeCalledOnce()
{
var reviewRepo = new Mock <IRepository <Review> >();
var usersRepo = new Mock <IRepository <User> >();
var users = new List <User>
{
new User {
UserName = "******"
},
new User {
UserName = "******"
},
};
usersRepo.Setup(u => u.All()).Returns(users.AsQueryable());
var reviews = new List <Review>();
reviewRepo.Setup(r => r.All()).Returns(reviews.AsQueryable());
reviewRepo.Setup(r => r.AddAsync(It.IsAny <Review>())).Returns <Review>(Task.FromResult).Callback <Review>(r => reviews.Add(r));
var service = new ReviewService(reviewRepo.Object, usersRepo.Object);
var review = new Review {
Id = Guid.NewGuid()
};
await service.Create(review, "stamat");
Assert.Equal(1, reviews.Count);
Assert.Contains(reviews, r => r.Id == review.Id);
reviewRepo.Verify(r => r.AddAsync(review), Times.Once);
}
public async Task <IActionResult> New(NewReviewModel model)
{
var movie = _movies.GetDetails(model.MovieId);
if (movie == null)
{
return(RedirectToAction("Index", "Movies"));
}
// TODO: authorize the user to create reviews for the movie
if (ModelState.IsValid)
{
var result = _reviews.Create(model.MovieId, model.Stars, model.Comment, "test");
if (result.Succeeded)
{
return(View("Success", new ReviewSuccessViewModel {
MovieId = model.MovieId, Action = "Created"
}));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
model.MovieTitle = movie.Title;
return(View(model));
}
public async Task <IActionResult> Post(int movieId, [FromBody] ReviewUpdateModel model)
{
var movie = _movies.GetDetails(movieId);
if (movie == null)
{
return(NotFound());
}
if (!(await _authorization.AuthorizeAsync(User, movie, Authorization.MovieOperations.Review)).Succeeded)
{
return(Forbid());
}
var userId = User.FindFirst("sub")?.Value;
var result = _reviews.Create(movieId, model.Stars, model.Comment, userId);
if (!result.Succeeded)
{
return(BadRequest(result.Errors.ToArray()));
}
return(NoContent());
}
public IActionResult CreateReview([FromBody] CreateReviewRequest request, long id, long sessionID)
{
var user = UserService.Get(long.Parse(User.Identity.Name));
if (user == null)
{
return(NotFound(new ResponseModel
{
Success = false,
Message = "Пользователь не найден"
}));
}
var problem = ProblemService.Get(id);
if (problem == null)
{
return(NotFound(new ResponseModel
{
Success = false,
Message = "Проблема не найдена"
}));
}
var session = SessionService.Get(sessionID);
if (session == null)
{
return(NotFound(new ResponseModel
{
Success = false,
Message = "Сессия не найдена"
}));
}
var specialist = SpecialistService.Get(session.Specialist.ID);
session.Specialist = specialist;
SessionService.Update(session);
var review = new Review
{
Session = session,
Text = request.ReviewText,
Score = request.Score
};
ReviewService.Create(review);
return(Ok(new ResponseModel()));
}
public ActionResult Create(Review review)
{
UserModel aPerson = GetUserFromSession();
review.Person = aPerson;
if (ModelState.IsValid)
{
reviewService.Create(review);
return(RedirectToAction(nameof(Index)));
}
return(View(review));
}
public IHttpActionResult CreateReview([FromBody] ReviewsDTO review)
{
ReviewService service = new ReviewService();
bool response = service.Create(review);
if (response)
{
return(Ok("Review has been added"));
}
else
{
return(Content(HttpStatusCode.BadRequest, "Review addition has failed. Invalid Inputs."));
}
}
public void Create_UserIdAndItemIdAndInputDtoAddReview_ReturnsSingleOutputDtoQueryReview()
{
// ARRANGE //
var reviewRep = Substitute.For <IReviewRepository>();
reviewRep.GetById(1).Returns(CreateReview(1));
reviewRep.Create(1, 1, Arg.Any <IReview>()).Returns(CreateReview(1));
var reviewService = new ReviewService(reviewRep);
var expected = CreateOutputDtoQueryReview(1);
// ACT //
var output = reviewService.Create(1, 1, CreateInputDtoAddReview(1));
// ASSERT //
Assert.AreEqual(expected, output);
}
public ActionResult Create(ReviewCreate model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new ReviewService(userId, model.ProductId);
if (service.Create(model))
{
TempData["SaveResult"] = "Your Review was created.";
return(RedirectToAction("Details", "Product", new { id = model.ProductId }));
}
ModelState.AddModelError("", "Review could not be created");
return(View(model));
}
public async Task <IActionResult> Create([Bind("Id,UserId,BookId,Created,Qualification,Comment")] ReviewViewModel reviewViewModel)
{
if (ModelState.IsValid)
{
var service = new ReviewService(HttpContext.Session.GetString("Token"));
var items = service.Create(reviewViewModel);
if (items == null)
{
return(BadRequest());
}
return(RedirectToAction(nameof(Index)));
}
var bookService = new BookService(HttpContext.Session.GetString("Token"));
var userService = new UserService(HttpContext.Session.GetString("Token"));
ViewData["BookId"] = new SelectList(bookService.Get(), "Id", "Name", reviewViewModel.BookId);
ViewData["UserId"] = new SelectList(userService.Get(), "Id", "Name", reviewViewModel.UserId);
ViewData["Qualification"] = new SelectList(Common.Reviews, "Value", "Key", reviewViewModel.Qualification);
return(View(reviewViewModel));
}
public void ValidDeleteByIdNotFoundId()
{
var options = new DbContextOptionsBuilder <BookingsDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidDeleteShouldDeleteHotel))
.Options;
using (var context = new BookingsDbContext(options))
{
var hotelService = new ReviewService(context);
var controller = new HotelsController(hotelService);
Hotel hotel = new Hotel
{
Id = 100,
HotelName = "Transilvania Hotel",
City = "Sibiu",
Capacity = 120,
Rating = 8,
Reviews = new List <Review>()
{
new Review
{
Text = "fain",
Rating = 10,
}
}
};
hotelService.Create(hotel);
context.Entry(hotel).State = EntityState.Detached;
IActionResult actionResult = controller.DeleteHotel(200);
// var createdResult = actionResult as OkObjectResult;
// Assert.IsInstanceOf(createdResult.GetType(), typeof(System.Web.Http.Results.NotFoundResult));
Assert.IsNotEmpty(context.Hotels);
}
}
public async Task <IActionResult> New(NewReviewModel model)
{
var movie = _movies.GetDetails(model.MovieId);
if (movie == null)
{
return(RedirectToAction("Index", "Movies"));
}
// TODO: authorize the user to create reviews for the movie
var authz = await _authorization.AuthorizeAsync(User, movie, Authorization.MovieOperations.Review);
if (!authz.Succeeded)
{
return(Forbid());
}
if (ModelState.IsValid)
{
var result = _reviews.Create(model.MovieId, model.Stars, model.Comment, User.FindFirst("sub").Value);
if (result.Succeeded)
{
return(View("Success", new ReviewSuccessViewModel {
MovieId = model.MovieId, Action = "Created"
}));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
model.MovieTitle = movie.Title;
return(View(model));
}
public async Task SubmitReviewShouldThrowErrorForNonExistingUser()
{
var reviewRepo = new Mock <IRepository <Review> >();
var usersRepo = new Mock <IRepository <User> >();
usersRepo.Setup(u => u.All()).Returns(new List <User>
{
new User {
UserName = "******"
},
new User {
UserName = "******"
},
}.AsQueryable());
var service = new ReviewService(reviewRepo.Object, usersRepo.Object);
var review = new Review();
await Assert.ThrowsAsync <NullReferenceException>(async() => await service.Create(review, "pesho"));
reviewRepo.Verify(r => r.AddAsync(review), Times.Never);
}
public ActionResult <Review> Create(ReviewDTO review, string productId)
{
var apiRep = new APIResponse();
var UserId = string.Empty;
if (HttpContext.User.Identity is ClaimsIdentity identity)
{
UserId = identity.FindFirst(ClaimTypes.Name).Value;
}
var _review = new Review
{
userId = UserId,
value = review.value,
productId = review.productId,
};
var result = _reviewService.Create(_review);
apiRep.Error = false;
apiRep.Data = result;
return(Ok(apiRep));
}