public async Task GetNsfwSubredditsAsync_WhenCalledAndRedditRateLimitHasNotExceeded_AssertEnforceRateLimitAsyncWasCalledOnRedditRateLimitLogicForEachKnownNsfwSubredditToGet()
{
IRedditAccessToken accessToken = CreateRedditAccessToken();;
int numberOfSubreddits = _random.Next(1, 10);
int numberOfKnownNsfwSubreddits = _random.Next(5, 10);
int numberOfSubredditsToGet = Math.Min(numberOfSubreddits, numberOfKnownNsfwSubreddits);
IEnumerable <IRedditKnownSubreddit> knownNsfwSubredditCollection = CreateRedditKnownSubredditCollection(numberOfSubreddits: numberOfKnownNsfwSubreddits);
const bool willExceedRateLimit = false;
int rateLimitUsed = _random.Next(1, 60);
int rateLimitRemaining = _random.Next(1, 60);
DateTime rateLimitResetTime = DateTime.Now.AddSeconds(_random.Next(90, 300));
DateTime receivedTime = DateTime.Now.AddSeconds(_random.Next(1, 10) * -1);
IRedditResponse <IRedditSubreddit> redditResponse = CreateRedditResponse(rateLimitUsed, rateLimitRemaining, rateLimitResetTime, receivedTime);
IRedditLogic sut = CreateSut(knownNsfwSubredditCollection: knownNsfwSubredditCollection, willExceedRateLimit: willExceedRateLimit, redditResponse: redditResponse);
await sut.GetNsfwSubredditsAsync(accessToken, numberOfSubreddits);
_redditRateLimitLogicMock.Verify(m => m.EnforceRateLimitAsync(
It.Is <int>(value => value == rateLimitUsed),
It.Is <int>(value => value == rateLimitRemaining),
It.Is <DateTime?>(value => value.HasValue && value.Value == rateLimitResetTime),
It.Is <DateTime>(value => value == receivedTime)),
Times.Exactly(numberOfSubredditsToGet));
}
private IRedditLogic CreateSut(IRedditAccessToken renewedAccessToken = null, Exception exception = null)
{
if (exception != null)
{
_redditAccessTokenProviderFactoryMock.Setup(m => m.RenewRedditAccessTokenAsync(It.IsAny <string>()))
.Throws(exception);
}
else
{
_redditAccessTokenProviderFactoryMock.Setup(m => m.RenewRedditAccessTokenAsync(It.IsAny <string>()))
.Returns(Task.Run <IRedditAccessToken>(() => renewedAccessToken ?? CreateRedditAccessToken()));
}
_exceptionHandlerMock.Setup(m => m.HandleAsync(It.IsAny <AggregateException>()))
.Returns(Task.Run(() => { }));
_exceptionHandlerMock.Setup(m => m.HandleAsync(It.IsAny <Exception>()))
.Returns(Task.Run(() => { }));
return(new OSDevGrp.MyDashboard.Core.Logic.RedditLogic(
_dataProviderFactoryMock.Object,
_redditAccessTokenProviderFactoryMock.Object,
_redditRepositoryMock.Object,
_redditRateLimitLogicMock.Object,
_redditFilterLogicMock.Object,
_exceptionHandlerMock.Object));
}
private async Task <IEnumerable <IRedditSubreddit> > GetSubredditsAsync(IRedditAccessToken accessToken, bool over18, bool includeNsfwContent, bool onlyNsfwContent)
{
if (accessToken == null)
{
throw new ArgumentNullException(nameof(accessToken));
}
try
{
IList <Task <IEnumerable <IRedditSubreddit> > > getSubredditTaskCollection = new List <Task <IEnumerable <IRedditSubreddit> > >
{
_redditLogic.GetSubredditsForAuthenticatedUserAsync(accessToken, over18 && includeNsfwContent, over18 && onlyNsfwContent)
};
if (over18 && (includeNsfwContent || onlyNsfwContent))
{
getSubredditTaskCollection.Add(_redditLogic.GetNsfwSubredditsAsync(accessToken, 4));
}
await Task.WhenAll(getSubredditTaskCollection.ToArray());
return(getSubredditTaskCollection
.Where(getsubredditTask => getsubredditTask.IsCompleted && getsubredditTask.IsFaulted == false && getsubredditTask.IsCanceled == false)
.SelectMany(getsubredditTask => getsubredditTask.Result)
.OrderByDescending(subreddit => subreddit.Subscribers)
.ToList());
}
catch (AggregateException ex)
{
await _exceptionHandler.HandleAsync(ex);
}
catch (Exception ex)
{
await _exceptionHandler.HandleAsync(ex);
}
return(new List <IRedditSubreddit>(0));
}
public void ToCookie(DashboardSettingsViewModel dashboardSettingsViewModel)
{
if (dashboardSettingsViewModel == null)
{
throw new ArgumentNullException(nameof(dashboardSettingsViewModel));
}
StoreCookie(DashboardSettingsViewModel.CookieName, dashboardSettingsViewModel,
viewModel => _contentHelper.ToBase64String(viewModel),
(viewModel, secureHttpRequest) =>
{
DateTime expires = DateTime.Now.AddHours(8);
if (string.IsNullOrWhiteSpace(viewModel.RedditAccessToken) == false)
{
IRedditAccessToken redditAccessToken = RedditAccessToken.Create(viewModel.RedditAccessToken);
if (redditAccessToken != null && redditAccessToken.Expires <= expires)
{
expires = redditAccessToken.Expires;
}
}
return(new CookieOptions
{
Expires = expires,
Secure = secureHttpRequest,
SameSite = SameSiteMode.None
});
});
}
private async Task <IEnumerable <IRedditLink> > GetLinksAsync(IRedditAccessToken accessToken, IEnumerable <IRedditSubreddit> subreddits, bool over18, bool includeNsfwContent, bool onlyNsfwContent)
{
if (accessToken == null)
{
throw new ArgumentNullException(nameof(accessToken));
}
if (subreddits == null)
{
throw new ArgumentNullException(nameof(subreddits));
}
try
{
return(await _redditLogic.GetLinksAsync(accessToken, subreddits, over18&& includeNsfwContent, over18&& onlyNsfwContent));
}
catch (AggregateException ex)
{
await _exceptionHandler.HandleAsync(ex);
}
catch (Exception ex)
{
await _exceptionHandler.HandleAsync(ex);
}
return(new List <IRedditLink>(0));
}
public async Task GetLinksAsync_WhenCalledAndRedditRateLimitHasNotExceeded_AssertCreatedTimeWasCalledOnEachLinkInFilteredCollectionOfLinks()
{
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;
Mock <IRedditLink> link1Mock = CreateLinkMock();
Mock <IRedditLink> link2Mock = CreateLinkMock();
Mock <IRedditLink> link3Mock = CreateLinkMock();
IEnumerable <IRedditLink> filteredLinkCollection = new List <IRedditLink>
{
link1Mock.Object,
link2Mock.Object,
link3Mock.Object
};
IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, filteredLinkCollection: filteredLinkCollection);
await sut.GetLinksAsync(accessToken, subredditCollection, includeNsfwContent, onlyNsfwContent);
link1Mock.Verify(m => m.CreatedTime, Times.Exactly(numberOfSubreddits * 2));
link2Mock.Verify(m => m.CreatedTime, Times.Exactly(numberOfSubreddits * 2));
link3Mock.Verify(m => m.CreatedTime, Times.Exactly(numberOfSubreddits * 2));
}
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 GetLinksAsync_WhenCalledAndRedditRateLimitHasNotExceeded_AssertEnforceRateLimitAsyncWasCalledOnRedditRateLimitLogicForEachSubredditInCollection()
{
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;
int rateLimitUsed = _random.Next(1, 60);
int rateLimitRemaining = _random.Next(1, 60);
DateTime rateLimitResetTime = DateTime.Now.AddSeconds(_random.Next(90, 300));
DateTime receivedTime = DateTime.Now.AddSeconds(_random.Next(1, 10) * -1);
IRedditResponse <IRedditList <IRedditLink> > redditResponse = CreateRedditResponse(rateLimitUsed, rateLimitRemaining, rateLimitResetTime, receivedTime);
IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, redditResponse: redditResponse);
await sut.GetLinksAsync(accessToken, subredditCollection, includeNsfwContent, onlyNsfwContent);
_redditRateLimitLogicMock.Verify(m => m.EnforceRateLimitAsync(
It.Is <int>(value => value == rateLimitUsed),
It.Is <int>(value => value == rateLimitRemaining),
It.Is <DateTime?>(value => value.HasValue && value.Value == rateLimitResetTime),
It.Is <DateTime>(value => value == receivedTime)),
Times.Exactly(numberOfSubreddits));
}
public async Task GetSubredditsForAuthenticatedUserAsync_WhenCalledAndRedditRateLimitHasNotExceeded_ReturnsFilteredCollectionOfSubreddits()
{
IRedditAccessToken redditAccessToken = CreateRedditAccessToken();
bool includeNsfwContent = _random.Next(1, 100) > 50;
bool onlyNsfwContent = _random.Next(1, 100) > 50;
const bool willExceedRateLimit = false;
IRedditSubreddit subreddit1 = CreateSubreddit();
IRedditSubreddit subreddit2 = CreateSubreddit();
IRedditSubreddit subreddit3 = CreateSubreddit();
IEnumerable <IRedditSubreddit> filteredSubredditCollection = new List <IRedditSubreddit>
{
subreddit1,
subreddit2,
subreddit3
};
IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, filteredSubredditCollection: filteredSubredditCollection);
IEnumerable <IRedditSubreddit> result = await sut.GetSubredditsForAuthenticatedUserAsync(redditAccessToken, includeNsfwContent, onlyNsfwContent);
Assert.IsNotNull(result);
Assert.AreEqual(filteredSubredditCollection.Count(), result.Count());
Assert.IsTrue(result.Contains(subreddit1));
Assert.IsTrue(result.Contains(subreddit2));
Assert.IsTrue(result.Contains(subreddit3));
}
public async Task GetNsfwSubredditsAsync_WhenCalled_AssertNameWasCalledOnEachKnownNsfwSubreddit()
{
IRedditAccessToken accessToken = CreateRedditAccessToken();;
int numberOfSubreddits = _random.Next(1, 5);
Mock <IRedditKnownSubreddit> knownNsfwSubreddit1 = CreateRedditKnownSubredditMock();
Mock <IRedditKnownSubreddit> knownNsfwSubreddit2 = CreateRedditKnownSubredditMock();
Mock <IRedditKnownSubreddit> knownNsfwSubreddit3 = CreateRedditKnownSubredditMock();
Mock <IRedditKnownSubreddit> knownNsfwSubreddit4 = CreateRedditKnownSubredditMock();
Mock <IRedditKnownSubreddit> knownNsfwSubreddit5 = CreateRedditKnownSubredditMock();
IEnumerable <IRedditKnownSubreddit> knownNsfwSubredditCollection = new List <IRedditKnownSubreddit>
{
knownNsfwSubreddit1.Object,
knownNsfwSubreddit2.Object,
knownNsfwSubreddit3.Object,
knownNsfwSubreddit4.Object,
knownNsfwSubreddit5.Object
};
IRedditLogic sut = CreateSut(knownNsfwSubredditCollection: knownNsfwSubredditCollection);
await sut.GetNsfwSubredditsAsync(accessToken, numberOfSubreddits);
knownNsfwSubreddit1.Verify(m => m.Name, Times.Once);
knownNsfwSubreddit2.Verify(m => m.Name, Times.Once);
knownNsfwSubreddit3.Verify(m => m.Name, Times.Once);
knownNsfwSubreddit4.Verify(m => m.Name, Times.Once);
knownNsfwSubreddit5.Verify(m => m.Name, Times.Once);
}
public async Task RenewAccessTokenAsync_WhenRedditAccessTokenIsNull_ThrowsArgumentNullException()
{
const IRedditAccessToken accessToken = null;
IRedditLogic sut = CreateSut();
await sut.RenewAccessTokenAsync(accessToken);
}
public void ToBase64_WhenCalled_ReturnsBase64()
{
IRedditAccessToken sut = CreateSut();
string result = sut.ToBase64();
Assert.IsNotNull(result);
Assert.IsTrue(result.Trim().Length % 4 == 0 && Regex.IsMatch(result.Trim(), @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None));
}
public async Task GetSpecificSubredditAsync_WhenAccessTokenIsNull_ThrowsArgumentNullException()
{
const IRedditAccessToken accessToken = null;
IRedditKnownSubreddit knownSubreddit = CreateRedditKnownSubreddit();
IRedditRepository sut = CreateSut();
await sut.GetSpecificSubredditAsync(accessToken, knownSubreddit);
}
public async Task GetNsfwSubredditsAsync_WhenRedditAccessTokenIsNull_ThrowsArgumentNullException()
{
const IRedditAccessToken accessToken = null;
int numberOfSubreddits = _random.Next(1, 10);
IRedditLogic sut = CreateSut();
await sut.GetNsfwSubredditsAsync(accessToken, numberOfSubreddits);
}
public async Task GetLinksAsync_WhenSubredditIsNull_ThrowsArgumentNullException()
{
IRedditAccessToken accessToken = CreateRedditAccessToken();
const IRedditSubreddit subreddit = null;
IRedditRepository sut = CreateSut();
await sut.GetLinksAsync(accessToken, subreddit);
}
public async Task GetSpecificSubredditAsync_WhenRedditKnownSubredditIsNull_ThrowsArgumentNullException()
{
IRedditAccessToken accessToken = CreateRedditAccessToken();
const IRedditKnownSubreddit knownSubreddit = null;
IRedditLogic sut = CreateSut();
await sut.GetSpecificSubredditAsync(accessToken, knownSubreddit);
}
public async Task GetAuthenticatedUserAsync_WhenCalled_AssertWillExceedRateLimitWasCalledOnRedditRateLimitLogic()
{
IRedditAccessToken redditAccessToken = CreateRedditAccessToken();
IRedditLogic sut = CreateSut();
await sut.GetAuthenticatedUserAsync(redditAccessToken);
_redditRateLimitLogicMock.Verify(m => m.WillExceedRateLimit(It.Is <int>(value => value == 1)), Times.Once);
}
public async Task GetLinksAsync_WhenRedditAccessTokenIsNull_ThrowsArgumentNullException()
{
const IRedditAccessToken accessToken = null;
IRedditSubreddit subreddit = CreateSubreddit();
bool includeNsfwContent = _random.Next(100) > 50;
bool onlyNsfwContent = _random.Next(100) > 50;
IRedditLogic sut = CreateSut();
await sut.GetLinksAsync(accessToken, subreddit, includeNsfwContent, onlyNsfwContent);
}
public async Task GetAuthenticatedUserAsync_WhenCalledAndRedditRateLimitHasExceeded_AssertGetAuthenticatedUserAsyncWasNotCalledOnRedditRepository()
{
IRedditAccessToken redditAccessToken = CreateRedditAccessToken();
const bool willExceedRateLimit = true;
IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit);
await sut.GetAuthenticatedUserAsync(redditAccessToken);
_redditRepositoryMock.Verify(m => m.GetAuthenticatedUserAsync(It.IsAny <IRedditAccessToken>()), Times.Never);
}
public async Task GetAuthenticatedUserAsync_WhenCalledAndRedditRateLimitHasExceeded_ReturnsNull()
{
IRedditAccessToken redditAccessToken = CreateRedditAccessToken();
const bool willExceedRateLimit = true;
IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit);
IRedditAuthenticatedUser getAuthenticatedUser = await sut.GetAuthenticatedUserAsync(redditAccessToken);
Assert.IsNull(getAuthenticatedUser);
}
public async Task GetSpecificSubredditAsync_WhenCalled_AssertWillExceedRateLimitWasCalledOnRedditRateLimitLogic()
{
IRedditAccessToken accessToken = CreateRedditAccessToken();
IRedditKnownSubreddit knownSubreddit = CreateRedditKnownSubreddit();
IRedditLogic sut = CreateSut();
await sut.GetSpecificSubredditAsync(accessToken, knownSubreddit);
_redditRateLimitLogicMock.Verify(m => m.WillExceedRateLimit(It.Is <int>(value => value == 1)), Times.Once);
}
protected static string BuildRedditAccessTokenAsBase64(Random random, string accessToken = null, string tokenType = null, int?expiresIn = null, string scope = null, string refreshToken = null, DateTime?received = null)
{
if (random == null)
{
throw new ArgumentNullException(nameof(random));
}
IRedditAccessToken redditAccessToken = BuildRedditAccessToken(random, accessToken, tokenType, expiresIn, scope, refreshToken, received);
return(Convert.ToBase64String(JsonSerialization.ToByteArray(redditAccessToken)));
}
public async Task RenewAccessTokenAsync_WhenCalledWithUnexpiredRedditAccessToken_AssertRenewRedditAccessTokenAsyncWasNotCalledOnRedditAccessTokenProviderFactory()
{
const bool hasExpired = false;
IRedditAccessToken accessToken = CreateRedditAccessToken(hasExpired: hasExpired);
IRedditLogic sut = CreateSut();
await sut.RenewAccessTokenAsync(accessToken);
_redditAccessTokenProviderFactoryMock.Verify(m => m.RenewRedditAccessTokenAsync(It.IsAny <string>()), Times.Never);
}
public async Task GetNsfwSubredditsAsync_WhenCalled_AssertGetKnownNsfwSubredditsAsyncWasCalledOnDataProviderFactory()
{
IRedditAccessToken accessToken = CreateRedditAccessToken();;
int numberOfSubreddits = _random.Next(1, 10);
IRedditLogic sut = CreateSut();
await sut.GetNsfwSubredditsAsync(accessToken, numberOfSubreddits);
_dataProviderFactoryMock.Verify(m => m.GetKnownNsfwSubredditsAsync(), Times.Once);
}
public async Task GetLinksAsync_WhenSubredditCollectionIsNull_ThrowsArgumentNullException()
{
IRedditAccessToken accessToken = CreateRedditAccessToken();
const IEnumerable <IRedditSubreddit> subredditCollection = null;
bool includeNsfwContent = _random.Next(100) > 50;
bool onlyNsfwContent = _random.Next(100) > 50;
IRedditLogic sut = CreateSut();
await sut.GetLinksAsync(accessToken, subredditCollection, includeNsfwContent, onlyNsfwContent);
}
public async Task RenewAccessTokenAsync_WhenCalledWithUnexpiredRedditAccessToken_ReturnsUnexpiredRedditAccessToken()
{
const bool hasExpired = false;
IRedditAccessToken accessToken = CreateRedditAccessToken(hasExpired: hasExpired);
IRedditLogic sut = CreateSut();
IRedditAccessToken result = await sut.RenewAccessTokenAsync(accessToken);
Assert.AreEqual(accessToken, result);
}
public async Task BuildAsync_WhenCalledWhereRedditAccessTokenIsNull_ReturnsInitializedDashboardSettingsViewModel()
{
const IRedditAccessToken redditAccessToken = null;
IDashboardSettings dashboardSettings = CreateDashboardSettings(redditAccessToken: redditAccessToken);
IViewModelBuilder <DashboardSettingsViewModel, IDashboardSettings> sut = CreateSut();
DashboardSettingsViewModel result = await sut.BuildAsync(dashboardSettings);
Assert.IsNotNull(result);
Assert.IsNull(result.RedditAccessToken);
}
public async Task GetSubredditsForAuthenticatedUserAsync_WhenCalled_AssertWillExceedRateLimitWasCalledOnRedditRateLimitLogic()
{
IRedditAccessToken redditAccessToken = CreateRedditAccessToken();
bool includeNsfwContent = _random.Next(1, 100) > 50;
bool onlyNsfwContent = _random.Next(1, 100) > 50;
IRedditLogic sut = CreateSut();
await sut.GetSubredditsForAuthenticatedUserAsync(redditAccessToken, includeNsfwContent, onlyNsfwContent);
_redditRateLimitLogicMock.Verify(m => m.WillExceedRateLimit(It.Is <int>(value => value == 1)), Times.Once);
}
public async Task GetAuthenticatedUserAsync_WhenCalledAndRedditRateLimitHasExceeded_AssertHandleAsyncWasNotCalledOnExceptionHandler()
{
IRedditAccessToken redditAccessToken = CreateRedditAccessToken();
const bool willExceedRateLimit = true;
IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit);
await sut.GetAuthenticatedUserAsync(redditAccessToken);
_exceptionHandlerMock.Verify(m => m.HandleAsync(It.IsAny <AggregateException>()), Times.Never);
_exceptionHandlerMock.Verify(m => m.HandleAsync(It.IsAny <Exception>()), Times.Never);
}
public async Task GetAuthenticatedUserAsync_WhenCalledAndRedditRateLimitHasNotExceededAndExceptionOccurs_ReturnsNull()
{
IRedditAccessToken redditAccessToken = CreateRedditAccessToken();
const bool willExceedRateLimit = false;
Exception exception = new Exception();
IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, exception: exception);
IRedditAuthenticatedUser getAuthenticatedUser = await sut.GetAuthenticatedUserAsync(redditAccessToken);
Assert.IsNull(getAuthenticatedUser);
}
