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); }