public async Task SetsArticleToDeletedWhenFound()
{
var article = new ArticleFixture().Build();
var contextFixture = new MockBlogApiDbContextFixture()
.With(article, article.Id);
var mock = contextFixture.Mock;
var fixture = new DeleteArticleCoordinatorFixture
{
Context = contextFixture.Build()
};
var coordinator = fixture.Build();
Assert.False(article.IsDeleted);
Assert.Null(article.Deleted);
var deleteResult = await coordinator.TryDeleteArticle(article.Id);
Assert.True(deleteResult);
Assert.True(article.IsDeleted);
Assert.NotNull(article.Deleted);
mock.Verify(ctx => ctx.SaveChanges());
}
public BogMarkdownConverterStrategyFixture()
{
BogMarkdownConverter = new Mock <IBogMarkdownConverter>().Object;
GetLatestArticleEntryStrategy = new GetLatestArticleEntryStrategyFixture().Build();
Context = new MockBlogApiDbContextFixture().Build();
UploadArticleEntryCoordinator = new UploadArticleEntryCoordinatorFixture().Build();
}
public async Task CreatesNewEntryWhenArticleFound()
{
var article = new ArticleFixture().Build();
var mockClock = new MockClock();
var dbContextFixture = new MockBlogApiDbContextFixture();
dbContextFixture.Mock
.Setup(ctx => ctx.Find <Article>(It.IsAny <Guid>()))
.ReturnsAsync(() => article);
var createArticleEntryCoordinator = new CreateArticleEntryCoordinatorFixture
{
Context = dbContextFixture.Build(),
Clock = mockClock
}.Build();
var result = await createArticleEntryCoordinator.CreateArticleEntry(article.Id, new ArticleEntry());
Assert.Equal(article.Id, result.ArticleId);
Assert.Equal(mockClock.Now, result.Created);
dbContextFixture.Mock.Verify(ctx => ctx.Find <Article>(article.Id));
dbContextFixture.Mock.Verify(ctx => ctx.Add(result));
dbContextFixture.Mock.Verify(ctx => ctx.SaveChanges());
}
public async Task DoesNothingIfArticleAlreadyMarkedAsDeleted()
{
var article = new ArticleFixture
{
IsDeleted = true
}.Build();
var contextFixture = new MockBlogApiDbContextFixture()
.With(article, article.Id);
var mock = contextFixture.Mock;
var fixture = new DeleteArticleCoordinatorFixture
{
Context = contextFixture.Build()
};
var coordinator = fixture.Build();
Assert.True(article.IsDeleted);
var deleteResult = await coordinator.TryDeleteArticle(article.Id);
Assert.True(deleteResult);
mock.Verify(ctx => ctx.SaveChanges(), Times.Never);
}
public async Task DoesNotAddNewTagsIfTheyAlreadyExistOnArticle()
{
var newTagToAdd = new MetaTagRequest
{
Name = "SomeTag"
};
var existingArticleWithTags = new ArticleFixture().WithTags(newTagToAdd).Build();
var mockContext = new MockBlogApiDbContextFixture();
mockContext.Mock.Setup(ctx => ctx.Query <Article>(It.IsAny <string>()))
.Returns(new[] { existingArticleWithTags }.AsQueryable());
var coordinator = new AddMetaTagForArticleCoordinatorFixture
{
Context = mockContext.Build()
}.Build();
var result = await coordinator.AddArticleMetaTags(existingArticleWithTags.Id, newTagToAdd);
Assert.Null(result);
mockContext.Mock.Verify(ctx => ctx.Add(It.IsAny <MetaTag[]>()), Times.Never);
mockContext.Mock.Verify(ctx => ctx.SaveChanges(), Times.Never);
}
public async Task IncrementallyUpdatesArticleDataPartsWhenFound(Article existingArticle, ArticleRequest updatedArticle, Action <Article, ArticleRequest> validationAction)
{
var contextFixture = new MockBlogApiDbContextFixture();
contextFixture.Mock
.Setup(ctx => ctx.Find <Article>(existingArticle.Id))
.Returns(async() =>
{
await Task.CompletedTask;
return(existingArticle);
});
var clock = new MockClock();
var coordinatorFixture = new UpdateArticleCoordinatorFixture
{
Context = contextFixture.Build(),
Clock = clock
};
var coordinator = coordinatorFixture.Build();
Assert.False(existingArticle.Updated.HasValue);
var result = await coordinator.TryUpdateArticle(existingArticle.Id, updatedArticle);
contextFixture.Mock.Verify(ctx => ctx.Find <Article>(existingArticle.Id));
contextFixture.Mock.Verify(ctx => ctx.SaveChanges());
Assert.True(result);
Assert.Equal(clock.Now, existingArticle.Updated.GetValueOrDefault());
validationAction(existingArticle, updatedArticle);
}
public async Task CallsDownToQueryIfArticleDoesExist()
{
var articleIdToLookup = Guid.NewGuid();
var articleToBuildFor = new ArticleFixture
{
Id = articleIdToLookup
}.Build();
var mockMapping = new Dictionary <string, string>();
var mockContextWithNoArticles = new MockBlogApiDbContextFixture();
mockContextWithNoArticles.Mock.Setup(m => m.Find <Article>(articleIdToLookup)).ReturnsAsync(articleToBuildFor);
var mockQuery = new Mock <IGetMediaLookupQuery>();
mockQuery.Setup(m => m.CreateMediaLookup(articleIdToLookup)).Returns(mockMapping);
var blogArticleCoordinatorFixture = new FindBlogArticleCoordinatorFixture
{
Context = mockContextWithNoArticles.Build(),
};
var lookupStrategy = new GetArticleMediaLookupStrategyFixture
{
FindBlogArticleCoordinator = blogArticleCoordinatorFixture.Build(),
MediaLookupQuery = mockQuery.Object
}.Build();
var result = await lookupStrategy.GetMediaLookup(articleIdToLookup);
Assert.Equal(mockMapping, result.MediaLookup);
mockQuery.Verify(m => m.CreateMediaLookup(articleIdToLookup), Times.Once);
}
public async Task DoesNotCallDownToQueryIfArticleDoesNotExist()
{
var articleIdToLookup = Guid.NewGuid();
var mockContextWithNoArticles = new MockBlogApiDbContextFixture();
mockContextWithNoArticles.Mock.Setup(m => m.Find <Article>(articleIdToLookup)).ReturnsAsync(null as Article);
var mockQuery = new Mock <IGetMediaLookupQuery>();
mockQuery.Setup(m => m.CreateMediaLookup(articleIdToLookup));
var blogArticleCoordinatorFixture = new FindBlogArticleCoordinatorFixture
{
Context = mockContextWithNoArticles.Build(),
};
var lookupStrategy = new GetArticleMediaLookupStrategyFixture
{
FindBlogArticleCoordinator = blogArticleCoordinatorFixture.Build(),
MediaLookupQuery = mockQuery.Object
}.Build();
var result = await lookupStrategy.GetMediaLookup(articleIdToLookup);
Assert.Null(result);
mockQuery.Verify(m => m.CreateMediaLookup(articleIdToLookup), Times.Never);
}
public async Task SavesNewEntryWhenConditionsMeet()
{
var blog = new BlogFixture().Build();
var newEntryRequest = new ArticleRequest
{
BlogId = blog.Id,
Author = "Test",
Title = "Some-title",
Description = "some-Description",
};
var dbContextFixture = new MockBlogApiDbContextFixture().With(blog, blog.Id);
var clock = new MockClock();
var blogEntryCoordinator = new CreateArticleCoordinatorFixture()
{
Context = dbContextFixture.Build(),
Clock = clock
}.Build();
var result = await blogEntryCoordinator.CreateNewArticleAsync(newEntryRequest);
Assert.Equal(newEntryRequest.BlogId, result.BlogId);
Assert.Equal(newEntryRequest.Author, result.Author);
Assert.Equal(newEntryRequest.Title, result.Title);
Assert.Equal(newEntryRequest.Description, result.Description);
Assert.Equal(clock.Now, result.Created);
dbContextFixture.Mock.Verify(ctx => ctx.Add(result));
dbContextFixture.Mock.Verify(ctx => ctx.SaveChanges());
}
public async Task PersistsTagsThatDoNotAlreadyExistOnArticle()
{
var tagThatExists = new MetaTagRequest
{
Name = "tag1"
};
var tagThatDoesNotExist = new MetaTagRequest
{
Name = "tag2"
};
var existingArticleWithTags = new ArticleFixture().WithTags(tagThatExists).Build();
var mockContext = new MockBlogApiDbContextFixture();
mockContext.Mock.Setup(ctx => ctx.Query <Article>(It.IsAny <string>()))
.Returns(new [] { existingArticleWithTags }.AsQueryable());
var coordinator = new AddMetaTagForArticleCoordinatorFixture
{
Context = mockContext.Build()
}.Build();
var result = await coordinator.AddArticleMetaTags(existingArticleWithTags.Id, tagThatExists, tagThatDoesNotExist);
Assert.True(result.Any(mt => mt.Name == tagThatDoesNotExist.Name));
Assert.True(result.All(mt => mt.Name != tagThatExists.Name));
mockContext.Mock.Verify(ctx => ctx.Add(result), Times.Once);
mockContext.Mock.Verify(ctx => ctx.SaveChanges(), Times.Once);
}
public async Task FindsActiveArticlesAsExpected(Blog blogToFind, Action <IQueryable <Article> > assertionFunction)
{
var mockCtx = new MockBlogApiDbContextFixture().WithQuery(new Blog[] { blogToFind });
var articleSearchListingCoordinator = new ActiveArticleSearchListingCoordinatorFixture
{
Context = mockCtx.Build()
}.Build();
var result = await articleSearchListingCoordinator.Find(blogToFind.Id);
assertionFunction(result);
}
public async Task WillConvertAndSaveMdContentsIfStillOutstanding()
{
var articleIdToFind = Guid.NewGuid();
var mdUrl = "someMdUrl";
var urlToExpect = "someUrl";
var mockConvertedContent = "someContent";
var latestEntryContent = new EntryContentFixture
{
ArticleId = articleIdToFind,
BlobUrl = StringUtilities.ToBase64(mdUrl),
ConvertedBlobUrl = string.Empty
}
.Build();
var mockGetLatestArticle = new Mock <IGetLatestArticleEntryStrategy>();
mockGetLatestArticle.Setup(m => m.FindLatestEntry(articleIdToFind))
.ReturnsAsync(latestEntryContent).Verifiable();
var mockMarkdownConverter = new Mock <IBogMarkdownConverter>();
mockMarkdownConverter.Setup(m => m.ConvertArticle(articleIdToFind, mdUrl))
.ReturnsAsync(mockConvertedContent).Verifiable();
var mockUploadArticleEntryCoordinator = new Mock <IUploadArticleEntryCoordinator>();
mockUploadArticleEntryCoordinator
.Setup(m => m.UploadConvertedArticleEntry(latestEntryContent, mockConvertedContent))
.ReturnsAsync(urlToExpect).Verifiable();
var mockBlogApiDbContextFixture = new MockBlogApiDbContextFixture();
var converterStrategy = new BogMarkdownConverterStrategyFixture
{
GetLatestArticleEntryStrategy = mockGetLatestArticle.Object,
BogMarkdownConverter = mockMarkdownConverter.Object,
UploadArticleEntryCoordinator = mockUploadArticleEntryCoordinator.Object,
Context = mockBlogApiDbContextFixture.Build()
}.Build();
var result = await converterStrategy.GetLatestConvertedEntryContentUri(articleIdToFind);
Assert.Equal(urlToExpect, result);
mockGetLatestArticle.VerifyAll();
mockMarkdownConverter.VerifyAll();
mockUploadArticleEntryCoordinator.VerifyAll();
mockBlogApiDbContextFixture.Mock.Verify(m => m.Attach(latestEntryContent), Times.Once);
mockBlogApiDbContextFixture.Mock.Verify(m => m.SaveChanges(), Times.Once);
}
public async Task ReturnsNullWhenErrorConditionsHit(ArticleRequest request, Blog[] blogs)
{
var mockBlogApiDbContextFixture = new MockBlogApiDbContextFixture();
foreach (var blog in blogs)
{
mockBlogApiDbContextFixture.With(blog, blog.Id);
}
var blogApiDbContext = mockBlogApiDbContextFixture.Build();
var blogEntryCoordinator = new CreateArticleCoordinatorFixture()
{
Context = blogApiDbContext
}.Build();
Assert.Null(await blogEntryCoordinator.CreateNewArticleAsync(request));
}
public async Task ReturnsNullWhenArticleNotFound()
{
var article = new ArticleFixture().Build();
var dbContextFixture = new MockBlogApiDbContextFixture();
dbContextFixture.Mock
.Setup(ctx => ctx.Find <Article>(It.IsAny <Guid>()))
.ReturnsAsync(() => null);
var createArticleEntryCoordinator = new CreateArticleEntryCoordinatorFixture
{
Context = dbContextFixture.Build()
}.Build();
var result = await createArticleEntryCoordinator.CreateArticleEntry(article.Id, new ArticleEntry());
Assert.Null(result);
dbContextFixture.Mock.Verify(ctx => ctx.Find <Article>(article.Id));
}
public async Task ReturnsFalseWhenArticleNotFound()
{
var articleIdThatDoesNotExist = Guid.NewGuid();
var contextFixture = new MockBlogApiDbContextFixture();
contextFixture.Mock.Setup(ctx => ctx.Find <Article>(It.IsAny <Guid>()));
var coordinatorFixture = new UpdateArticleCoordinatorFixture
{
Context = contextFixture.Build()
};
var coordinator = coordinatorFixture.Build();
var result = await coordinator.TryUpdateArticle(articleIdThatDoesNotExist, new ArticleRequest());
contextFixture.Mock.Verify(ctx => ctx.Find <Article>(articleIdThatDoesNotExist));
Assert.False(result);
}
public async Task UpdatesAndPersistsEntryContentOnUpload()
{
var entryContent = new EntryContentFixture().Build();
var blobUrl = "http://somewhere";
var blobUrlBase64 = StringUtilities.ToBase64(blobUrl);
var mockClock = new MockClock();
var dbContextFixture = new MockBlogApiDbContextFixture();
var createArticleEntryCoordinator = new CreateArticleEntryCoordinatorFixture
{
Context = dbContextFixture.Build(),
Clock = mockClock
}.Build();
var resultEntryContent = await createArticleEntryCoordinator.MarkUploadSuccess(entryContent, blobUrl);
Assert.Equal(blobUrlBase64, resultEntryContent.BlobUrl);
dbContextFixture.Mock.Verify(ctx => ctx.Attach(entryContent));
dbContextFixture.Mock.Verify(ctx => ctx.SaveChanges());
}
public async Task DoesNotDeleteTagsIfArticleDoesNotExist()
{
var metaTag = new MetaTagRequest
{
Name = "SomeTag"
};
var mockContext = new MockBlogApiDbContextFixture();
mockContext.Mock.Setup(ctx => ctx.Query <Article>(It.IsAny <string>()))
.Returns(Enumerable.Empty <Article>().AsQueryable());
var coordinator = new RemoveMetaTagForArticleCoordinatorFixture()
{
Context = mockContext.Build()
}.Build();
await coordinator.RemoveArticleMetaTags(Guid.NewGuid(), metaTag);
mockContext.Mock.Verify(ctx => ctx.Delete(It.IsAny <MetaTag>()), Times.Never);
mockContext.Mock.Verify(ctx => ctx.SaveChanges(), Times.Never);
}
public async Task ReturnsNullWhenEntryNotFound()
{
var articleEntry = new EntryContentFixture().Build();
var dbContextFixture = new MockBlogApiDbContextFixture();
dbContextFixture.Mock.Setup(ctx => ctx.Find <EntryContent>(It.IsAny <Guid>()))
.ReturnsAsync(() => null);
var coordinator = new CreateEntryMediaCoordinatorFixture
{
Context = dbContextFixture.Build()
}.Build();
var result = await coordinator.CreateArticleEntryMedia(new ArticleEntryMediaRequest
{
EntryId = articleEntry.Id
});
Assert.Null(result);
dbContextFixture.Mock.Verify(ctx => ctx.Find <EntryContent>(articleEntry.Id));
}
public async Task DoesNotAddMetaTagIfArticleDoesNotExist()
{
var newTagToAdd = new MetaTagRequest
{
Name = "SomeTag"
};
var mockContext = new MockBlogApiDbContextFixture();
mockContext.Mock.Setup(ctx => ctx.Query <Article>(It.IsAny <string>()))
.Returns(Enumerable.Empty <Article>().AsQueryable());
var coordinator = new AddMetaTagForArticleCoordinatorFixture
{
Context = mockContext.Build()
}.Build();
var result = await coordinator.AddArticleMetaTags(Guid.NewGuid(), newTagToAdd);
Assert.Null(result);
mockContext.Mock.Verify(ctx => ctx.Add(It.IsAny <MetaTag[]>()), Times.Never);
mockContext.Mock.Verify(ctx => ctx.SaveChanges(), Times.Never);
}
public async Task FindsEntryAsExpected(Article[] articles, Guid articleIdToFind, EntryContent expectedResult = null)
{
var mockContext = new MockBlogApiDbContextFixture().WithQuery(articles);
var dbMock = mockContext.Mock;
var strategy = new GetLatestArticleEntryStrategyFixture
{
Context = mockContext.Build()
}.Build();
var result = await strategy.FindLatestEntry(articleIdToFind);
dbMock.Verify(ctx => ctx.Query <Article>(It.IsAny <string[]>()));
if (expectedResult == null)
{
Assert.Null(result);
return;
}
Assert.Equal(expectedResult, result);
}
public async Task ReturnsNullWhenNoArticleFound(Guid articleId, Article expectedArticle = null)
{
var contextFixture = new MockBlogApiDbContextFixture();
contextFixture.Mock.Setup(m => m.Find <Article>(articleId)).Returns(Task.FromResult(expectedArticle));
var coordinator = new FindBlogArticleCoordinatorFixture
{
Context = contextFixture.Build()
}.Build();
var result = await coordinator.Find(articleId);
contextFixture.Mock.Verify(m => m.Find <Article>(articleId));
if (expectedArticle == null)
{
Assert.Null(result);
return;
}
Assert.Equal(expectedArticle, result);
}
public async Task DoesNothingIfArticleNotFound()
{
var article = new ArticleFixture().Build();
var contextFixture = new MockBlogApiDbContextFixture();
var mock = contextFixture.Mock;
var fixture = new DeleteArticleCoordinatorFixture
{
Context = contextFixture.Build()
};
var coordinator = fixture.Build();
Assert.False(article.IsDeleted);
Assert.Null(article.Deleted);
var deleteResult = await coordinator.TryDeleteArticle(article.Id);
Assert.False(deleteResult);
Assert.False(article.IsDeleted);
Assert.Null(article.Deleted);
mock.Verify(ctx => ctx.SaveChanges(), Times.Never);
}
public void CompilesDictionaryAsExpected(Guid articleId,
Article articleToFind,
Dictionary <string, string> expectedResult = null,
string[] shouldNotContainFiles = null)
{
var articlesQuery = articleToFind == null?Enumerable.Empty <Article>() : new[] { articleToFind };
var mockBlogApiDbContextFixture = new MockBlogApiDbContextFixture().WithQuery(articlesQuery);
var mockDb = mockBlogApiDbContextFixture.Mock;
var mediaLookupQuery = new GetMediaLookupQueryFixture
{
Context = mockBlogApiDbContextFixture.Build()
}.Build();
var result = mediaLookupQuery.CreateMediaLookup(articleId);
if (expectedResult == null)
{
Assert.Empty(result.Keys);
return;
}
Assert.Equal(expectedResult.Keys.Count, result.Keys.Count);
foreach (var imageFileName in expectedResult.Keys)
{
Assert.True(result.ContainsKey(imageFileName));
Assert.Equal(expectedResult[imageFileName], result[imageFileName]);
}
if (shouldNotContainFiles != null && shouldNotContainFiles.Any())
{
foreach (var keyWhichShouldNotExist in shouldNotContainFiles)
{
Assert.False(result.ContainsKey(keyWhichShouldNotExist));
}
}
}
public async Task MarksEntryMediaAsPersistedWhenSuccessful()
{
var expectedUriUpload = "http://test.com";
var uriAsBase64String = StringUtilities.ToBase64(expectedUriUpload);
var entryMedia = new EntryMediaFixture().Build();
var mockClock = new MockClock();
var dbContextFixture = new MockBlogApiDbContextFixture();
var dbMock = dbContextFixture.Mock;
dbMock.Setup(ctx => ctx.Attach(entryMedia));
var coordinator = new CreateEntryMediaCoordinatorFixture
{
Context = dbContextFixture.Build(),
Clock = mockClock
}.Build();
var result = await coordinator.MarkUploadedSuccess(entryMedia, expectedUriUpload);
Assert.Equal(uriAsBase64String, result.BlobUrl);
Assert.Equal(mockClock.Now, result.Persisted);
dbMock.Verify(ctx => ctx.Attach(entryMedia));
dbMock.Verify(ctx => ctx.SaveChanges());
}
public async Task CreatesNewEntryMediaWhenEntryFound()
{
var articleEntry = new EntryContentFixture().Build();
var request = new ArticleEntryMediaRequest
{
FileName = "testFile",
ContentType = "image/png",
EntryId = articleEntry.Id,
MD5Base64Hash = "1234",
MediaContent = Enumerable.Empty <byte>().ToArray()
};
var mockClock = new MockClock();
var dbContextFixture = new MockBlogApiDbContextFixture();
dbContextFixture.Mock
.Setup(ctx => ctx.Find <EntryContent>(It.IsAny <Guid>()))
.ReturnsAsync(() => articleEntry);
var coordinator = new CreateEntryMediaCoordinatorFixture
{
Context = dbContextFixture.Build(),
Clock = mockClock
}.Build();
var result = await coordinator.CreateArticleEntryMedia(request);
Assert.Equal(articleEntry.Id, result.EntryContentId);
Assert.Equal(request.FileName, result.FileName);
Assert.Equal(request.ContentType, result.ContentType);
Assert.Equal(request.MD5Base64Hash, result.MD5Base64Hash);
Assert.Equal(mockClock.Now, result.Created);
dbContextFixture.Mock.Verify(ctx => ctx.Find <EntryContent>(articleEntry.Id));
dbContextFixture.Mock.Verify(ctx => ctx.Add(result));
dbContextFixture.Mock.Verify(ctx => ctx.SaveChanges());
}
public async Task FindsMediaEntryByHashAndFileNameIfExists(Article[] allArticles, Guid entryContentId, string testMd5HashToFind, string fileNameToFind, EntryMedia expected = null)
{
var contextFixture = new MockBlogApiDbContextFixture();
contextFixture.WithQuery(allArticles);
var context = contextFixture.Build();
var entryMediaSearchStrategy = new EntryMediaSearchStrategyFixture
{
Context = context
}.Build();
var result = await entryMediaSearchStrategy.Find(entryContentId, testMd5HashToFind, fileNameToFind);
contextFixture.Mock.Verify(ctx => ctx.Query <Article>());
if (expected == null)
{
Assert.Null(result);
return;
}
Assert.Equal(expected, result);
}
public UpdateArticleCoordinatorFixture()
{
Context = new MockBlogApiDbContextFixture().Build();
Clock = new MockClock();
}
public CreateEntryMediaCoordinatorFixture()
{
Context = new MockBlogApiDbContextFixture().Build();
Clock = new MockClock();
}
