public async Task GetLinksAsync_WhenCalledAndRedditRateLimitHasNotExceeded_ReturnsFilteredCollectionOfLinks()
{
int numberOfSubreddits = _random.Next(1, 10);
IRedditAccessToken accessToken = CreateRedditAccessToken();
IEnumerable <IRedditSubreddit> subredditCollection = CreateSubredditCollection(numberOfSubreddits: numberOfSubreddits);
bool includeNsfwContent = _random.Next(100) > 50;
bool onlyNsfwContent = _random.Next(100) > 50;
const bool willExceedRateLimit = false;
IRedditLink link1 = CreateLink();
IRedditLink link2 = CreateLink();
IRedditLink link3 = CreateLink();
IEnumerable <IRedditLink> filteredLinkCollection = new List <IRedditLink>
{
link1,
link2,
link3
};
IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, filteredLinkCollection: filteredLinkCollection);
IEnumerable <IRedditLink> result = await sut.GetLinksAsync(accessToken, subredditCollection, includeNsfwContent, onlyNsfwContent);
Assert.IsNotNull(result);
Assert.AreEqual(filteredLinkCollection.Count() * numberOfSubreddits, result.Count());
Assert.AreEqual(numberOfSubreddits, result.Count(subreddit => subreddit == link1));
Assert.AreEqual(numberOfSubreddits, result.Count(subreddit => subreddit == link2));
Assert.AreEqual(numberOfSubreddits, result.Count(subreddit => subreddit == link3));
}
public async Task ExportAsync_WhenRedditLinkIsWithoutImagesAndWithoutThumbnailUrl_ReturnsDashboardItemExportModelWithoutImageUrl()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
IRedditLink redditLink = BuildRedditLink();
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.IsNull(result.ImageUrl);
}
public async Task ExportAsync_WhenRedditLinkIsWithoutAuthor_ReturnsDashboardItemExportModelWithoutAuthor()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
IRedditLink redditLink = BuildRedditLink();
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.IsNull(result.Author);
}
public async Task ExportAsync_WhenRedditLinkIsWithoutRedditSubreddit_AssertFullNameWasNotCalledOnRedditSubreddit()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
Mock <IRedditSubreddit> redditSubredditMock = BuildRedditSubredditMock();
IRedditLink redditLink = BuildRedditLink();
await sut.ExportAsync(redditLink);
redditSubredditMock.Verify(m => m.FullName, Times.Never);
}
public async Task ExportAsync_WhenCalled_AssertHandleAsyncWasNotCalledOnExceptionHandler()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
IRedditLink redditLink = BuildRedditLink();
await sut.ExportAsync(redditLink);
_exceptionHandlerMock.Verify(m => m.HandleAsync(It.IsAny <AggregateException>()), Times.Never);
_exceptionHandlerMock.Verify(m => m.HandleAsync(It.IsAny <Exception>()), Times.Never);
}
public async Task ExportAsync_WhenCalled_ReturnsDashboardItemExportModelWithTimestampFromRedditLink()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
DateTime createdTime = DateTime.Now.AddSeconds(_random.Next(300, 3600) * -1);
IRedditLink redditLink = BuildRedditLink(createdTime: createdTime);
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.AreEqual(createdTime, result.Timestamp);
}
public async Task ExportAsync_WhenRedditLinkIsWithoutImagesAndWithThumbnailUrl_ReturnsDashboardItemExportModelWithImageUrlFromRedditLink()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
Uri thumbnailUrl = new Uri($"http://localhost/{Guid.NewGuid().ToString("D")}/{Guid.NewGuid().ToString("D")}");
IRedditLink redditLink = BuildRedditLink(thumbnailUrl: thumbnailUrl);
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.AreEqual(thumbnailUrl.AbsoluteUri, result.ImageUrl);
}
public async Task ExportAsync_WhenRedditLinkIsWithAuthor_ReturnsDashboardItemExportModelWithAuthorFromRedditLink()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
string author = Guid.NewGuid().ToString("D");
IRedditLink redditLink = BuildRedditLink(author: author);
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.AreEqual(author, result.Author);
}
public async Task ExportAsync_WhenRedditLinkIsWithSelftextAsText_ReturnsDashboardItemExportModelWithDetailsFromRedditLink()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
string selftextAsText = Guid.NewGuid().ToString("D");
IRedditLink redditLink = BuildRedditLink(selftextAsText: selftextAsText);
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.AreEqual(selftextAsText, result.Details);
}
public async Task ExportAsync_WhenCalled_ReturnsDashboardItemExportModelWithInformationFromRedditLink()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
string title = Guid.NewGuid().ToString("D");
IRedditLink redditLink = BuildRedditLink(title: title);
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.AreEqual(title, result.Information);
}
public async Task ExportAsync_WhenRedditLinkIsWithEmptyImages_ReturnsDashboardItemExportModelWithoutImageUrl()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
IEnumerable <IRedditImage> redditImageCollection = new List <IRedditImage>();
IRedditLink redditLink = BuildRedditLink(redditImageCollection: redditImageCollection);
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.IsNull(result.ImageUrl);
}
public async Task ExportAsync_WhenCalled_ReturnsDashboardItemExportModelWithIdentifierFromRedditLink()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
string fullName = Guid.NewGuid().ToString("D");
IRedditLink redditLink = BuildRedditLink(fullName);
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.AreEqual(fullName, result.Identifier);
}
public async Task BuildAsync_WhenCalledWithRedditLinkWithRedditSubreddit_AssertDisplayNamePrefixedWasCalledOnRedditSubreddit()
{
Mock <IRedditSubreddit> redditSubredditMock = CreateRedditSubredditMock(Guid.NewGuid().ToString("D"));
IRedditLink redditLink = CreateRedditLink(redditSubreddit: redditSubredditMock.Object);
IViewModelBuilder <InformationViewModel, IRedditLink> sut = CreateSut();
await sut.BuildAsync(redditLink);
redditSubredditMock.Verify(m => m.DisplayNamePrefixed, Times.Once);
}
public async Task ExportAsync_WhenRedditLinkIsWithRedditSubreddit_ReturnsDashboardItemExportModelWithProviderFromRedditLink()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
string fullName = Guid.NewGuid().ToString("D");
IRedditSubreddit redditSubreddit = BuildRedditSubreddit(fullName);
IRedditLink redditLink = BuildRedditLink(redditSubreddit: redditSubreddit);
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.AreEqual(fullName, result.Provider);
}
public async Task BuildAsync_WhenCalledWithRedditLinkWhereImagesIsNotEmptyAndThumbnailUrlIsNotNull_AssertNextWasCalledOnRandomizer()
{
IEnumerable <IRedditImage> redditImages = CreateRedditImageCollection();
Uri thumbnailUrl = CreateImageUri();
IRedditLink redditLink = CreateRedditLink(redditImages: redditImages, thumbnailUrl: thumbnailUrl);
IViewModelBuilder <InformationViewModel, IRedditLink> sut = CreateSut();
await sut.BuildAsync(redditLink);
_randomizerMock.Verify(m => m.Next(
It.Is <int>(value => value == 0),
It.Is <int>(value => value == redditImages.Count() - 1)),
Times.Once);
}
public async Task BuildAsync_WhenCalledWithRedditLinkWhereImagesIsEmptyAndThumbnailUrlIsNull_AssertNextWasNotCalledOnRandomizer()
{
IEnumerable <IRedditImage> redditImages = new List <IRedditImage>(0);
const Uri thumbnailUrl = null;
IRedditLink redditLink = CreateRedditLink(redditImages: redditImages, thumbnailUrl: thumbnailUrl);
IViewModelBuilder <InformationViewModel, IRedditLink> sut = CreateSut();
await sut.BuildAsync(redditLink);
_randomizerMock.Verify(m => m.Next(
It.IsAny <int>(),
It.IsAny <int>()),
Times.Never);
}
public async Task ExportAsync_WhenRedditLinkIsWithNonEmptyImages_ReturnsDashboardItemExportModelWithImageUrlFromRedditLink()
{
IModelExporter <DashboardItemExportModel, IRedditLink> sut = CreateSut();
Uri imageUrl = new Uri($"http://localhost/{Guid.NewGuid().ToString("D")}/{Guid.NewGuid().ToString("D")}");
IEnumerable <IRedditImage> redditImageCollection = new List <IRedditImage>()
{
BuildRedditImage(imageUrl)
};
IRedditLink redditLink = BuildRedditLink(redditImageCollection: redditImageCollection);
DashboardItemExportModel result = await sut.ExportAsync(redditLink);
Assert.IsNotNull(result);
Assert.AreEqual(imageUrl.AbsoluteUri, result.ImageUrl);
}
public async Task BuildAsync_WhenCalledWithRedditLinkWhereImagesIsNotEmpty_AssertUrlWasCalledOnEachRedditImage()
{
Mock <IRedditImage> redditImage1Mock = CreateRedditImageMock(CreateImageUri());
Mock <IRedditImage> redditImage2Mock = CreateRedditImageMock(CreateImageUri());
Mock <IRedditImage> redditImage3Mock = CreateRedditImageMock(CreateImageUri());
IEnumerable <IRedditImage> redditImages = CreateRedditImageCollection(
redditImage1Mock.Object,
redditImage2Mock.Object,
redditImage3Mock.Object);
IRedditLink redditLink = CreateRedditLink(redditImages: redditImages);
IViewModelBuilder <InformationViewModel, IRedditLink> sut = CreateSut();
await sut.BuildAsync(redditLink);
redditImage1Mock.Verify(m => m.Url, Times.Exactly(3));
redditImage2Mock.Verify(m => m.Url, Times.Exactly(2));
redditImage3Mock.Verify(m => m.Url, Times.Exactly(2));
}
private async Task BuildAsync_WhenCalled_ReturnsInitializedInformationViewModel(bool hasRedditSubreddit, string title, string selftextAsText, string author, Uri thumbnailUrl, IEnumerable <IRedditImage> redditImages, Uri url, string redditSubredditDisplayNamePrefixed)
{
string identifier = Guid.NewGuid().ToString("D");
DateTime createdTime = DateTime.Now.AddMinutes(_random.Next(60, 300) * -1);
IRedditSubreddit redditSubreddit = hasRedditSubreddit ? CreateRedditSubreddit(displayNamePrefixed: redditSubredditDisplayNamePrefixed) : null;
IRedditLink redditLink = CreateRedditLink(
identifier: identifier,
createdTime: createdTime,
redditSubreddit: redditSubreddit,
title: title,
selftextAsText: selftextAsText,
author: author,
thumbnailUrl: thumbnailUrl,
redditImages: redditImages,
url: url);
IViewModelBuilder <InformationViewModel, IRedditLink> sut = CreateSut();
InformationViewModel result = await sut.BuildAsync(redditLink);
Assert.IsNotNull(result);
Assert.IsNotNull(result.InformationIdentifier);
Assert.AreEqual(identifier, result.InformationIdentifier);
Assert.AreEqual(createdTime, result.Timestamp);
if (string.IsNullOrWhiteSpace(title))
{
Assert.IsNull(result.Header);
}
else
{
Assert.IsNotNull(result.Header);
Assert.AreEqual(title, result.Header);
}
if (string.IsNullOrWhiteSpace(selftextAsText))
{
Assert.IsNull(result.Details);
}
else
{
Assert.IsNotNull(result.Details);
Assert.AreEqual(selftextAsText, result.Details);
}
Assert.IsNull(result.Summary);
if (redditImages != null && redditImages.Any(image => image.Url != null))
{
Assert.IsNotNull(result.ImageUrl);
Assert.IsTrue(redditImages.Where(image => image.Url != null).Select(image => image.Url.AbsoluteUri).Contains(result.ImageUrl));
}
else if (thumbnailUrl != null)
{
Assert.IsNotNull(result.ImageUrl);
Assert.AreEqual(thumbnailUrl.AbsoluteUri, result.ImageUrl);
}
else
{
Assert.IsNull(result.ImageUrl);
}
if (hasRedditSubreddit == false || string.IsNullOrWhiteSpace(redditSubredditDisplayNamePrefixed))
{
Assert.IsNull(result.Provider);
}
else
{
Assert.IsNotNull(result.Provider);
Assert.AreEqual(redditSubredditDisplayNamePrefixed, result.Provider);
}
if (string.IsNullOrWhiteSpace(author))
{
Assert.IsNull(result.Author);
}
else if (hasRedditSubreddit == false || string.IsNullOrWhiteSpace(redditSubredditDisplayNamePrefixed))
{
Assert.IsNotNull(result.Author);
Assert.AreEqual(author, result.Author);
}
else
{
Assert.IsNotNull(result.Author);
Assert.AreEqual($"{author} @ {redditSubredditDisplayNamePrefixed}", result.Author);
}
if (url == null)
{
Assert.IsNotNull(result.ExternalUrl);
Assert.AreEqual("#", result.ExternalUrl);
}
else
{
Assert.IsNotNull(result.ExternalUrl);
Assert.AreEqual(url.AbsoluteUri, result.ExternalUrl);
}
}
