public void GetStoriesByID_ReturnsValid()
{
var testId = 1;
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
.ReturnsAsync(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(testStories.Where(s => s.id == testId).First()), Encoding.UTF8, "application/json"),
})
.Verifiable();
var client = new HttpClient(handlerMock.Object);
client.BaseAddress = new Uri("http://test.test");
var service = new HackerNewsService();
service.Client = client;
var result = service.GetStoriesByID(new List <int>()
{
testId
});
Assert.True(result != null);
Assert.True(result.Count() == 1);
Assert.Equal(result.First().id, testId);
}
protected void btnGetArticles_Click(object sender, EventArgs e)
{
btnGetArticles.Enabled = false;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
//try accessing the web api, if there is an issue, show an error message to the user
try
{
originalArticles = HackerNewsService.GetNewArticles();
}
catch (Exception ex)
{
lblError.Text = ex.Message;
lblError.Visible = true;
}
finally
{
//if we were not able to get articles, we still want the button to be enabled so the user can try again
btnGetArticles.Enabled = true;
}
grdArticles.DataSource = originalArticles;
grdArticles.DataBind();
stopwatch.Stop();
lblTime.Text = "Article Retrive Took: " + stopwatch.Elapsed.ToString();
lblTime.Visible = true;
//now that we have content, enable searching
btnSearch.Enabled = true;
btnReset.Enabled = true;
}
public async Task WhenItem8863ThenStory()
{
IHackerNewsService hackerNewsService = new HackerNewsService();
var story = await hackerNewsService.Story(8863);
Check.That(story.Id).IsEqualTo(8863);
}
public void GetStoriesByID_InvalidIDReturnsValid()
{
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
.ReturnsAsync(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(string.Empty)
})
.Verifiable();
var client = new HttpClient(handlerMock.Object);
client.BaseAddress = new Uri("http://test.test");
var service = new HackerNewsService();
service.Client = client;
var result = service.GetStoriesByID(new List <int>()
{
21
});
Assert.True(result != null);
Assert.True(result.First() == null);
}
public async Task WhenBestStoriesThen200Stories()
{
IHackerNewsService hackerNewsService = new HackerNewsService();
var bestStories = await hackerNewsService.BestStories();
Check.That(bestStories.Count).IsEqualTo(200);
}
public async Task WhenTopStoriesThenXStories()
{
IHackerNewsService hackerNewsService = new HackerNewsService();
var topStories = await hackerNewsService.TopStories();
Check.That(topStories).IsNotNull();
}
public async Task WhenNewStoriesThen500Stories()
{
IHackerNewsService hackerNewsService = new HackerNewsService();
var newStories = await hackerNewsService.NewStories();
Check.That(newStories.Count).IsEqualTo(500);
}
public async Task CanGetStories(int?count, HttpResponseMessage latestStoriesResponse, IEnumerable <HackerNewsItemEntity> newsItems)
{
// Arrange
var config = new HackerNewsConfig
{
BaseUrl = "http://test.com",
DefaultArticleCount = 10
};
var cosmosDbService = new Mock <ICosmosDbService>();
cosmosDbService.Setup(x => x.GetHackerNewsItems(It.IsAny <Expression <Func <HackerNewsItemEntity, bool> > >())).ReturnsAsync(newsItems);
cosmosDbService.Setup(x => x.AddHackerNewsItem(It.IsAny <HackerNewsItemEntity>()));
var httpMessageHandler = new Mock <HttpMessageHandler>();
httpMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns((HttpRequestMessage y, CancellationToken z) => GetResponseMessage(y, latestStoriesResponse));
var httpClient = new HttpClient(httpMessageHandler.Object);
var service = new HackerNewsService(cosmosDbService.Object, httpClient, Options.Create(config));
// Act
var response = await service.GetStories(count);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Count() <= count.GetValueOrDefault());
}
public void Initialize()
{
_hackerNewsProxy = new Mock <IHackerNewsProxy>();
_staticCacheManager = new Mock <IStaticCacheManager>();
_hackerNewsService = new HackerNewsService(_hackerNewsProxy.Object, _staticCacheManager.Object);
_mockHackerNewsService = new Mock <HackerNewsService>(_hackerNewsProxy.Object, _staticCacheManager.Object);
_fixture = new Fixture();
}
public async Task RetrievesData()
{
IDataProvider dataProvider = new HackerNewsProvider(configurationMock.Object);
IHackerNewsService hackerNewsService = new HackerNewsService(dataProvider);
var result = await hackerNewsService.GetBestStoriesAsync();
Assert.IsTrue(result.Any());
}
public async Task GetBestStories_Should_Return_List_Of_Articles()
{
init();
HackerNewsService service = new HackerNewsService(_mockRepo.Object);
var articles = await service.GetBestStories();
articles.Should().HaveCount(2);
}
public async Task WhenItem160705ThenPollOpt()
{
IHackerNewsService hackerNewsService = new HackerNewsService();
var item = await hackerNewsService.Item(new ItemId(160705));
if (item is PollOpt pollOpt)
{
Check.That(pollOpt.Id).IsEqualTo(160705);
}
}
public void TestArticleToString()
{
List <Article> allNewArticles = HackerNewsService.GetNewArticles();
//check that we are not getting any completely null articles (specific code to prevent that from happening)
foreach (Article art in allNewArticles)
{
Assert.IsTrue(art != null);
}
}
private async Task <IEnumerable <BestStory> > GetStoriesData()
{
MemoryCacheOptions options = new MemoryCacheOptions();
IMemoryCache memoryCache = new MemoryCache(options);
IDataProvider dataProvider = new HackerNewsProvider(configurationMock.Object);
IHackerNewsService hackerNewsService = new HackerNewsService(dataProvider);
IStoryService storyService = new StoryService(hackerNewsService, configurationMock.Object, memoryCache);
return(await storyService.GetBestStoriesAsync());
}
public HackerNewsServiceTest()
{
var mapperMock = new Mapper(new MapperConfiguration(mc =>
{
mc.AddProfile(new ItemMappingProfile());
}));
client = new Mock <IAPIClient>();
hackerNews = new HackerNewsService(client.Object, mapperMock);
}
public async Task WhenItem2921983ThenComment()
{
IHackerNewsService hackerNewsService = new HackerNewsService();
var item = await hackerNewsService.Item(new ItemId(2921983));
Check.That(item).IsInstanceOf <Comment>();
if (item is Comment comment)
{
Check.That(comment.Id).IsEqualTo(2921983);
}
}
public async Task WhenItem192327ThenJob()
{
IHackerNewsService hackerNewsService = new HackerNewsService();
var item = await hackerNewsService.Item(new ItemId(192327));
Check.That(item).IsInstanceOf <Job>();
if (item is Job job)
{
Check.That(job.Id).IsEqualTo(192327);
}
}
public async Task <List <BestStoriesModel> > getBestStories()
{
// Init the search text to empty
ViewBag.newsSearchText = "";
// Get all the best stories
var bestStoriesIDs = await HackerNewsService.GetBestStoriesIDs(appSettings);
var bestStories = await HackerNewsService.GetBestStories(bestStoriesIDs, appSettings);
return(bestStories.OrderByDescending(i => i.time).Take(20).ToList());
}
public void TestGetArticleIds()
{
//retrive list of current top article ids
List <string> articleIds = HackerNewsService.GetNewArticleIdList();
//check that all new article id loaded
foreach (string artId in articleIds)
{
Assert.IsTrue(!string.IsNullOrEmpty(artId), "Failed to retrive an article id");
}
}
public async Task WhenItem126809ThenPoll()
{
IHackerNewsService hackerNewsService = new HackerNewsService();
var item = await hackerNewsService.Item(new ItemId(126809));
Check.That(item).IsInstanceOf <Poll>();
if (item is Poll poll)
{
Check.That(poll.Id).IsEqualTo(126809);
}
}
public async void HackerNewsService_GetNewsAsync_ById()
{
// Arrange
var articleId = 8863;
var logger = GetLogger();
var hackerNewsService = new HackerNewsService(logger);
// Act
var rv = await hackerNewsService.GetNewsAsync(articleId);
// Assert
Assert.Equal(8863, rv.Id);
Assert.Equal("dhouston", rv.By);
}
public async Task GetSpecificArticle_Returns_Value()
{
var serviceOptions = Microsoft.Extensions.Options.Options.Create(new ServiceOptions());
var stringContent = JsonConvert.SerializeObject(new Item {
Id = 1
});
var httpClient = await SetupMockHttpClient(stringContent);
var service = new HackerNewsService(httpClient, serviceOptions);
var result = await service.GetSpecificArticle(1);
Assert.NotNull(result);
Assert.Equal(result.Id, 1);
}
public async Task GetLatestArticleIdsAsync_Returns_Values()
{
var serviceOptions = Microsoft.Extensions.Options.Options.Create(new ServiceOptions());
var stringContent = JsonConvert.SerializeObject(new List <int>()
{
1, 2, 3, 4, 5
});
var httpClient = await SetupMockHttpClient(stringContent);
var service = new HackerNewsService(httpClient, serviceOptions);
var result = await service.GetLatestArticleIdsAsync();
Assert.NotNull(result);
Assert.True(result.Count() == 5);
}
public void TestGetArticle()
{
//create and seed random
Random rand = new Random((int)DateTime.Now.Ticks);
//retrive list of current top article ids
List <string> articleIds = HackerNewsService.GetNewArticleIdList();
//randomly get a current top article to load
string artId = articleIds[rand.Next(0, articleIds.Count)];
Article art = HackerNewsService.GetArticle(artId);
Assert.IsTrue(art != null, "Failed to retrive an article");
}
public void GiveAHackerNewsResponse_WhereTopStoryIdsAreNotAvailable_ExpectNoPosts()
{
//Arrange
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://hacker-news.firebaseio.com/v0/topstories.json")
.Respond("application/json", $"[]");
var client = new HttpClient(mockHttp);
var service = new HackerNewsService(client);
//Act
var posts = service.GetTopPosts(consoleStream).ToList();
//Assert
posts.Count.Should().Be(0);
}
public async void HackerNewsService_GetTopArticleIdsAsync()
{
// Arrange
var logger = GetLogger();
var hackerNewsService = new HackerNewsService(logger);
// Act
var rv = await hackerNewsService.GetTopArticleIdsAsync();
int[] result = rv.ToArray();
// Assert
var type1 = Assert.IsType <int[]>(result);
Assert.True(result.Count() > 0);
}
public async void Get_HackerNewsItems_Service_ShouldReturn_List()
{
_hackerNewsGateway.Setup(gw => gw.GetTopStoriesAsync()).ReturnsAsync(new List <string>()
{
"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"
});
_hackerNewsGateway.Setup(gw => gw.GetItemAsync(0)).ReturnsAsync(new Domain.Models.HackerNewsItem()
{
Id = 1
});
var service = new HackerNewsService(_config, _hackerNewsGateway.Object);
var results = await service.GetItemsAsync(0);
results.Count.Should().Be(10);
}
public void GivenAHackerNewsResponse_WhereTwoWellFormedPostsExist_ExpectTwoPostObjectsToBeConstructed()
{
//Arrange
var mockHttp = MockPostHttpMessageHandlerCreator.Create(new List <long> {
21134540, 21135259
});
var client = new HttpClient(mockHttp);
var service = new HackerNewsService(client);
//Act
var posts = service.GetTopPosts(consoleStream).ToList();
//Assert
posts.Count.Should().Be(2);
posts.FirstOrDefault(p => p.id == 21134540).Should().NotBeNull();
posts.FirstOrDefault(p => p.id == 21135259).Should().NotBeNull();
}
public void GivenHandleCalled_WithHttpResponseWithTwoValidPostsAndPostsNumberIsOne_ExpectFormattedJsonOnOutputStreamWithOnePost()
{
//Arrange
var mockHttpHandler = MockPostHttpMessageHandlerCreator.Create(new List <long> {
21134540, 21135259
});
var service = new HackerNewsService(new HttpClient(mockHttpHandler));
var handler = new HackerNewsScraperHandler(service);
var expected = JsonPostResourceLoader.Load("WithHttpResponseWithTwoValidPostsAndPostsNumberIsOne");
//Act
handler.Handle(new Options {
Posts = 1
}, consoleStream);
//Assert
var output = consoleStream.Output.ToString();
output.Should().Be(expected);
}
public void GivenHandleCalled_WithHttpResponseWithFiveValidPosts_ExpectFormattedJsonOnOutputWithPostsInOrderOfIdsCollection()
{
//Arrange
var mockHttpHandler = MockPostHttpMessageHandlerCreator.Create(new List <long> {
21134540, 21135259, 21144604, 21138841, 21144098
});
var service = new HackerNewsService(new HttpClient(mockHttpHandler));
var handler = new HackerNewsScraperHandler(service);
var expected = JsonPostResourceLoader.Load("WithHttpResponseWithFiveValidPosts");
//Act
handler.Handle(new Options {
Posts = 5
}, consoleStream);
//Assert
var output = consoleStream.Output.ToString();
output.Should().Be(expected);
}