public void CanRecountAverageProductRate()
{
// Create review for test
var item = new CustomerReview
{
Id = CustomerReviewId,
ProductId = ProductId,
CreatedDate = DateTime.Now,
CreatedBy = "initial data seed",
AuthorNickname = "John Doe",
Content = "Liked that",
Rate = 5
};
CustomerReviewService.SaveCustomerReviews(new[] { item });
// Check result
var getByIdsResult = AverageProductRateService.GetByProductIds(new[] { ProductId });
Assert.Single(getByIdsResult);
var avgRate = getByIdsResult[0];
Assert.Equal(ProductId, avgRate.ProductId);
Assert.Equal(item.Rate, avgRate.AverageRate);
// Delete test review
CanDeleteCustomerReviews();
}
public CustomerReviewServiceTests()
{
_randomizer = new Fixture();
_unitOfWork = new Mock <IUnitOfWork>();
_repository = new Mock <ICustomerReviewRepository>();
_repository.SetupGet(m => m.UnitOfWork).Returns(_unitOfWork.Object);
_service = new CustomerReviewService(() => _repository.Object);
}
public void GetByIds_ExistingId_ReturnsItemWithSameId()
{
string testReviewId = "testReviewId";
var getByIdsResult = CustomerReviewService.GetByIds(new[] { testReviewId });
Assert.Single(getByIdsResult);
Assert.Equal(testReviewId, getByIdsResult[0].Id);
}
public void GetByIds_NonExistingId_ReturnsEmpty()
{
string nonExistingId = "nonExistingId";
var getByIdsResult = CustomerReviewService.GetByIds(new[] { nonExistingId });
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
}
public void CanDeleteCustomerReviews()
{
CustomerReviewService.DeleteCustomerReviews(new[] { CustomerReviewId });
CustomerReview[] getByIdsResult = CustomerReviewService.GetByIds(new[] { CustomerReviewId });
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
}
public void CanDoCRUDandSearch()
{
// Read non-existing item
var getByIdsResult = CustomerReviewService.GetByIds(new[] { CustomerReviewId });
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
// Create
var item = new CustomerReview
{
Id = CustomerReviewId,
ProductId = ProductId,
CreatedDate = DateTime.Now,
CreatedBy = "initial data seed",
AuthorNickname = "John Doe",
Content = "Liked that",
Virtues = "Liked that!",
Disadvantages = "Not",
Rate = 3
};
CustomerReviewService.SaveCustomerReviews(new[] { item });
getByIdsResult = CustomerReviewService.GetByIds(new[] { CustomerReviewId });
Assert.Single(getByIdsResult);
item = getByIdsResult[0];
Assert.Equal(CustomerReviewId, item.Id);
// Update
var updatedContent = "Updated content";
Assert.NotEqual(updatedContent, item.Content);
item.Content = updatedContent;
CustomerReviewService.SaveCustomerReviews(new[] { item });
getByIdsResult = CustomerReviewService.GetByIds(new[] { CustomerReviewId });
Assert.Single(getByIdsResult);
item = getByIdsResult[0];
Assert.Equal(updatedContent, item.Content);
// Search
Assert.Throws <ArgumentNullException>(() => CustomerReviewSearchService.SearchCustomerReviews(null));
var criteria = new CustomerReviewSearchCriteria {
ProductIds = new[] { ProductId }
};
var searchResult = CustomerReviewSearchService.SearchCustomerReviews(criteria);
Assert.NotNull(searchResult);
Assert.Equal(1, searchResult.TotalCount);
Assert.Single(searchResult.Results);
// Delete
CanDeleteCustomerReviews();
}
public CustomerReviewServiceTests()
{
randomizer = new Fixture();
customerReviewsApi = new Mock <ICustomerReviewsModule>();
memoryCache = new Mock <IStorefrontMemoryCache>();
apiChangesWatcher = new Mock <IApiChangesWatcher>();
service = new CustomerReviewService(customerReviewsApi.Object, memoryCache.Object, apiChangesWatcher.Object);
}
public async Task CanDeleteCustomerReviews()
{
await CustomerReviewService.DeleteCustomerReviewsAsync(new[] { CustomerReviewId });
var getByIdsResult = await CustomerReviewService.GetByIdsAsync(new[] { CustomerReviewId });
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
}
public void DeleteCustomerReviews_NonExistingItem_ReturnsEmpty()
{
string nonExistingId = "nonExistingId";
CustomerReviewService.DeleteCustomerReviews(new[] { nonExistingId });
var getByIdsResult = CustomerReviewService.GetByIds(new[] { nonExistingId });
Assert.Empty(getByIdsResult);
}
public void DeleteCustomerReviews_ExistingItem_ItemDeletes()
{
string dropReviewId = "dropReviewId";
CreateNewReview(dropReviewId);
CustomerReviewService.DeleteCustomerReviews(new[] { dropReviewId });
var getByIdsResult = CustomerReviewService.GetByIds(new[] { dropReviewId });
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
}
public CustomerReviewModuleTests()
{
_mockUnitOfWork = new Mock <IUnitOfWork>();
_mockCustomerReviewRepository = new Mock <ICustomerReviewRepository>();
_mockUnitOfWork = new Mock <IUnitOfWork>();
_mockCustomerReviewRepository.Setup(ss => ss.UnitOfWork).Returns(_mockUnitOfWork.Object);
_platformMemoryCacheMock = new Mock <IPlatformMemoryCache>();
_cacheEntryMock = new Mock <ICacheEntry>();
_cacheEntryMock.SetupGet(c => c.ExpirationTokens).Returns(new List <IChangeToken>());
var cacheKey = CacheKey.With(CustomerReviewService.GetType(), "GetByIdsAsync", string.Join("-", CustomerReviewId));
_platformMemoryCacheMock.Setup(pmc => pmc.CreateEntry(cacheKey)).Returns(_cacheEntryMock.Object);
}
private void CreateNewReview(string rewiewId)
{
var item = new CustomerReview
{
Id = rewiewId,
ProductId = "newProductId",
CreatedDate = DateTime.Now,
CreatedBy = "xUnit tests",
AuthorNickname = "xUnit",
Content = "xUnit likes this",
Rating = 1
};
CustomerReviewService.SaveCustomerReviews(new[] { item });
}
public void SaveCustomerReviews_ExistingItem_ReturnsSameItem()
{
string testReviewId = "testReviewId";
string testProductId = "testProductId";
var item = new CustomerReview
{
Id = testReviewId,
ProductId = testProductId,
CreatedDate = DateTime.Now,
CreatedBy = "xUnit tests",
AuthorNickname = "xUnit",
Content = "xUnit likes this " + DateTime.Now.ToString(),
Rating = 1
};
CustomerReviewService.SaveCustomerReviews(new[] { item });
var getByIdsResult = CustomerReviewService.GetByIds(new[] { testReviewId });
Assert.Single(getByIdsResult);
}
public void CheckCalculateAverageProductRating()
{
const int firstRating = 2;
const int secondRating = 5;
const int reviewsCount = 2;
const double averageRating = 3.5D;
var firstItem = new CustomerReview
{
ProductId = ProductId,
AuthorNickname = "Test author",
Content = "Test content",
IsActive = true,
ProductRating = firstRating
};
var secondItem = new CustomerReview
{
ProductId = ProductId,
AuthorNickname = "Test author",
Content = "Test content",
IsActive = true,
ProductRating = secondRating
};
try
{
CustomerReviewService.SaveCustomerReview(firstItem);
CustomerReviewService.SaveCustomerReview(secondItem);
var productRating = CustomerReviewService.GetAverageProductRating(ProductId);
Assert.Equal(ProductId, productRating.ProductId);
Assert.Equal(reviewsCount, productRating.ReviewsCount);
Assert.Equal(averageRating, productRating.Rating);
}
finally
{
CustomerReviewService.DeleteCustomerReviews(new[] { firstItem.Id, secondItem.Id });
}
}
public void CanCreateCustomerReview()
{
var item = new CustomerReview
{
ProductId = ProductId,
AuthorNickname = "John Doe",
Content = "Liked that",
IsActive = true,
ProductRating = 4,
PropertyValues = new[]
{
new FavoritePropertyValue
{
Id = Guid.NewGuid().ToString("N"),
Property = new FavoriteProperty
{
Id = "1",
ProductId = ProductId,
Name = "Sound quality"
},
PropertyId = "1",
Rating = 5
}
}
};
try
{
CustomerReviewService.SaveCustomerReview(item);
Assert.False(item.IsTransient());
var getByIdItem = CustomerReviewService.GetById(item.Id);
Assert.NotNull(getByIdItem);
}
finally
{
CustomerReviewService.DeleteCustomerReviews(new[] { item.Id });
}
}
public void CanNotSaveCustomerReviews()
{
// Try create review for test
var item = new CustomerReview
{
Id = CustomerReviewId,
ProductId = ProductId,
CreatedDate = DateTime.Now,
CreatedBy = "initial data seed",
AuthorNickname = "John Doe",
Content = "Liked that",
Rate = 10
};
CustomerReviewService.SaveCustomerReviews(new[] { item });
// Check result
var getByIdsResult = CustomerReviewService.GetByIds(new[] { CustomerReviewId });
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
}
public async Task CanDoCRUDandSearch()
{
// Read non-existing item
var getByIdsResult = await CustomerReviewService.GetByIdsAsync(new[] { CustomerReviewId });
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
// Create
var item = new CustomerReview
{
Id = CustomerReviewId,
ProductId = ProductId,
CreatedDate = DateTime.Now,
CreatedBy = "initial data seed",
CustomerName = "John Doe",
ReviewContent = "Liked that"
};
await CustomerReviewService.SaveCustomerReviewsAsync(new[] { item });
_mockCustomerReviewRepository.Setup(ss => ss.GetByIdsAsync(new[] { CustomerReviewId }))
.ReturnsAsync(new[] { new CustomerReviewEntity().FromModel(item, new PrimaryKeyResolvingMap()) });
getByIdsResult = await CustomerReviewService.GetByIdsAsync(new[] { CustomerReviewId });
Assert.Single(getByIdsResult);
item = getByIdsResult[0];
Assert.Equal(CustomerReviewId, item.Id);
// Update
var updatedContent = "Updated content";
Assert.NotEqual(updatedContent, item.ReviewContent);
item.ReviewContent = updatedContent;
await CustomerReviewService.SaveCustomerReviewsAsync(new[] { item });
getByIdsResult = await CustomerReviewService.GetByIdsAsync(new[] { CustomerReviewId });
Assert.Single(getByIdsResult);
item = getByIdsResult[0];
Assert.Equal(updatedContent, item.ReviewContent);
// Search
var mockReviews = new[] { new CustomerReviewEntity().FromModel(item, new PrimaryKeyResolvingMap()) }.AsQueryable().BuildMock();
_mockCustomerReviewRepository.SetupGet(x => x.CustomerReviews).Returns(mockReviews.Object);
var criteria = new CustomerReviewSearchCriteria {
ProductIds = new[] { ProductId }
};
var cacheKey = CacheKey.With(CustomerReviewSearchService.GetType(), nameof(CustomerReviewSearchService.SearchCustomerReviewsAsync), criteria.GetCacheKey());
_platformMemoryCacheMock.Setup(pmc => pmc.CreateEntry(cacheKey)).Returns(_cacheEntryMock.Object);
var searchResult = await CustomerReviewSearchService.SearchCustomerReviewsAsync(criteria);
Assert.NotNull(searchResult);
Assert.Equal(1, searchResult.TotalCount);
Assert.Single(searchResult.Results);
// Delete
_mockCustomerReviewRepository.Setup(ss => ss.GetByIdsAsync(new[] { CustomerReviewId }))
.ReturnsAsync(new CustomerReviewEntity[0]);
await CanDeleteCustomerReviews();
}
public void DeleteCustomerReviews_Null_ThrowsArgumentNullException()
{
Action actual = () => CustomerReviewService.DeleteCustomerReviews(null);
Assert.Throws <ArgumentNullException>(actual);
}
