public void As_WhenCalled_ExpectRedditResponseWithSameValues() { int rateLimitUsed = _random.Next(100); int rateLimitRemaining = _random.Next(100); DateTime? rateLimitResetTime = _random.Next(100) > 50 ? DateTime.Now.AddSeconds(_random.Next(300)) : (DateTime?)null; DateTime receivedTime = DateTime.Now.AddSeconds(_random.Next(30, 60) * -1); MyRedditObject data = new MyRedditObject(); IRedditResponse <MyRedditObject> sut = CreateSut(rateLimitUsed: rateLimitUsed, rateLimitRemaining: rateLimitRemaining, rateLimitResetTime: rateLimitResetTime, receivedTime: receivedTime, data: data); IRedditResponse <IRedditObject> result = sut.As <IRedditObject>(); Assert.AreEqual(rateLimitUsed, result.RateLimitUsed); Assert.AreEqual(rateLimitRemaining, result.RateLimitRemaining); if (rateLimitResetTime.HasValue) { Assert.AreEqual(rateLimitResetTime.Value, result.RateLimitResetTime); Assert.AreEqual(rateLimitResetTime.Value.ToUniversalTime(), result.RateLimitResetUtcTime); } else { Assert.IsNull(result.RateLimitResetTime); Assert.IsNull(result.RateLimitResetUtcTime); } Assert.AreEqual(receivedTime, result.ReceivedTime); Assert.AreEqual(receivedTime.ToUniversalTime(), result.ReceivedUtcTime); Assert.AreEqual(data, result.Data); }
public async Task <IRedditResponse <IRedditSubreddit> > GetSpecificSubredditAsync(IRedditAccessToken accessToken, IRedditKnownSubreddit knownSubreddit) { if (accessToken == null) { throw new ArgumentNullException(nameof(accessToken)); } if (knownSubreddit == null) { throw new ArgumentNullException(nameof(knownSubreddit)); } try { IRedditResponse <RedditListChild <RedditSubreddit> > response = await GetAsync <RedditListChild <RedditSubreddit> >(new Uri($"{RedditApiUrl}/r/{knownSubreddit.Name}/about"), accessToken.TokenType, accessToken.AccessToken); return(response.As <IRedditSubreddit>(response.Data.Data)); } catch (AggregateException ex) { await _exceptionHandler.HandleAsync(ex); } catch (Exception ex) { await _exceptionHandler.HandleAsync(ex); } return(null); }
public void Constructor_WhenCalledWhereDataIsNull_ThrowsArgumentNullException() { const MyRedditObject data = null; const bool hasData = false; IRedditResponse <MyRedditObject> sut = CreateSut(data: data, hasData: hasData); }
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(bool willExceedRateLimit = false, IRedditResponse <IRedditAuthenticatedUser> redditResponse = null, Exception exception = null) { _redditRateLimitLogicMock.Setup(m => m.WillExceedRateLimit(It.IsAny <int>())) .Returns(willExceedRateLimit); _redditRateLimitLogicMock.Setup(m => m.EnforceRateLimitAsync(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <DateTime?>(), It.IsAny <DateTime>())) .Returns(Task.Run(() => { })); if (exception != null) { _redditRepositoryMock.Setup(m => m.GetAuthenticatedUserAsync(It.IsAny <IRedditAccessToken>())) .Throws(exception); } else { _redditRepositoryMock.Setup(m => m.GetAuthenticatedUserAsync(It.IsAny <IRedditAccessToken>())) .Returns(Task.Run <IRedditResponse <IRedditAuthenticatedUser> >(() => redditResponse ?? CreateRedditResponse())); } _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)); }
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 void As_WhenCalled_ExpectDataInRedditResponseToBeInterface() { IRedditResponse <MyRedditObject> sut = CreateSut(); IRedditResponse <IRedditObject> result = sut.As <IRedditObject>(); Assert.AreEqual(typeof(IRedditObject), result.GetType().GetProperty("Data").PropertyType); }
public void Constructor_WhenCalled_ExpectReceivedTimeEqualToInputValue() { DateTime receivedTime = DateTime.Now.AddSeconds(_random.Next(30, 60) * -1); IRedditResponse <MyRedditObject> sut = CreateSut(receivedTime: receivedTime); Assert.AreEqual(receivedTime, sut.ReceivedTime); }
public void Constructor_WhenCalledWithRateLimitResetTimeNotEqualToNull_ExpectRateLimitResetUtcTimeEqualToInputValueAsUtcTime() { DateTime rateLimitResetTime = DateTime.Now.AddSeconds(_random.Next(300, 900)); IRedditResponse <MyRedditObject> sut = CreateSut(rateLimitResetTime: rateLimitResetTime); Assert.AreEqual(rateLimitResetTime.ToUniversalTime(), sut.RateLimitResetUtcTime); }
public void Constructor_WhenCalledWithRateLimitResetTimeEqualToNull_ExpectRateLimitResetUtcTimeEqualToNull() { DateTime?rateLimitResetTime = null; IRedditResponse <MyRedditObject> sut = CreateSut(rateLimitResetTime: rateLimitResetTime); Assert.IsNull(sut.RateLimitResetUtcTime); }
public void Constructor_WhenCalled_ExpectRateLimitRemainingEqualToInputValue() { int rateLimitRemaining = _random.Next(100); IRedditResponse <MyRedditObject> sut = CreateSut(rateLimitRemaining: rateLimitRemaining); Assert.AreEqual(rateLimitRemaining, sut.RateLimitRemaining); }
public void Constructor_WhenCalled_ExpectDataEqualToInputValue() { MyRedditObject data = new MyRedditObject(); IRedditResponse <MyRedditObject> sut = CreateSut(data: data); Assert.AreEqual(data, sut.Data); }
public void As_WhenCalled_ExpectRedditResponseNotEqualToSut() { IRedditResponse <MyRedditObject> sut = CreateSut(); IRedditResponse <IRedditObject> result = sut.As <IRedditObject>(); Assert.AreNotSame(sut, result); }
public async Task GetAuthenticatedUserAsync_WhenCalledAndRedditRateLimitHasNotExceeded_ReturnsRedditAuthenticatedUserFromRedditRepository() { IRedditAccessToken redditAccessToken = CreateRedditAccessToken(); const bool willExceedRateLimit = false; IRedditAuthenticatedUser redditAuthenticatedUser = CreateRedditAuthenticatedUser(); IRedditResponse <IRedditAuthenticatedUser> redditResponse = CreateRedditResponse(redditAuthenticatedUser: redditAuthenticatedUser); IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, redditResponse: redditResponse); IRedditAuthenticatedUser getAuthenticatedUser = await sut.GetAuthenticatedUserAsync(redditAccessToken); Assert.AreEqual(redditAuthenticatedUser, getAuthenticatedUser); }
public async Task GetSubredditsForAuthenticatedUserAsync_WhenCalledAndRedditRateLimitHasNotExceeded_AssertRemoveUserBannedContentAsyncWasCalledOnRedditFilterLogic() { IRedditAccessToken redditAccessToken = CreateRedditAccessToken(); bool includeNsfwContent = _random.Next(1, 100) > 50; bool onlyNsfwContent = _random.Next(1, 100) > 50; const bool willExceedRateLimit = false; IRedditList <IRedditSubreddit> redditList = CreateRedditList(); IRedditResponse <IRedditList <IRedditSubreddit> > redditResponse = CreateRedditResponse(redditList: redditList); IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, redditResponse: redditResponse); await sut.GetSubredditsForAuthenticatedUserAsync(redditAccessToken, includeNsfwContent, onlyNsfwContent); _redditFilterLogicMock.Verify(m => m.RemoveUserBannedContentAsync(It.Is <IEnumerable <IRedditSubreddit> >(value => value == redditList)), Times.Once); }
public async Task GetSpecificSubredditAsync_WhenCalledAndRedditRateLimitHasNotExceeded_ReturnsSubreddit() { IRedditAccessToken accessToken = CreateRedditAccessToken(); IRedditKnownSubreddit knownSubreddit = CreateRedditKnownSubreddit(); const bool willExceedRateLimit = false; IRedditSubreddit subreddit = CreateSubreddit(); IRedditResponse <IRedditSubreddit> redditResponse = CreateRedditResponse(subreddit: subreddit); IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, redditResponse: redditResponse); IRedditSubreddit result = await sut.GetSpecificSubredditAsync(accessToken, knownSubreddit); Assert.IsNotNull(result); Assert.AreEqual(subreddit, result); }
public async Task <IRedditResponse <IRedditList <IRedditLink> > > GetLinksAsync(IRedditAccessToken accessToken, IRedditSubreddit subreddit) { if (accessToken == null) { throw new ArgumentNullException(nameof(accessToken)); } if (subreddit == null) { throw new ArgumentNullException(nameof(subreddit)); } try { if (subreddit.Url == null) { return(null); } string localPath = subreddit.Url.LocalPath; if (localPath.StartsWith("/")) { localPath = localPath.Substring(1); } if (localPath.EndsWith("/")) { localPath = localPath.Substring(0, localPath.Length - 1); } IRedditResponse <RedditList <RedditLink> > response = await GetAsync <RedditList <RedditLink> >(new Uri($"{RedditApiUrl}/{localPath}/new"), accessToken.TokenType, accessToken.AccessToken); foreach (RedditLink link in response.Data) { link.Subreddit = subreddit; } return(response.As <IRedditList <IRedditLink> >(response.Data.As <IRedditLink>())); } catch (AggregateException ex) { await _exceptionHandler.HandleAsync(ex); } catch (Exception ex) { await _exceptionHandler.HandleAsync(ex); } return(null); }
private IRedditLogic CreateSut(bool willExceedRateLimit = false, IRedditResponse <IRedditList <IRedditLink> > redditResponse = null, IEnumerable <IRedditLink> filteredLinkCollection = null, Exception exception = null) { if (exception != null) { _redditRateLimitLogicMock.Setup(m => m.WillExceedRateLimit(It.IsAny <int>())) .Throws(exception); } else { _redditRateLimitLogicMock.Setup(m => m.WillExceedRateLimit(It.IsAny <int>())) .Returns(willExceedRateLimit); } _redditRateLimitLogicMock.Setup(m => m.EnforceRateLimitAsync(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <DateTime?>(), It.IsAny <DateTime>())) .Returns(Task.Run(() => { })); _redditRepositoryMock.Setup(m => m.GetLinksAsync(It.IsAny <IRedditAccessToken>(), It.IsAny <IRedditSubreddit>())) .Returns(Task.Run(() => redditResponse ?? CreateRedditResponse())); Mock <IRedditThingComparer <IRedditLink> > redditLinkComparerMock = new Mock <IRedditThingComparer <IRedditLink> >(); redditLinkComparerMock.Setup(m => m.Equals(It.IsAny <IRedditLink>(), It.IsAny <IRedditLink>())) .Returns(false); redditLinkComparerMock.Setup(m => m.GetHashCode()) .Returns(_random.Next()); _redditFilterLogicMock.Setup(m => m.RemoveUserBannedContentAsync(It.IsAny <IEnumerable <IRedditLink> >())) .Returns(Task.Run <IEnumerable <IRedditLink> >(() => filteredLinkCollection ?? new List <IRedditLink>(0))); _redditFilterLogicMock.Setup(m => m.RemoveNsfwContentAsync(It.IsAny <IEnumerable <IRedditLink> >())) .Returns(Task.Run <IEnumerable <IRedditLink> >(() => filteredLinkCollection ?? new List <IRedditLink>(0))); _redditFilterLogicMock.Setup(m => m.RemoveNoneNsfwContentAsync(It.IsAny <IEnumerable <IRedditLink> >())) .Returns(Task.Run <IEnumerable <IRedditLink> >(() => filteredLinkCollection ?? new List <IRedditLink>(0))); _redditFilterLogicMock.Setup(m => m.CreateComparerAsync <IRedditLink>()) .Returns(Task.Run <IRedditThingComparer <IRedditLink> >(() => redditLinkComparerMock.Object)); _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)); }
public async Task GetLinksAsync_WhenCalledAndRedditRateLimitHasNotExceeded_AssertRemoveUserBannedContentAsyncWasCalledOnRedditFilterLogicForEachSubredditInCollection() { 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; IRedditList <IRedditLink> redditList = CreateRedditList(); IRedditResponse <IRedditList <IRedditLink> > redditResponse = CreateRedditResponse(redditList: redditList); IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, redditResponse: redditResponse); await sut.GetLinksAsync(accessToken, subredditCollection, includeNsfwContent, onlyNsfwContent); _redditFilterLogicMock.Verify(m => m.RemoveUserBannedContentAsync(It.Is <IEnumerable <IRedditLink> >(value => value == redditList)), Times.Exactly(numberOfSubreddits)); }
public Task <IRedditAccessToken> GetRedditAccessTokenAsync(string clientId, string clientSecret, string code, Uri redirectUri) { if (string.IsNullOrWhiteSpace(clientId)) { throw new ArgumentNullException(nameof(clientId)); } if (string.IsNullOrWhiteSpace(clientSecret)) { throw new ArgumentNullException(nameof(clientSecret)); } if (string.IsNullOrWhiteSpace(code)) { throw new ArgumentNullException(nameof(code)); } if (redirectUri == null) { throw new ArgumentNullException(nameof(redirectUri)); } return(Task.Run <IRedditAccessToken>(async() => { IDictionary <string, string> formFields = new Dictionary <string, string> { { "grant_type", "authorization_code" }, { "code", code }, { "redirect_uri", redirectUri.AbsoluteUri } }; IRedditResponse <RedditAccessToken> redditResponse = await RedditRepository.PostAsync <RedditAccessToken>( new Uri("https://www.reddit.com/api/v1/access_token"), "Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes($"{clientId}:{clientSecret}")), formFields); RedditAccessToken redditAccessToken = redditResponse.Data; if (string.IsNullOrWhiteSpace(redditAccessToken.Error)) { return redditAccessToken; } throw new Exception($"Unable to get the access token from Reddit: {redditAccessToken.Error}"); })); }
public async Task GetAuthenticatedUserAsync_WhenCalledAndRedditRateLimitHasNotExceeded_AssertEnforceRateLimitAsyncWasCalledOnRedditRateLimitLogic() { IRedditAccessToken redditAccessToken = CreateRedditAccessToken(); 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 <IRedditAuthenticatedUser> redditResponse = CreateRedditResponse(rateLimitUsed, rateLimitRemaining, rateLimitResetTime, receivedTime); IRedditLogic sut = CreateSut(willExceedRateLimit: willExceedRateLimit, redditResponse: redditResponse); await sut.GetAuthenticatedUserAsync(redditAccessToken); _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.Once); }
public async Task <IRedditResponse <IRedditList <IRedditSubreddit> > > GetSubredditsForAuthenticatedUserAsync(IRedditAccessToken accessToken) { if (accessToken == null) { throw new ArgumentNullException(nameof(accessToken)); } try { IRedditResponse <RedditList <RedditSubreddit> > response = await GetAsync <RedditList <RedditSubreddit> >(new Uri($"{RedditApiUrl}/subreddits/mine/subscriber"), accessToken.TokenType, accessToken.AccessToken); return(response.As <IRedditList <IRedditSubreddit> >(response.Data.As <IRedditSubreddit>())); } catch (AggregateException ex) { await _exceptionHandler.HandleAsync(ex); } catch (Exception ex) { await _exceptionHandler.HandleAsync(ex); } return(null); }
private IRedditLogic CreateSut(IEnumerable <IRedditKnownSubreddit> knownNsfwSubredditCollection = null, bool willExceedRateLimit = false, IRedditResponse <IRedditSubreddit> redditResponse = null, Exception exception = null) { if (exception != null) { _dataProviderFactoryMock.Setup(m => m.GetKnownNsfwSubredditsAsync()) .Throws(exception); } else { _dataProviderFactoryMock.Setup(m => m.GetKnownNsfwSubredditsAsync()) .Returns(Task.Run(() => knownNsfwSubredditCollection ?? CreateRedditKnownSubredditCollection())); } _redditRateLimitLogicMock.Setup(m => m.WillExceedRateLimit(It.IsAny <int>())) .Returns(willExceedRateLimit); _redditRateLimitLogicMock.Setup(m => m.EnforceRateLimitAsync(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <DateTime?>(), It.IsAny <DateTime>())) .Returns(Task.Run(() => { })); _redditRepositoryMock.Setup(m => m.GetSpecificSubredditAsync(It.IsAny <IRedditAccessToken>(), It.IsAny <IRedditKnownSubreddit>())) .Returns(Task.Run(() => redditResponse ?? CreateRedditResponse())); _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)); }