public async Task GetAll_ShouldReturnEmptySet_WhenThereAreNone()
{
// Setup
var emptyList = new List <PullRequest>();
mockGitHubClient.Setup(c => c.Get <List <PullRequest> >("repos/ampersandre/random-scale/pulls")).Returns(Task.FromResult(emptyList));
// Execute
var actualPullRequests = await service.GetAll("ampersandre", "random-scale");
// Assert
AssertUtils.AreIdentical(emptyList, actualPullRequests);
}
public async Task GetAll_ShouldReturnRepositories_WhenThereAreSome()
{
// Setup
var expectedRepositories = Enumerable.Range(1, 4).Select(Generator.GenerateRepository).ToList();
mockGitHubClient.Setup(c => c.Get <List <Repository> >("user/repos")).Returns(Task.FromResult(expectedRepositories));
// Execute
var actualRepositories = await service.GetAll();
// Assert
AssertUtils.AreIdentical(expectedRepositories, actualRepositories);
}
public async Task GetAll_ShouldReturnPullRequests_WhenThereAreSome()
{
// Setup
var expectedPullRequests = Enumerable.Range(1, 4).Select(Generator.GeneratePullRequest).ToList();
mockGitHubClient.Setup(c => c.Get <List <PullRequest> >("repos/ampersandre/barn-ville/pulls")).Returns(Task.FromResult(expectedPullRequests));
// Execute
var actualPullRequests = await service.GetAll("ampersandre", "barn-ville");
// Assert
AssertUtils.AreIdentical(expectedPullRequests, actualPullRequests);
}
public async Task GetAll_ShouldReturnEmptySet_WhenThereAreNone()
{
// Setup
var emptyList = new List <Repository>();
mockGitHubClient.Setup(c => c.Get <List <Repository> >("user/repos")).Returns(Task.FromResult(emptyList));
// Execute
var actualRepositories = await service.GetAll();
// Assert
AssertUtils.AreIdentical(emptyList, actualRepositories);
}
public async Task GetOne_ShouldReturnExpectedPullRequest_WhenItExists()
{
// Setup
var owner = "ampersandre";
var name = "fitbit-except-for-blinking";
var expectedPullRequest = Generator.GeneratePullRequest();
mockGitHubClient.Setup(c => c.Get <PullRequest>($"repos/{owner}/{name}/pulls/78")).Returns(Task.FromResult(expectedPullRequest));
// Execute
var actualPullRequest = await service.GetOne(owner, name, 78);
// Assert
AssertUtils.AreIdentical(expectedPullRequest, actualPullRequest);
}
public async Task GetOne_ShouldReturnExpectedRepository_WhenItExists()
{
// Setup
var owner = "ampersandre";
var name = "fitbit-except-for-blinking";
var expectedRepository = Generator.GenerateRepository();
mockGitHubClient.Setup(c => c.Get <Repository>($"repos/{owner}/{name}")).Returns(Task.FromResult(expectedRepository));
// Execute
var actualRepository = await service.GetOne(owner, name);
// Assert
AssertUtils.AreIdentical(expectedRepository, actualRepository);
}
public void Get_ShouldReturnExpectedValue_WhenCacheContainsValue()
{
// Setup
var key = "repository:76";
var expectedValue = Generator.GenerateRepository(76);
var valueJson = JsonConvert.SerializeObject(expectedValue);
mockRedisDb.Setup(db => db.StringGet($"github-monitor:${key}", CommandFlags.None)).Returns(valueJson);
// Execute
var actualValue = redisCacheClient.Get <Repository>(key);
// Assert
AssertUtils.AreIdentical(expectedValue, actualValue);
}
public async Task Get_ShouldReturnExpectedObject_GivenResponse()
{
// Setup
var expectedUser = Generator.GeneraterUser();
var mockRestResponse = new Mock <IRestResponse <User> >();
mockRestResponse.Setup(r => r.Data).Returns(() => expectedUser);
mockRestClient.Setup(c => c.Execute <User>(It.IsAny <IRestRequest>())).Returns(() => mockRestResponse.Object);
// Execute
var actualUser = await client.Get <User>("users/ampersandre");
// Assert
Assert.IsNotNull(actualUser);
AssertUtils.AreIdentical(expectedUser, actualUser);
}
public async Task IndexController_ShouldReturnRepositories_WhenThereAreRepositories()
{
// Setup
var expectedRepositories = Enumerable.Range(1, 7).Select(Generator.GenerateRepository).ToList();
mockRepositoryService.Setup(s => s.GetAll()).Returns(() => Task.FromResult(expectedRepositories as IEnumerable <Repository>));
// Execute
var result = await indexController.Index() as ViewResult;
// Assert
Assert.IsNotNull(result);
Assert.IsAssignableFrom <List <Repository> >(result.ViewData.Model);
var actualRepositories = result.ViewData.Model as List <Repository>;
AssertUtils.AreIdentical(expectedRepositories, actualRepositories);
}
public async Task GetWithFunc_ShouldReturnExpectedValue_WhenCacheDoesNotContainValue()
{
// Setup
var key = "repository:23";
var expectedValue = Generator.GenerateRepository(23);
var valueJson = JsonConvert.SerializeObject(expectedValue);
mockRedisDb.Setup(db => db.StringGet($"github-monitor:${key}", CommandFlags.None)).Returns(default(string));
Func <Task <Repository> > resolver = () => {
return(Task.Run(() => expectedValue));
};
// Execute
var actualValue = await redisCacheClient.Get(key, resolver);
// Assert
AssertUtils.AreIdentical(expectedValue, actualValue);
mockRedisDb.Verify(db => db.StringSetAsync($"github-monitor:${key}", valueJson, TimeSpan.FromMinutes(3), When.Always, CommandFlags.None));
}
public async Task GetWithFunc_ShouldReturnExpectedValue_WhenCacheContainsValue()
{
// Setup
var key = "repository:23";
var expectedValue = Generator.GenerateRepository(23);
expectedValue.Name = "The original!";
var valueJson = JsonConvert.SerializeObject(expectedValue);
mockRedisDb.Setup(db => db.StringGet($"github-monitor:${key}", CommandFlags.None)).Returns(valueJson);
Func <Task <Repository> > resolver = () => {
return(Task.Run(() => Generator.GenerateRepository(23)));
};
// Execute
var actualValue = await redisCacheClient.Get(key, resolver);
// Assert
AssertUtils.AreIdentical(expectedValue, actualValue);
}
