protected override void OnModelCreating(ModelBuilder modelBuilder)
{
AppointmentBuilder.BuildAppointment(modelBuilder);
DoctorBuilder.BuildDoctor(modelBuilder);
ReviewBuilder.BuildReview(modelBuilder);
PatientBuilder.BuildPatient(modelBuilder);
base.OnModelCreating(modelBuilder);
}
public void Put_MismatchBetweenUrlIdAndReviewIdCausesBadRequest()
{
//Arrange
var review = new ReviewBuilder().WithId(10).Build();
//Act
var result = _controller.Put(20, review).Result as BadRequestResult;
//Assert
Assert.That(result, Is.Not.Null);
}
public void Put_InValidReviewModelStateCausesBadRequest()
{
//Arrange
_controller.ModelState.AddModelError("ReviewerName", "Reviewer name is required");
var review = new ReviewBuilder().WithId().WithoutName().Build();
//Act
var result = _controller.Put(review.Id, review).Result as BadRequestResult;
//Assert
Assert.That(result, Is.Not.Null);
}
public void Put_NonExistingReviewReturnsNotFound()
{
//Arrange
_controller._reviewRepositoryMock.Setup(rm => rm.GetAsync(It.IsAny <int>())).Returns(Task.FromResult <Review>(null));
var review = new ReviewBuilder().WithId().Build();
//Act
var result = _controller.Put(review.Id, review).Result as NotFoundResult;
//Assert
Assert.That(result, Is.Not.Null);
}
public void Delete_NonExistingReviewReturnsNotFound()
{
//Arrange
_controller._reviewRepositoryMock.Setup(rm => rm.GetAsync(It.IsAny <int>()))
.Returns(Task.FromResult <Review>(null));
var review = new ReviewBuilder().WithId().Build();
//Act
var result = _controller.Delete(review.Id).Result as NotFoundResult;
//Assert
_controller._reviewRepositoryMock.Verify(rm => rm.GetAsync(review.Id), Times.Once);
_controller._reviewRepositoryMock.Verify(rm => rm.DeleteAsync(review.Id), Times.Never);
Assert.That(result, Is.Not.Null);
}
public void Edit_ValidId_ReturnsEditView()
{
//Arrange
var review = new ReviewBuilder().WithId().Build();
_controller._apiProxyMock.Setup(proxy => proxy.GetReviewByIdAsync(review.Id)).Returns(Task.FromResult <Review>(review));
//Act
var viewResult = _controller.Edit(review.Id).Result as ViewResult;
//Assert
Assert.That(viewResult, Is.Not.Null);
Assert.That(viewResult.Model, Is.EqualTo(review));
_controller._apiProxyMock.Verify(proxy => proxy.GetReviewByIdAsync(review.Id), Times.Once);
}
public async Task <ActionResult> SourceReviews(string SourceUrl)
{
var _sourceUrl = SourceUrl;
WebScraper scraperAgent = new WebScraper();
ReviewBuilder reviewBuilder;
var webPage = await scraperAgent.Scrape(_sourceUrl);
reviewBuilder = new ReviewBuilder(webPage);
reviewBuilder.BuildReviewData();
var reviews = reviewBuilder.Reviews;
return(PartialView("_Reviews", reviews));
}
public void Get_ReturnsReviewIfItExists()
{
//Arrange
var review = new ReviewBuilder().Build();
_controller._reviewRepositoryMock.Setup(rm => rm.GetAsync(It.IsAny <int>()))
.Returns(Task.FromResult <Review>(review));
//Act
var result = _controller.Get(review.Id).Result as OkNegotiatedContentResult <Review>;
//Assert
_controller._reviewRepositoryMock.Verify(rm => rm.GetAsync(review.Id), Times.Once);
Assert.That(result, Is.Not.Null);
Assert.That(result.Content, Is.EqualTo(review));
}
public void Put_ExistingReviewIsSavedInRepository()
{
//Arrange
var review = new ReviewBuilder().WithId().Build();
_controller._reviewRepositoryMock.Setup(rm => rm.GetAsync(It.IsAny <int>())).Returns(Task.FromResult <Review>(review));
_controller._reviewRepositoryMock.Setup(rm => rm.UpdateAync(It.IsAny <Review>()))
.Returns(Task.FromResult <Review>(review));
//Act
var result = _controller.Put(review.Id, review).Result as OkResult;
//Assert
Assert.That(result, Is.Not.Null);
_controller._reviewRepositoryMock.Verify(rm => rm.GetAsync(review.Id), Times.Once);
_controller._reviewRepositoryMock.Verify(rm => rm.UpdateAync(review), Times.Once);
}
public void Edit_ValidIdAndValidReview_ReturnsRedirectToRouteResult()
{
//Arrange
var review = new ReviewBuilder().WithId().Build();
_controller._apiProxyMock.Setup(proxy => proxy.PutReviewAsync(review.Id, review))
.Returns(Task.FromResult <bool>(true));
//Act
var redirectResult = _controller.Edit(review.Id, review).Result as RedirectToRouteResult;
//Assert
Assert.That(redirectResult, Is.Not.Null);
Assert.That(redirectResult.Permanent, Is.False);
Assert.That(redirectResult.RouteValues["Action"], Is.EqualTo("Index"));
_controller._apiProxyMock.Verify(proxy => proxy.PutReviewAsync(review.Id, review), Times.Once);
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
foreach (var property in builder.Model.GetEntityTypes().SelectMany(t => t.GetProperties()).Where(p => p.ClrType == typeof(decimal)))
{
property.Relational().ColumnType = "decimal(18, 2)";
}
var brandBuilder = new BrandBuilder(builder.Entity <Brand>());
var colorBuilder = new ColorBuilder(builder.Entity <Color>());
var fileBuilder = new FileBuilder(builder.Entity <File>());
var languageBuilder = new LanguageBuilder(builder.Entity <Language>());
var pageBuilder = new PageBuilder(builder.Entity <Page>());
var postBuilder = new PostBuilder(builder.Entity <Post>());
var postCategoryBuilder = new PostCategoryBuilder(builder.Entity <PostCategory>());
var postPostCategoryBuilder = new PostPostCategoryBuilder(builder.Entity <PostPostCategory>());
var productBuilder = new ProductBuilder(builder.Entity <Product>());
var productCategoryBuilder = new ProductCategoryBuilder(builder.Entity <ProductCategory>());
var productColorBuilder = new ProductColorBuilder(builder.Entity <ProductColor>());
var productPhotoBuilder = new ProductPhotoBuilder(builder.Entity <ProductPhoto>());
var reviewBuilder = new ReviewBuilder(builder.Entity <Review>());
var slideBuilder = new SlideBuilder(builder.Entity <Slide>());
var sliderBuilder = new SliderBuilder(builder.Entity <Slider>());
var advertisementBuilder = new AdvertisementBuilder(builder.Entity <Advertisement>());
var storeBuilder = new StoreBuilder(builder.Entity <Store>());
var storeBrandBuilder = new StoreBrandBuilder(builder.Entity <StoreBrand>());
var wishlistBuilder = new WishlistBuilder(builder.Entity <Wishlist>());
var orderBuilder = new OrderBuilder(builder.Entity <Order>());
var orderItemBuilder = new OrderItemBuilder(builder.Entity <OrderItem>());
var addressBuilder = new AddressBuilder(builder.Entity <Address>());
var cityBuilder = new CityBuilder(builder.Entity <City>());
var countryBuilder = new CountryBuilder(builder.Entity <Country>());
var couponBuilder = new CouponBuilder(builder.Entity <Coupon>());
var districtBuilder = new DistrictBuilder(builder.Entity <District>());
var productQuestionBuilder = new ProductQuestionBuilder(builder.Entity <ProductQuestion>());
var questionCategoryBuilder = new QuestionCategoryBuilder(builder.Entity <QuestionCategory>());
var shipperBuilder = new ShipperBuilder(builder.Entity <Shipper>());
var cartBuilder = new CartBuilder(builder.Entity <Cart>());
var cartItemBuilder = new CartItemBuilder(builder.Entity <CartItem>());
// data seeding
ApplicationDbContextSeed.Seed(builder);
}
public void Index_ReturnsAllReviews()
{
//Arrange
var reviewBuilder = new ReviewBuilder();
var reviews = new List <Review>
{
reviewBuilder.WithId().Build(),
reviewBuilder.WithId().Build()
};
_controller._apiProxyMock.Setup(proxy => proxy.GetReviewsAsync())
.Returns(Task.FromResult <IEnumerable <Review> >(reviews)); //ReturnsAsync can also be used
//Act
var viewResult = _controller.Index().Result as ViewResult;
//Assert
Assert.That(viewResult, Is.Not.Null);
Assert.That(viewResult.Model, Is.EquivalentTo(reviews));
_controller._apiProxyMock.Verify(proxy => proxy.GetReviewsAsync(), Times.Once);
}
public void Post_ValidReviewIsSavedInRepository()
{
//Arrange
var review = new ReviewBuilder().Build();
_controller._reviewRepositoryMock.Setup(rm => rm.AddAsync(It.IsAny <Review>())).Returns(() =>
{
review.Id = new Random().Next(1, int.MaxValue);
return(Task.FromResult <Review>(review));
});
//Act
var result = _controller.Post(review).Result as CreatedAtRouteNegotiatedContentResult <Review>;
//Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Content.Id, Is.EqualTo(review.Id));
Assert.That(result.Content.ReviewerName, Is.EqualTo(review.ReviewerName));
Assert.That(result.RouteName, Is.EqualTo("DefaultApi"));
Assert.That(result.RouteValues.Count, Is.EqualTo(2));
Assert.That(result.RouteValues["controller"], Is.EqualTo("Review"));
Assert.That(result.RouteValues["id"], Is.EqualTo(result.Content.Id));
}
private static IList<Review> GetReviews()
{
var reviewCleaner = FileReviewsCleaner.GetReviewCleanerFromFile(_reviewCleanerCSV);
var miDBRecordsGetter = new CSVFileProvider(_connectionString);
var reviewBuilder = new ReviewBuilder(_logger, reviewCleaner, new InMemoryCleaner(), null);
var reviewsManager = new ReviewsManager(reviewBuilder);
var results = miDBRecordsGetter.GetRecords();
foreach (var result in results)
{
try
{
reviewsManager.AddReviewFrom(result);
}
catch (Exception e)
{
_logger.LogError(string.Format("Une erreur est survenue lors du parsing de la review {0} : {1}", result.Id, e.Message), ErrorLevel.Error);
continue;
}
}
return reviewsManager.Reviews;
}
private static IList <Review> GetReviews()
{
var reviewCleaner = FileReviewsCleaner.GetReviewCleanerFromFile(_reviewCleanerCSV);
var miDBRecordsGetter = new CSVFileProvider(_connectionString);
var reviewBuilder = new ReviewBuilder(_logger, reviewCleaner, new InMemoryCleaner(), null);
var reviewsManager = new ReviewsManager(reviewBuilder);
var results = miDBRecordsGetter.GetRecords();
foreach (var result in results)
{
try
{
reviewsManager.AddReviewFrom(result);
}
catch (Exception e)
{
_logger.LogError(string.Format("Une erreur est survenue lors du parsing de la review {0} : {1}", result.Id, e.Message), ErrorLevel.Error);
continue;
}
}
return(reviewsManager.Reviews);
}
