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