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