def test_feed_writer_prints_nothing_with_an_empty_feed():
"""Empty aggregate feed should print nothing"""
subject = FeedWriter()
(feed_writer, aggregate_feed) = (Mock(), Mock())
subject.stdout = Mock()
aggregate_feed.expects(once()).is_empty().will(return_value(True))
subject.print_entry_listings(feed_writer, aggregate_feed)
aggregate_feed.verify()
subject.stdout.verify()
def test_create_entry():
"""Create a xkcd_feed item from a xkcd_feed and a xkcd_feed entry"""
agg_feed = AggregateFeed()
agg_feed.feed_factory = Mock()
(aggregate_feed, xkcd_feed, entry, converted) = (Mock(), Mock(), Mock(),
Mock())
agg_feed.feed_factory.expects(once()).from_parsed_feed(
same(xkcd_feed), same(entry)).will(return_value(converted))
aggregate_feed.expects(once()).add(same(converted))
agg_feed.create_entry(aggregate_feed, xkcd_feed, entry)
aggregate_feed.verify()
def test_combine_feeds():
"""Should combine feeds into a list of FeedEntries"""
subject = AggregateFeed()
mock_feeds = [Mock(), Mock()]
aggregate_feed = Mock()
aggregate_feed.expects(once()).add_single_feed(same(aggregate_feed),
same(mock_feeds[0]))
aggregate_feed.expects(once()).add_single_feed(same(aggregate_feed),
same(mock_feeds[1]))
subject.combine_feeds(aggregate_feed, mock_feeds)
aggregate_feed.verify()
def test_add_singled_feed():
"""Should add a single xkcd_feed to a set of feeds"""
entries = [Mock(), Mock()]
xkcd_feed = {'entries': entries}
aggregate_feed = Mock()
aggregate_feed.expects(once()).create_entry(same(aggregate_feed),
same(xkcd_feed),
same(entries[0]))
aggregate_feed.expects(once()).create_entry(same(aggregate_feed),
same(xkcd_feed),
same(entries[1]))
AggregateFeed().add_single_feed(aggregate_feed, xkcd_feed)
aggregate_feed.verify()
def test_main():
""""Main should create a feed and print results"""
args = ["unused_program_name", "x1"]
reader = RSReader()
reader.aggregate_feed = Mock()
reader.feed_writer = Mock()
reader.aggregate_feed.expects(once()).from_urls(
same(reader.aggregate_feed), eq(["x1"]))
reader.feed_writer.expects(once()).print_entry_listings(same(reader.feed_writer), \
same(reader.aggregate_feed))
reader.main(args)
reader.aggregate_feed.verify()
reader.feed_writer.verify()
def test_print_entry_listings():
"""Verify that a listing was printed"""
subject = FeedWriter()
(feed_writer, aggregate_feed, listings) = (Mock(), Mock(), Mock())
subject.stdout = Mock()
aggregate_feed.expects(once()).is_empty().will(return_value(False))
feed_writer.expects(once()).entry_listings(same(aggregate_feed)).\
will(return_value(listings))
subject.stdout.expects(once()).write(same(listings))
subject.stdout.expects(once()).write(eq(os.linesep))
subject.print_entry_listings(feed_writer, aggregate_feed)
feed_writer.verify()
subject.stdout.verify()
def test_get_feeds_from_urls():
"""Should get a feed for every URL"""
urls = [Mock(), Mock()]
feeds = [Mock(), Mock()]
subject = AggregateFeed()
subject.feedparser = Mock()
subject.feedparser.expects(once()).parse(same(urls[0])).will(
return_value(feeds[0]))
subject.feedparser.expects(once()).parse(same(urls[1])).will(
return_value(feeds[1]))
returned_feeds = subject.feeds_from_urls(urls)
assert_equals(feeds, returned_feeds)
subject.feedparser.verify()
def __init__(self,
head_tag_dict={},
build_tag_dict={},
mandatory_head_tags=[],
mandatory_build_tags=[],
mandatory_has_questions=False):
self.mock_hooks = Mock()
mocked_head_tag_dict = {
' ': self.mock_hooks.on_default_header,
'a_header': self.mock_hooks.on_a_header,
'an_other_header': self.mock_hooks.on_an_other_header
}
mocked_build_tag_dict = {
' ': self.mock_hooks.on_default_builder,
'a_builder': self.mock_hooks.on_a_builder,
'an_other_builder': self.mock_hooks.on_an_other_builder
}
mocked_head_tag_dict.update(head_tag_dict)
mocked_build_tag_dict.update(build_tag_dict)
super(Mocked_SaDrill,
self).__init__(mocked_head_tag_dict, mocked_build_tag_dict,
mandatory_head_tags, mandatory_build_tags,
mandatory_has_questions)
self.on_comment = self.mock_hooks.on_comment
self.on_section = self.mock_hooks.on_section
self.on_question = self.mock_hooks.on_question
def setUp(self):
self.SCORE = {}
for question in range(10, 30):
self.SCORE[str(question)] = question / 10.
self.quiz = self.CLASS_TO_TEST(self.QUIZ_POOL[:], self.SCORE)
self.mock_listener = Mock()
self.quiz.connect('break_time', self.mock_listener.break_time)
self.quiz.connect('question_changed',
self.mock_listener.question_changed)
def test_from_urls():
"""Should get feeds from URLs and combine them"""
urls = [Mock(), Mock()]
feeds = [Mock(), Mock()]
subject = AggregateFeed()
aggregate_feed = Mock()
subject.feedparser = Mock()
#
subject.feedparser.expects(once()).parse(same(urls[0])).will(
return_value(feeds[0]))
aggregate_feed.expects(once()).\
add_single_feed(same(aggregate_feed), same(feeds[0]))
#
subject.feedparser.expects(once()).parse(same(urls[1])).will(
return_value(feeds[1]))
aggregate_feed.expects(once()).\
add_single_feed(same(aggregate_feed), same(feeds[1]))
#
subject.from_urls(aggregate_feed, urls)
subject.feedparser.verify()
aggregate_feed.verify()
def setUp(self):
self.quiz = self.CLASS_TO_TEST(self.QUIZ_POOL[:])
self.mock_listener = Mock()
self.quiz.connect('break_time', self.mock_listener.break_time)
self.quiz.connect('question_changed',
self.mock_listener.question_changed)
def test_add():
"""Add a xkcd_feed entry to the aggregate"""
entry = Mock()
subject = AggregateFeed()
subject.add(entry)
assert_equals(set([entry]), subject.entries)
