public async Task DeleteImageAsyncShould_DeleteTheImageFromCloudAnd_ImageInfoFromDB()
{
//Arrange
var cloudService = new Mock <ICloudImageService>();
cloudService.Setup(cs => cs.UploadFormFileAsync(It.IsAny <IFormFile>()))
.Returns(It.IsAny <Task <ImageUploadResult> >());
var picInfoWriter = new Mock <IPictureInfoWriterService>();
var service = new PictureService(this.Db, cloudService.Object, picInfoWriter.Object);
var user = UserCreator.Create();
await this.Db.AddAsync(user);
var image = ImageInfoCreator.CreateWithFullData(user.Id);
await this.Db.AddAsync(image);
await this.Db.SaveChangesAsync();
//Act
await service.DeleteImageAsync(image.Id);
//Assert
cloudService.Verify(c => c.DeleteImages(It.IsAny <string>()), Times.Once);
this.Db.CloudinaryImages
.FirstOrDefault(i => i.Id == DefaultImageId).Should().BeNull();
}
public async Task DeleteAsyncShould_ReturnsTrueIf_EventCreatorIsAnotherUser_AndShouldDeleteArticle_AndImage()
{
//Arrange
var picServiceMock = IPictureServiceMock.New(imageToDeleteId);
var service = new BlogArticleService(Db, null, picServiceMock.Object);
var author = UserCreator.Create();
await this.Db.AddAsync(author);
var image = ImageInfoCreator.CreateWithFullData(author.Id);
await this.Db.AddAsync(image);
var article = ArticleCreator.Create(author.Id, imageToDeleteId);
await this.Db.AddAsync(article);
await this.Db.SaveChangesAsync();
//Act
var result = await service.DeleteAsync(article.Id, author.Id);
//Assert
result.Should().BeTrue();
picServiceMock.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Once);
this.Db.Articles.Should().NotContain(a => a.Id == article.Id);
}
public async Task RemoveResolvedReferenceAsyncShould_SettsIssuePropertyResolvedIssueToNull()
{
//Arrange
var service = new ManagerIssueService(Db, null, null);
var user = UserCreator.Create(null);
await Db.AddAsync(user);
var pic = ImageInfoCreator.Create();
await Db.AddAsync(pic);
var issue = UrbanIssueCreator.CreateIssue(true, RegionType.Western, user.Id, pic.Id);
await Db.AddAsync(issue);
var resolved = ResolvedCreator.Create(user.Id, issue.Id, pic.Id);
await Db.AddAsync(resolved);
var hasResolvedBefore = issue.ResolvedIssue != null; //true
//Act
await service.RemoveResolvedReferenceAsync(issue.Id);
var hasResolvedAfter = issue.ResolvedIssue != null; //false
//Assert
hasResolvedAfter.Should().BeFalse();
hasResolvedAfter.Should().IsSameOrEqualTo(!hasResolvedBefore);
}
public async Task TotalAsyncShould_ReturnsCorrectCountOf_AllApprovedAnd_CountOfAllNotApprovedIssues(bool takeApproved)
{
//Arrange
//TODO: rearrange test - now issueService has more parameters
var service = new IssueService(this.Db, null);
var user = UserCreator.Create();
await this.Db.AddAsync(user);
var image = ImageInfoCreator.CreateWithFullData(user.Id);
await this.Db.AddRangeAsync(image);
var issue = CreateIssue(true, RegionType.Central, user.Id, image.Id);
var secondIssue = CreateIssue(true, RegionType.Eastern, user.Id, image.Id);
await this.Db.AddRangeAsync(issue, secondIssue);
var notApprovedIssue = CreateIssue(false, RegionType.North, user.Id, image.Id);
var secondNotApprovedIssue = CreateIssue(true, RegionType.North, user.Id, image.Id);
await this.Db.AddRangeAsync(notApprovedIssue, secondNotApprovedIssue);
await this.Db.SaveChangesAsync();
//Act
var resultCount = await service.TotalAsync(isApproved : takeApproved);
var expectedCount = await this.Db.UrbanIssues.Where(i => i.IsApproved == takeApproved).CountAsync();
//Assert
resultCount.Should().Be(expectedCount);
}
public async Task ParticipateShould_ReturnsTrueIf_UserIsNotParticipatingEvent()
{
//Arrange
var user = UserCreator.Create();
await this.Db.AddAsync(user);
var image = ImageInfoCreator.Create();
await this.Db.AddAsync(image);
var firstEvent = EventCreator.Create(user.Id, null);
await this.Db.AddAsync(firstEvent);
await this.Db.SaveChangesAsync();
var service = new EventService(Db, null);
//Act
var result = await service.Participate(firstEvent.Id, user.Id);
//Assert
result.Should().BeTrue();
this.Db.EventUsers.Should().Contain(eu => eu.EventId == firstEvent.Id && eu.ParticipantId == user.Id);
}
public async Task ParticipateShould_ReturnFalseIf_UserIsAlreadyParticipatingEvent()
{
//Arrange
var user = UserCreator.Create();
await this.Db.AddAsync(user);
var image = ImageInfoCreator.Create();
await this.Db.AddAsync(image);
var firstEvent = EventCreator.Create(user.Id, null);
await this.Db.AddAsync(firstEvent);
var eventUser = EventCreator.CreateEventUser(firstEvent.Id, user.Id);
await this.Db.AddAsync(eventUser);
await this.Db.SaveChangesAsync();
var service = new EventService(Db, null);
//Act
var result = await service.Participate(firstEvent.Id, user.Id);
//Assert
result.Should().Be(false);
}
public async Task EditAsyncShould_ReturnsTrue_AndShould_SetsThePropertiesOfEventCorrectly()
{
//Arrange
var creator = UserCreator.Create();
await this.Db.AddAsync(creator);
var img = ImageInfoCreator.CreateWithFullData(creator.Id);
await this.Db.AddAsync(img);
var eventObj = EventCreator.Create(creator.Id, img.Id);
await this.Db.AddAsync(eventObj);
await this.Db.SaveChangesAsync();
var service = new EventService(Db, null);
//Act
var result = await service.EditAsync(eventObj.Id, creator.Id, TitleToSet, DescriptionToSet, startDateToSet,
endDateToSet, AddressToSet, LatitudeToSet, LongitudeToSet);
//Assert
result.Should().BeTrue();
eventObj.Title.Should().Match(TitleToSet);
eventObj.Address.Should().Match(AddressToSet);
eventObj.CreatorId.Should().Match(creator.Id);
eventObj.EndDate.Should().Be(endDateToSet);
eventObj.StartDate.Should().Be(startDateToSet);
eventObj.Description.Should().Match(DescriptionToSet);
eventObj.Latitude.Should().Be(double.Parse(LatitudeToSet, CultureInfo.InvariantCulture));
eventObj.Longitude.Should().Be(double.Parse(LongitudeToSet, CultureInfo.InvariantCulture));
}
public async Task AllMapInfoDetailsAsync(bool isApprovedParam, RegionType regionParam)
{
//Arrange
var user = UserCreator.Create();
await this.Db.AddAsync(user);
var image = ImageInfoCreator.CreateWithFullData(user.Id);
await this.Db.AddRangeAsync(image);
var issue = CreateIssue(true, RegionType.All, user.Id, image.Id);
var secondIssue = CreateIssue(true, RegionType.Thracia, user.Id, image.Id);
var thirdIssue = CreateIssue(true, RegionType.Western, user.Id, image.Id);
var notApprovedIssue = CreateIssue(false, RegionType.Western, user.Id, image.Id);
var secondNotApproved = CreateIssue(false, RegionType.Eastern, user.Id, image.Id);
await this.Db.AddRangeAsync(issue, secondIssue, thirdIssue, notApprovedIssue, secondNotApproved);
await this.Db.SaveChangesAsync();
//TODO: rearrange test - now issueService has more parameters
var service = new IssueService(this.Db, null);
//Act
var resultModel = (await service.AllMapInfoDetailsAsync <IssueMapInfoBoxModel>(isApprovedParam, regionParam)).ToList();
var issuesToNotContain = this.Db.UrbanIssues.Where(i => i.IsApproved != isApprovedParam);
var notContainFromAnotherRegions = this.Db.UrbanIssues.Where(i => i.Region != regionParam);
//Assert
resultModel.Should().AllBeOfType <IssueMapInfoBoxModel>();
resultModel.Should().NotContain(issuesToNotContain);
if (regionParam != RegionType.All)
{
resultModel.Should().NotContain(notContainFromAnotherRegions);
}
}
public async Task AllAsyncShould_ReturnsApprovedAndNotApprovedIssuesWith_CorrectModel(bool isApproved, RegionType concreteRegion)
{
//Arrange
var service = new ManagerIssueService(Db, null, null);
var user = UserCreator.Create(null);
await Db.AddAsync(user);
var pic = ImageInfoCreator.Create();
await Db.AddAsync(pic);
var issue = UrbanIssueCreator.CreateIssue(true, RegionType.Western, user.Id, pic.Id);
var secondIssue = UrbanIssueCreator.CreateIssue(true, RegionType.Thracia, user.Id, pic.Id);
var thirdIssue = UrbanIssueCreator.CreateIssue(false, RegionType.Western, user.Id, pic.Id);
var fourthIssue = UrbanIssueCreator.CreateIssue(false, RegionType.North, user.Id, pic.Id);
var fifthIssue = UrbanIssueCreator.CreateIssue(false, RegionType.Thracia, user.Id, pic.Id);
var sixthIssue = UrbanIssueCreator.CreateIssue(false, RegionType.Western, user.Id, pic.Id);
var seventhIssue = UrbanIssueCreator.CreateIssue(true, RegionType.South, user.Id, pic.Id);
await Db.UrbanIssues.AddRangeAsync(issue, secondIssue, thirdIssue, fourthIssue, fifthIssue, sixthIssue, seventhIssue);
await Db.SaveChangesAsync();
//Act
//TODO: change test - no has new parameters - page and takeCount
(int count, var resultAllRegions) = (await service.AllAsync <IssuesListingModel>(isApproved, RegionType.All, 1, 5));
var expectedAllRegions = await this.Db.UrbanIssues.Where(i => i.IsApproved == isApproved).ToListAsync();
(int countConcreteRegion, var resultConcreteRegion) = (await service.AllAsync <IssuesListingModel>(isApproved, concreteRegion, 1, 5));
var expectedConcreteRegion = await this.Db.UrbanIssues.Where(i => i.IsApproved == isApproved)
.Where(i => i.Region == concreteRegion).ToListAsync();
//Assert
resultAllRegions.Should().AllBeOfType <IssuesListingModel>();
resultAllRegions.Should().HaveCount(expectedAllRegions.Count);
resultConcreteRegion.Should().HaveCount(expectedConcreteRegion.Count);
resultConcreteRegion.Should().HaveCount(expectedConcreteRegion.Count);
}
public async Task DeleteAsyncShould_ReturnsTrue_IfManagerRegionIsEqualToIssueRegion_OrManagerIsForAllRegions()
{
//Arrange
var pictureService = IPictureServiceMock.New(DefaultImageId);
var activityService = new Mock <IManagerActivityService>();
var service = new ManagerIssueService(Db, pictureService.Object, activityService.Object);
var manager = UserCreator.Create(RegionType.Western);
var secondManager = UserCreator.Create(RegionType.All);
await Db.AddRangeAsync(manager, secondManager);
var pic = ImageInfoCreator.Create();
var secondPic = ImageInfoCreator.Create();
await Db.AddRangeAsync(pic, secondPic);
var issue = UrbanIssueCreator.CreateIssue(RegionType.Western, pic.Id);
var secondIssue = UrbanIssueCreator.CreateIssue(RegionType.South, secondPic.Id);
await Db.AddRangeAsync(issue, secondIssue);
await Db.SaveChangesAsync();
//Act
var result = await service.DeleteAsync(manager.Id, manager.ManagedRegion, issue.Id);
var result2 = await service.DeleteAsync(secondManager.Id, secondManager.ManagedRegion, secondIssue.Id);
//Assert
result.Should().BeTrue();
result2.Should().BeTrue();
pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Exactly(2));
activityService.Verify(a =>
a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Exactly(2));
}
public async Task GetAsyncShould_ReturnsCorrectModel()
{
//Arrange
//TODO: rearrange test - now issueService has more parameters
var service = new IssueService(this.Db, null);
var user = UserCreator.Create();
await this.Db.AddAsync(user);
var image = ImageInfoCreator.CreateWithFullData(user.Id);
await this.Db.AddRangeAsync(image);
var issue = CreateIssue(true, RegionType.Western, user.Id, image.Id);
var secondIssue = CreateIssue(true, RegionType.Central, user.Id, image.Id);
await this.Db.AddRangeAsync(issue, secondIssue);
await this.Db.SaveChangesAsync();
//Act
var result = await service.GetAsync <IssueEditViewModel>(issue.Id);
var secondResult = await service.GetAsync <IssueDetailsModel>(secondIssue.Id);
//Assert
result.Should().BeOfType <IssueEditViewModel>();
result.Id.Should().Be(issue.Id);
result.Publisher.Should().Match(user.UserName);
secondResult.Should().BeOfType <IssueDetailsModel>();
secondResult.Id.Should().Be(secondIssue.Id);
secondResult.HasResolved.Should().Be(secondIssue.ResolvedIssue != null);
secondResult.Latitude.Should().Be(secondIssue.Latitude.ToString().Replace(",", "."));
secondResult.Longitude.Should().Be(secondIssue.Longitude.ToString().Replace(",", "."));
secondResult.IssuePictureUrl.Should().Be(secondIssue.CloudinaryImage.PictureUrl);
}
public async Task GetAsyncShould_ReturnsCorrectArticleModel()
{
//Arrange
var user = UserCreator.Create();
await this.Db.AddAsync(user);
var image = ImageInfoCreator.CreateWithFullData(user.Id);
await this.Db.AddAsync(image);
var article = ArticleCreator.Create(user.Id, image.Id);
var secondArticle = ArticleCreator.Create(user.Id, image.Id);
var thirdArticle = ArticleCreator.Create(user.Id, image.Id);
await this.Db.AddRangeAsync(article, secondArticle, thirdArticle);
await this.Db.SaveChangesAsync();
var service = new BlogArticleService(Db, null, null);
//Act
var result = await service.GetAsync <ArticleDetailsModel>(secondArticle.Id);
var secondResult = await service.GetAsync <EditArticleViewModel>(article.Id);
var thirdResult = await service.GetAsync <EditArticleViewModel>(4589);
//Assert
result.Should().BeOfType <ArticleDetailsModel>();
Assert.Equal(secondArticle.Id, result.Id);
secondResult.Should().BeOfType <EditArticleViewModel>();
Assert.Equal(article.Id, secondResult.Id);
Assert.Null(thirdResult);
}
