public async Task DeleteAsyncShould_ReturnsFalseIf_EventCreatorIsAnotherUser_And_ShouldNotDeleteArticle_AndImage()
{
const string anotherAuthorId = "899f4fgg5f57dm888m";
//Arrange
var picServiceMock = IPictureServiceMock.New(imageToDeleteId);
var service = new BlogArticleService(Db, null, picServiceMock.Object);
var author = UserCreator.Create();
await this.Db.AddAsync(author);
var article = ArticleCreator.Create(author.Id, null);
await this.Db.AddAsync(article);
await this.Db.SaveChangesAsync();
//Act
var result = await service.DeleteAsync(article.Id, anotherAuthorId);
//Assert
result.Should().BeFalse();
picServiceMock.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Never);
this.Db.Articles.Should().Contain(a => a.Id == article.Id);
}
public async Task CreateAsyncShould_SetTheCorrectParametersForArticlePropertiesAnd_ReturnsArticleId()
{
const int NewImageId = 258;
const string Title = "Title";
const string Content = "Content123";
const string AuthorId = "8945opi7563k87";
//Arrange
var picService = IPictureServiceMock.New(NewImageId);
var htmlService = IHtmlServiceMock.New(Content);
var service = new BlogArticleService(Db, htmlService.Object, picService.Object);
//Act
var resultId = await service.CreateAsync(Title, Content, null, AuthorId);
var savedEntry = await Db.FindAsync <Article>(resultId);
//Assert
resultId.Should().Be(savedEntry.Id);
htmlService.Verify(h => h.Sanitize(It.IsAny <string>()), Times.Once);
picService.Verify(p =>
p.UploadImageAsync(It.IsAny <string>(), It.IsAny <IFormFile>()), Times.Once);
savedEntry.Id.Should().Be(resultId);
savedEntry.Title.Should().Match(Title);
savedEntry.Content.Should().Match(Content);
savedEntry.AuthorId.Should().Match(AuthorId);
savedEntry.CloudinaryImageId.Should().Be(NewImageId);
}
public async Task UpdateAsyncShould_ReturnsTrue_IfManagerForAllRegionsUpdatesIssue_WithPictureFile()
{
//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.All);
await Db.AddAsync(manager);
var issue = UrbanIssueCreator.CreateIssue(RegionType.Western);
await Db.AddAsync(issue);
await Db.SaveChangesAsync();
var pictureFile = new Mock <IFormFile>();
//Act
var result = await service.UpdateAsync(
manager, issue.Id, null, null, issue.Region, IssueType.DamagedRoads, null, pictureFile : pictureFile.Object);
//Assert
result.Should().BeTrue();
pictureService.Verify(p => p.UploadImageAsync(It.IsAny <string>(), It.IsAny <IFormFile>()), Times.Once);
pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Once);
activityService.Verify(a => a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Once);
}
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 DeleteAsyncShould_ReturnsFalse_IfManagerRegionIsNotEqualToIssueRegion()
{
//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.Central);
await Db.AddAsync(manager);
var issue = UrbanIssueCreator.CreateIssue(RegionType.Western);
await Db.AddAsync(issue);
await Db.SaveChangesAsync();
//Act
var result = await service.DeleteAsync(manager.Id, manager.ManagedRegion, issue.Id);
//Assert
result.Should().BeFalse();
pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Never);
activityService.Verify(a =>
a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Never);
}
public async Task CreateAsyncShould_ReturnsEventId_AndShould_SetsThePropertiesOfEventCorrectly()
{
//Arrange
var picService = IPictureServiceMock.New(DefaultImageId);
var service = new EventService(Db, picService.Object);
var user = UserCreator.Create();
await this.Db.AddAsync(user);
await this.Db.SaveChangesAsync();
var formFile = new Mock <IFormFile>();
//Act
int resultId = await service.CreateAsync(TitleToSet, DescriptionToSet, startDateToSet, endDateToSet,
formFile.Object, AddressToSet, LatitudeToSet, LongitudeToSet, user.Id);
//Assert
resultId.Should().BeOfType(typeof(int));
picService.Verify(p => p.UploadImageAsync(It.IsAny <string>(), It.IsAny <IFormFile>()), Times.Once);
var savedEvent = Db.Find <Event>(resultId);
savedEvent.Id.Should().Be(resultId);
savedEvent.Title.Should().Match(TitleToSet);
savedEvent.Address.Should().Match(AddressToSet);
savedEvent.CreatorId.Should().Match(user.Id);
savedEvent.EndDate.Should().Be(endDateToSet);
savedEvent.StartDate.Should().Be(startDateToSet);
savedEvent.Description.Should().Match(DescriptionToSet);
savedEvent.Latitude.Should().BeOfType(typeof(double));
savedEvent.Longitude.Should().BeOfType(typeof(double));
}
public async Task DeleteAsyncShould_ReturnsTrueAnd_DeletesCorrectResolvedIssue()
{
//Arrange
var activityService = new Mock <IManagerActivityService>();
var pictureService = IPictureServiceMock.New(DefaultPicId);
var issueService = new Mock <IManagerIssueService>();
var service = new ResolvedService(Db, issueService.Object, pictureService.Object, activityService.Object);
var(managerId, secondIssue, secondResolved, resolved) =
await ResolvedCreator.CreateResolvedManagerAndIssue(Db);
//Act
var result = await service.DeleteAsync(managerId, secondResolved.Id);
var resolvedIssuesAfter = await this.Db.ResolvedIssues.ToListAsync();
var urbanIssueAfter = await this.Db.UrbanIssues.Where(i => i.Id == secondIssue.Id).FirstOrDefaultAsync();
//Assert
result.Should().BeTrue();
Db.ResolvedIssues.Should().HaveCount(resolvedIssuesAfter.Count);
Db.ResolvedIssues.Should().BeEquivalentTo(resolvedIssuesAfter);
urbanIssueAfter.ResolvedIssue.Should().BeNull();
issueService.Verify(i => i.RemoveResolvedReferenceAsync(It.IsAny <int>()), Times.Once);
pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Once);
activityService.Verify(a =>
a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Once);
}
public async Task UpdateAsyncShould_ReturnsTrueAnd_ChangesResolvedPictureFileHasPassed()
{
//Arrange
var issueService = new Mock <IManagerIssueService>();
var pictureService = IPictureServiceMock.New(DefaultPicId);
var activityService = new Mock <IManagerActivityService>();
var service = new ResolvedService(Db, issueService.Object, pictureService.Object, activityService.Object);
var(manager, resolved) = await ResolvedCreator.CreateResolvedAndManager(Db);
var file = new Mock <IFormFile>();
var oldImage = resolved.CloudinaryImage;
//Act
var result = await service.UpdateAsync(manager.Id, resolved.Id, ChangedDescription, file.Object);
//Assert
result.Should().BeTrue();
resolved.CloudinaryImage.Should().NotBe(oldImage);
resolved.CloudinaryImageId.Should().Be(DefaultPicId);
resolved.Description.Should().NotMatch(DefaultDescription);
resolved.Description.Should().Match(ChangedDescription);
pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Once);
activityService.Verify(a =>
a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Once);
}
public async Task UploadAsyncShould()
{
const string UserId = "rt8856dse45e12ds2";
const string Title = "Title";
const string Description = "Description";
const string Address = "Address";
const string Latitude = "42.36";
const string Longitude = "41.458";
string issueType = IssueType.DangerousTrees.ToString();
string region = RegionType.Western.ToString();
//Arrange
var pictureService = IPictureServiceMock.New(DefaultImageId);
//TODO: move this tests in IssueServiceTests
var service = new IssueService(this.Db, pictureService.Object);
var picFile = new Mock <IFormFile>();
//Act
var result = await service.UploadAsync(UserId, Title, Description, picFile.Object, issueType, region,
Address, Latitude, Longitude);
//Assert
result.Should().BeOfType(typeof(int));
pictureService.Verify(p => p.UploadImageAsync(It.IsAny <string>(), It.IsAny <IFormFile>()), Times.Once);
var savedIssue = this.Db.Find <UrbanIssue>(result);
savedIssue.Id.Should().Be(result);
savedIssue.Title.Should().Match(Title);
savedIssue.Description.Should().Match(Description);
savedIssue.Latitude.Should().Be(double.Parse(Latitude.Trim(), CultureInfo.InvariantCulture));
savedIssue.Longitude.Should().Be(double.Parse(Longitude.Trim(), CultureInfo.InvariantCulture));
savedIssue.AddressStreet.Should().Match(Address);
savedIssue.PublisherId.Should().Match(UserId);
savedIssue.Type.Should().Be(Enum.Parse <IssueType>(issueType));
savedIssue.Region.Should().Be(Enum.Parse <RegionType>(region));
savedIssue.CloudinaryImageId.Should().Be(DefaultImageId);
}
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 UpdateAsyncShould_ReturnsFalseIf_UpdaterIsNotTheSameAsUploader()
{
//Arrange
var publisher = UserCreator.Create();
var updater = UserCreator.Create();
await this.Db.AddRangeAsync(publisher, updater);
var issue = UrbanIssueCreator.CreateIssue(RegionType.All);
await this.Db.AddAsync(issue);
var resolved = ResolvedCreator.Create(publisher.Id, issue.Id, DefaultPicId);
await this.Db.AddAsync(resolved);
await this.Db.SaveChangesAsync();
var issueService = new Mock <IManagerIssueService>();
var pictureService = IPictureServiceMock.New(DefaultPicId);
var activityService = new Mock <IManagerActivityService>();
var service = new ResolvedService(Db, issueService.Object, pictureService.Object, activityService.Object);
//Act
var result = await service.UpdateAsync(updater.Id, resolved.Id, ChangedDescription, null);
var resolvedAfterAct = await this.Db.FindAsync <ResolvedIssue>(resolved.Id);
//Assert
result.Should().Be(false);
resolved.Should().BeEquivalentTo(resolvedAfterAct);
pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Never);
activityService.Verify(a =>
a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Never);
}
public async Task DeleteAsyncShould_ReturnsFalse_IfManagerId_IsNotEqualTo_ResolvedPublisherId()
{
//Arrange
var issueService = new Mock <IManagerIssueService>();
var pictureService = IPictureServiceMock.New(DefaultPicId);
var activityService = new Mock <IManagerActivityService>();
var service = new ResolvedService(Db, issueService.Object, pictureService.Object, activityService.Object);
var manager = UserCreator.Create();
var publisher = UserCreator.Create();
await Db.AddRangeAsync(manager, publisher);
var issue = UrbanIssueCreator.CreateIssue(RegionType.All);
await Db.AddAsync(issue);
var resolved = ResolvedCreator.Create(publisher.Id, issue.Id, 0);
await Db.AddAsync(resolved);
await Db.SaveChangesAsync();
//Act
var result = await service.DeleteAsync(manager.Id, resolved.Id);
//Assert
result.Should().BeFalse();
issueService.Verify(i => i.RemoveResolvedReferenceAsync(It.IsAny <int>()), Times.Never);
pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Never);
activityService.Verify(a =>
a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Never);
}
