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 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 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 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 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));
}
public async Task RenewAccessTokenAsync_WhenRedditAccessTokenIsNull_ThrowsArgumentNullException()
{
const IRedditAccessToken accessToken = null;
IRedditLogic sut = CreateSut();
await sut.RenewAccessTokenAsync(accessToken);
}
public async Task GetSubredditsForAuthenticatedUserAsync_WhenRedditAccessTokenIsNull_ThrowsArgumentNullException()
{
bool includeNsfwContent = _random.Next(1, 100) > 50;
bool onlyNsfwContent = _random.Next(1, 100) > 50;
IRedditLogic sut = CreateSut();
await sut.GetSubredditsForAuthenticatedUserAsync(null, includeNsfwContent, onlyNsfwContent);
}
public async Task GetSpecificSubredditAsync_WhenRedditKnownSubredditIsNull_ThrowsArgumentNullException()
{
IRedditAccessToken accessToken = CreateRedditAccessToken();
const IRedditKnownSubreddit knownSubreddit = null;
IRedditLogic 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 RenewAccessTokenAsync_WhenCalled_AssertExpiresWasCalledOnRedditAccessToken()
{
Mock <IRedditAccessToken> accessTokenMock = CreateRedditAccessTokenMock();
IRedditLogic sut = CreateSut();
await sut.RenewAccessTokenAsync(accessTokenMock.Object);
accessTokenMock.Verify(m => m.Expires, Times.Once);
}
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 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 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 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 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 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_AssertRefreshTokenWasNotCalledOnRedditAccessToken()
{
const bool hasExpired = false;
Mock <IRedditAccessToken> accessTokenMock = CreateRedditAccessTokenMock(hasExpired: hasExpired);
IRedditLogic sut = CreateSut();
await sut.RenewAccessTokenAsync(accessTokenMock.Object);
accessTokenMock.Verify(m => m.RefreshToken, Times.Never);
}
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);
}
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 RenewAccessTokenAsync_WhenCalledWithExpiredRedditAccessToken_AssertRenewRedditAccessTokenAsyncWasCalledOnRedditAccessTokenProviderFactory()
{
const bool hasExpired = true;
string refreshToken = Guid.NewGuid().ToString("D");
IRedditAccessToken accessToken = CreateRedditAccessToken(hasExpired: hasExpired, refreshToken: refreshToken);
IRedditLogic sut = CreateSut();
await sut.RenewAccessTokenAsync(accessToken);
_redditAccessTokenProviderFactoryMock.Verify(m => m.RenewRedditAccessTokenAsync(It.Is <string>(value => string.Compare(refreshToken, value, StringComparison.Ordinal) == 0)), Times.Once);
}
public async Task RenewAccessTokenAsync_WhenCalledWithExpiredRedditAccessTokenAndExceptionOccurs_AssertHandleAsyncWasCalledOnExceptionHandler()
{
const bool hasExpired = true;
IRedditAccessToken accessToken = CreateRedditAccessToken(hasExpired: hasExpired);
Exception exception = new Exception();
IRedditLogic sut = CreateSut(exception: exception);
await sut.RenewAccessTokenAsync(accessToken);
_exceptionHandlerMock.Verify(m => m.HandleAsync(It.Is <Exception>(value => value == exception)), 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 RenewAccessTokenAsync_WhenCalledWithExpiredRedditAccessTokenAndExceptionOccurs_ReturnsNull()
{
const bool hasExpired = true;
IRedditAccessToken accessToken = CreateRedditAccessToken(hasExpired: hasExpired);
Exception exception = new Exception();
IRedditLogic sut = CreateSut(exception: exception);
IRedditAccessToken result = await sut.RenewAccessTokenAsync(accessToken);
Assert.IsNull(result);
}
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);
}
public async Task GetAuthenticatedUserAsync_WhenCalledAndRedditRateLimitHasNotExceededAndExceptionOccurs_AssertHandleAsyncWasCalledOnExceptionHandler()
{
IRedditAccessToken redditAccessToken = CreateRedditAccessToken();
const bool willExceedRateLimit = false;
Exception exception = new Exception();
IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, exception: exception);
await sut.GetAuthenticatedUserAsync(redditAccessToken);
_exceptionHandlerMock.Verify(m => m.HandleAsync(It.Is <Exception>(value => value == exception)), Times.Once);
}
public async Task RenewAccessTokenAsync_WhenCalledWithUnexpiredRedditAccessToken_AssertHandleAsyncWasNotCalledOnExceptionHandler()
{
const bool hasExpired = false;
IRedditAccessToken accessToken = CreateRedditAccessToken(hasExpired: hasExpired);
IRedditLogic sut = CreateSut();
await sut.RenewAccessTokenAsync(accessToken);
_exceptionHandlerMock.Verify(m => m.HandleAsync(It.IsAny <AggregateException>()), Times.Never);
_exceptionHandlerMock.Verify(m => m.HandleAsync(It.IsAny <Exception>()), Times.Never);
}
public async Task GetSpecificSubredditAsync_WhenCalledAndRedditRateLimitHasExceeded_ReturnsNull()
{
IRedditAccessToken accessToken = CreateRedditAccessToken();
IRedditKnownSubreddit knownSubreddit = CreateRedditKnownSubreddit();
const bool willExceedRateLimit = true;
IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit);
IRedditSubreddit result = await sut.GetSpecificSubredditAsync(accessToken, knownSubreddit);
Assert.IsNull(result);
}
