Initial public release of PieTime!

\o/

tests/test_abstract_card.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+
+import mock
+import os
+import pygame
+
+from pie_time import application as app_module
+from pie_time.application import PieTime
+from pie_time.card import AbstractCard
+
+
+class Test_AbstractCard(object):
+    def _dummy_card(self, **settings):
+        app = PieTime(None)
+        card = AbstractCard()
+        card.set_app(app)
+        card.set_settings(settings)
+
+        return card
+
+    def test_init(self):
+        card = AbstractCard()
+        assert card._app is None
+        assert card._settings == {}
+        assert card._surface is None
+
+    def test_set_app(self):
+        card = AbstractCard()
+        app = mock.Mock(spec=PieTime)
+        card.set_app(app)
+        assert card._app == app
+
+    def test_set_settings(self):
+        card = AbstractCard()
+        settings = {'spam': 'eggs'}
+        card.set_settings(settings)
+        assert card._settings == settings
+
+    def test_width(self):
+        card = self._dummy_card()
+        assert card.width == card._app.screen_size[0]
+
+    def test_height(self):
+        card = self._dummy_card()
+        assert card.height == card._app.screen_size[1]
+
+    def test_surface(self):
+        fake_surface = mock.Mock(spec=pygame.surface.Surface)
+
+        with mock.patch.object(app_module.pygame.surface, 'Surface',
+                               return_value=fake_surface):
+            card = self._dummy_card()
+            assert card.surface == fake_surface
+            assert card._surface == card.surface
+            app_module.pygame.surface.Surface.assert_called_with((
+                card.width, card.height
+            ))
+
+    def test_background_color(self):
+        card = self._dummy_card()
+        assert card.background_color == card._app.BACKGROUND_COLOR
+
+    def test_background_color_override(self):
+        card = self._dummy_card(background_color=(255, 255, 255))
+        assert card.background_color == (255, 255, 255)
+
+    def test_path_for_resource(self):
+        card = self._dummy_card()
+
+        spam_path = card.path_for_resource('spam')
+        assert os.path.isabs(spam_path)
+        assert card.RESOURCE_FOLDER in spam_path
+        assert spam_path.endswith('spam')
+
+        spam_eggs_path = card.path_for_resource('spam', folder='eggs')
+        assert os.path.isabs(spam_eggs_path)
+        assert card.RESOURCE_FOLDER in spam_eggs_path
+        assert 'eggs' in spam_eggs_path
+        assert spam_eggs_path.endswith('spam')
+
+    def test_tick(self):
+        try:
+            card = self._dummy_card()
+            card.tick()
+        except Exception as exc:
+            assert isinstance(exc, RuntimeError)
+            assert exc.args[0] == 'TODO'
+        else:
+            assert False, 'Nothing was raised :('

tests/test_application.py

@@ -0,0 +1,744 @@
+# -*- coding: utf-8 -*-
+
+import datetime
+import logging
+import os
+import sys
+
+import mock
+import pygame
+
+from pie_time import application as app_module
+from pie_time.application import logging as app_logging
+from pie_time.application import EVENT_QUIT, EVENT_CLICK_TO_UNBLANK,\
+    EVENT_CLICK_TO_PREV_CARD, EVENT_CLICK_TO_NEXT_CARD, RET_OK, RET_ERROR,\
+    PieTime
+from pie_time.card import AbstractCard
+
+
+class DummyCard(AbstractCard):
+    def tick(self):
+        pass
+
+    def initialize(self):
+        self._surface = mock.Mock(spec=pygame.surface.Surface)
+
+
+class FakeTimer(object):
+    def __init__(self, step=1, start=None):
+        if start is None:
+            self.n = 0 - step
+        else:
+            self.n = start
+        self._step = step
+
+    def __call__(self):
+        self.n += self._step
+        return self.n
+
+
+def _now(*args):
+    return datetime.datetime(*args)
+
+
+class Test_Application(object):
+    def _dummy_deck(self):
+        return [mock.Mock(spec=DummyCard)]
+
+    def _dummy_blanker_schedule(self):
+        return (datetime.timedelta(hours=1), datetime.timedelta(hours=2))
+
+    def _mocked_app(self, **kwargs):
+        mocked_app = PieTime(self._dummy_deck(), **kwargs)
+        mocked_app.init_pygame = mock.Mock()
+        mocked_app.get_screen = mock.Mock(
+            side_effect=lambda: mock.Mock(spec=pygame.Surface)
+        )
+        mocked_app._should_blank = mock.Mock(return_value=False)
+        mocked_app._blank = mock.Mock()
+        mocked_app._unblank = mock.Mock()
+        mocked_app.fill_screen = mock.Mock()
+        mocked_app._clock = mock.Mock(spec=pygame.time.Clock)
+        mocked_app.destroy_cards = mock.Mock()
+        mocked_app.quit_pygame = mock.Mock()
+        mocked_app._start_clock = mock.Mock()
+        mocked_app._setup_output_stream = mock.Mock()
+        mocked_app._setup_logging = mock.Mock()
+        mocked_app._logger = mock.Mock(spec=logging.Logger)
+
+        def init_cards(*args, **kwargs):
+            PieTime.init_cards(mocked_app)
+
+        mocked_app.init_cards = mock.Mock(side_effect=init_cards)
+
+        def transition_cards(*args, **kwargs):
+            mocked_app._current_card_idx = 0
+            mocked_app._current_card_time = 0
+
+        mocked_app._transition_cards = mock.Mock(
+            side_effect=transition_cards
+        )
+
+        return mocked_app
+
+    def _make_app(self, *args, **kwargs):
+        new_app = PieTime(*args, **kwargs)
+        new_app._logger = mock.Mock(spec=logging.Logger)
+
+        return new_app
+
+    def test_init_default_settings(self):
+        deck = self._dummy_deck()
+        app = self._make_app(deck)
+
+        assert app._deck == deck
+        assert app.screen is None
+        assert app.screen_size == (320, 240)
+        assert app.events == []
+        assert app.log_path is None
+        assert app._fps == 20
+        assert app._verbose is False
+        assert app._blanker_schedule is None
+        assert app._click_to_unblank_interval is None
+        assert app._click_to_transition is True
+        assert app._clock is None
+        assert app._cards == []
+        assert app._is_blanked is False
+        assert app._current_card_idx is None
+        assert app._current_card_time is None
+        assert app._should_quit is False
+        assert len(app._internal_events) == 0
+        assert app._ctu_timer is None
+        assert app._output_stream is None
+
+        assert app._ctt_region_prev.x == 0
+        assert app._ctt_region_prev.y == 210
+        assert app._ctt_region_prev.width == 30
+        assert app._ctt_region_prev.height == 30
+
+        assert app._ctt_region_next.x == 290
+        assert app._ctt_region_next.y == 210
+        assert app._ctt_region_next.width == 30
+        assert app._ctt_region_next.height == 30
+
+    def test_init_override_settings(self):
+        deck = self._dummy_deck()
+        blanker_schedule = self._dummy_blanker_schedule()
+
+        app = self._make_app(
+            deck, screen_size=(640, 480), fps=60, verbose=True,
+            blanker_schedule=blanker_schedule,
+            click_to_unblank_interval=10, click_to_transition=False,
+            log_path='/path/to/log_file.txt'
+        )
+
+        assert app.screen_size == (640, 480)
+        assert app.log_path == '/path/to/log_file.txt'
+        assert app._fps == 60
+        assert app._verbose is True
+        assert app._blanker_schedule == blanker_schedule
+        assert app._click_to_unblank_interval == 10
+        assert app._click_to_transition is False
+
+    def test_should_blank_scheduled(self):
+        blanker_schedule = self._dummy_blanker_schedule()
+
+        app = self._make_app(self._dummy_deck())
+        assert app._should_blank(now=_now(2014, 10, 15, 9)) is False
+
+        app = self._make_app(
+            self._dummy_deck(), blanker_schedule=blanker_schedule
+        )   
+        assert app._should_blank(now=_now(2014, 10, 15, 0, 0, 0)) is False
+        assert app._should_blank(now=_now(2014, 10, 15, 1, 0, 0)) is True
+        assert app._should_blank(now=_now(2014, 10, 15, 1, 30, 0)) is True
+        assert app._should_blank(now=_now(2014, 10, 15, 1, 59, 59)) is True
+        assert app._should_blank(now=_now(2014, 10, 15, 2, 0, 0)) is False
+        assert app._should_blank(now=_now(2014, 10, 15, 9, 0, 0)) is False
+
+        blanker_schedule = (
+            datetime.timedelta(hours=23), datetime.timedelta(hours=6)
+        )
+        app = self._make_app(
+            self._dummy_deck(), blanker_schedule=blanker_schedule
+        )
+        assert app._should_blank(now=_now(2014, 10, 15, 0, 0, 0)) is True
+        assert app._should_blank(now=_now(2014, 10, 15, 5, 59, 59)) is True
+        assert app._should_blank(now=_now(2014, 10, 15, 6, 0, 0)) is False
+        assert app._should_blank(now=_now(2014, 10, 15, 12, 0, 0)) is False
+        assert app._should_blank(now=_now(2014, 10, 15, 22, 59, 59)) is False
+        assert app._should_blank(now=_now(2014, 10, 15, 23, 0, 0)) is True
+
+    def test_should_blank_ctu(self):
+        ctu = 10
+
+        app = self._make_app(self._dummy_deck())
+        app._has_click_to_unblank_event = mock.Mock(return_value=True)
+        assert app._should_blank() is False
+        assert app._ctu_timer is None
+
+        app = self._make_app(
+            self._dummy_deck(),
+            blanker_schedule=self._dummy_blanker_schedule(),
+            click_to_unblank_interval=ctu
+        )
+        app._is_blanked = True
+        app._has_click_to_unblank_event = mock.Mock(return_value=True)
+        assert app._should_blank(now=_now(2014, 10, 15, 1, 0, 0)) is False
+        assert app._ctu_timer == ctu
+
+        app = self._make_app(
+            self._dummy_deck(),
+            blanker_schedule=self._dummy_blanker_schedule(),
+            click_to_unblank_interval=ctu
+        )
+        app._is_blanked = True
+        app._ctu_timer = ctu
+        app._has_click_to_unblank_event = mock.Mock(return_value=False)
+
+        app._clock = mock.Mock(spec=pygame.time.Clock)
+        app._clock.get_time = mock.Mock(return_value=1 * 1000)
+
+        assert app._should_blank(now=_now(2014, 10, 15, 1, 0, 0)) is False
+        assert app._ctu_timer == ctu - 1
+
+        app = self._make_app(
+            self._dummy_deck(),
+            blanker_schedule=self._dummy_blanker_schedule(),
+            click_to_unblank_interval=ctu
+        )
+        app._is_blanked = True
+        app._ctu_timer = ctu
+        app._has_click_to_unblank_event = mock.Mock(return_value=False)
+
+        app._clock = mock.Mock(spec=pygame.time.Clock)
+        app._clock.get_time = mock.Mock(return_value=ctu * 1000)
+
+        assert app._should_blank(now=_now(2014, 10, 15, 1, 0, 0)) is True
+        assert app._ctu_timer is None
+
+    def test_blank(self):
+        app = self._make_app(self._dummy_deck())
+        app.screen = mock.Mock(spec=pygame.surface.Surface)
+        app.will_blank = mock.Mock()
+
+        app._blank()
+        assert app._is_blanked is True
+        assert app.will_blank.called is True
+        app.screen.fill.assert_called_with(PieTime.BLANK_COLOR)
+
+    def test_unblank(self):
+        app = self._make_app(self._dummy_deck())
+        app.init_cards()
+        app._is_blanked = True
+        app.will_unblank = mock.Mock()
+
+        app._unblank()
+        assert app._is_blanked is False
+        assert app.will_unblank.called is True
+        assert app._cards[0][0].show.call_count == 1
+
+    def test_transition_cards(self):
+        deck = [
+            (mock.Mock(spec=DummyCard), 1),
+            (mock.Mock(spec=DummyCard), 1)
+        ]
+
+        app = self._make_app(self._dummy_deck())
+        app.init_cards()
+        app._transition_cards()
+
+        assert app._current_card_idx == 0
+        assert not app._cards[0][0].hide.called
+        assert app._cards[0][0].show.call_count == 1
+
+        app = self._make_app(deck)
+        app._clock = mock.Mock(spec=pygame.time.Clock)
+
+        timer = FakeTimer(step=2, start=0)
+        app._clock.get_time = mock.Mock(
+            side_effect=lambda: timer() * 1000.0
+        )
+
+        app.init_cards()
+        app._current_card_idx = 0
+        app._current_card_time = 0
+
+        app._transition_cards()
+        assert app._current_card_idx == 1
+        assert app._cards[0][0].hide.call_count == 1
+        assert app._cards[1][0].show.call_count == 1
+
+        app._transition_cards()
+        assert app._current_card_idx == 0
+        assert app._cards[0][0].show.call_count == 1
+        assert app._cards[1][0].hide.call_count == 1
+
+    def test_transition_cards_forced(self):
+        deck = [
+            (mock.Mock(spec=DummyCard), 1),
+            (mock.Mock(spec=DummyCard), 1)
+        ]
+
+        app = self._make_app(deck)
+        app._clock = mock.Mock(spec=pygame.time.Clock)
+
+        timer = FakeTimer(step=2, start=0)
+        app._clock.get_time = mock.Mock(
+            side_effect=lambda: timer()
+        )
+
+        app.init_cards()
+        app._current_card_idx = 0
+        app._current_card_time = 0
+
+        app._transition_cards(direction=1, force=True)
+        assert app._current_card_idx == 1
+
+        app._transition_cards(direction=1, force=True)
+        assert app._current_card_idx == 0
+
+        app._transition_cards(direction=-1, force=True)
+        assert app._current_card_idx == 1
+
+        app._transition_cards(direction=-1, force=True)
+        assert app._current_card_idx == 0
+
+    def test_get_events_quit_pygame(self):
+        new_event_get = mock.Mock(return_value=[
+            pygame.event.Event(pygame.QUIT)
+        ])
+
+        app = self._make_app(self._dummy_deck())
+        with mock.patch.object(app_module.pygame.event, 'get',
+                               new=new_event_get):
+            app._get_events()
+            assert app._internal_events == set([EVENT_QUIT])
+
+    def test_get_events_quit_key(self):
+        new_event_get = mock.Mock(return_value=[
+            pygame.event.Event(pygame.KEYDOWN, key=PieTime.KEY_QUIT)
+        ])
+
+        app = self._make_app(self._dummy_deck())
+        with mock.patch.object(app_module.pygame.event, 'get',
+                               new=new_event_get):
+            app._get_events()
+            assert app._internal_events == set([EVENT_QUIT])
+
+    def test_get_events_click_to_unblank(self):
+        new_event_get = mock.Mock(return_value=[
+            pygame.event.Event(pygame.MOUSEBUTTONDOWN, pos=(160, 120))
+        ])
+
+        app = self._make_app(self._dummy_deck(), click_to_unblank_interval=10)
+        with mock.patch.object(app_module.pygame.event, 'get',
+                               new=new_event_get):
+            app._is_blanked = False
+            app._get_events()
+            assert app._internal_events == set()
+
+            app._is_blanked = True
+            app._get_events()
+            assert app._internal_events == set([EVENT_CLICK_TO_UNBLANK])
+
+    def test_get_events_click_to_prev_card(self):
+        new_event_get = mock.Mock(return_value=[
+            pygame.event.Event(pygame.MOUSEBUTTONDOWN, pos=(10, 230))
+        ])
+
+        app = self._make_app(self._dummy_deck(), click_to_transition=True)
+        with mock.patch.object(app_module.pygame.event, 'get',
+                               new=new_event_get):
+            app._is_blanked = False
+            app._get_events()
+            assert app._internal_events == set([EVENT_CLICK_TO_PREV_CARD])
+
+            app._is_blanked = True
+            app._get_events()
+            assert EVENT_CLICK_TO_PREV_CARD not in app._internal_events
+
+            app._click_to_transition = False
+            app._is_blanked = False
+            app._get_events()
+            assert EVENT_CLICK_TO_PREV_CARD not in app._internal_events
+
+    def test_get_events_click_to_next_card(self):
+        new_event_get = mock.Mock(return_value=[
+            pygame.event.Event(pygame.MOUSEBUTTONDOWN, pos=(310, 230))
+        ])
+
+        app = self._make_app(self._dummy_deck(), click_to_transition=True)
+        with mock.patch.object(app_module.pygame.event, 'get',
+                               new=new_event_get):
+            app._is_blanked = False
+            app._get_events()
+            assert app._internal_events == set([EVENT_CLICK_TO_NEXT_CARD])
+
+            app._is_blanked = True
+            app._get_events()
+            assert EVENT_CLICK_TO_NEXT_CARD not in app._internal_events
+
+            app._click_to_transition = False
+            app._is_blanked = False
+            app._get_events()
+            assert EVENT_CLICK_TO_NEXT_CARD not in app._internal_events
+
+    def test_get_events_other_events(self):
+        events = [
+            pygame.event.Event(pygame.MOUSEBUTTONDOWN, pos=(160, 120)),
+            pygame.event.Event(pygame.KEYDOWN, key=pygame.K_RETURN)
+        ]
+        new_event_get = mock.Mock(return_value=events)
+
+        app = self._make_app(self._dummy_deck(), click_to_transition=True)
+        with mock.patch.object(app_module.pygame.event, 'get',
+                               new=new_event_get):
+            app._is_blanked = False
+            app._get_events()
+            assert app._internal_events == set()
+            assert app.events == events
+
+    def test_has_quit_event(self):
+        app = self._make_app(self._dummy_deck())
+        assert app._has_quit_event() is False
+
+        app._internal_events.add(EVENT_QUIT)
+        assert app._has_quit_event() is True
+
+    def test_has_click_to_unblank_event(self):
+        app = self._make_app(self._dummy_deck(), click_to_unblank_interval=10)
+        assert app._has_click_to_unblank_event() is False
+
+        app._internal_events.add(EVENT_CLICK_TO_UNBLANK)
+        assert app._has_click_to_unblank_event() is True
+
+    def test_start_clock(self):
+        app = self._make_app(self._dummy_deck())
+
+        fake_clock = mock.Mock(spec=pygame.time.Clock)
+        with mock.patch.object(app_module.pygame.time, 'Clock',
+                               return_value=fake_clock):
+            app._start_clock()
+
+            assert app_module.pygame.time.Clock.called is True
+            assert app._clock == fake_clock
+
+    def test_setup_output_stream_no_log_path(self):
+        deck = self._dummy_deck()
+
+        with mock.patch.object(PieTime, '_STREAM_FACTORY'):
+            with mock.patch.object(PieTime, '_setup_logging'):
+                app = self._make_app(deck, log_path=None)
+                app._setup_output_stream()
+
+                assert app._output_stream == PieTime._DEFAULT_OUTPUT_STREAM
+                assert PieTime._STREAM_FACTORY.called is False
+
+    def test_setup_output_stream_with_log_path(self):
+        deck = self._dummy_deck()
+        fake_file = mock.Mock(spec=file)
+
+        with mock.patch.object(PieTime, '_STREAM_FACTORY', new=fake_file):
+            with mock.patch.object(PieTime, '_setup_logging'):
+                app = self._make_app(deck, log_path='/path/to/log_file.txt')
+                app._setup_output_stream()
+
+                PieTime._STREAM_FACTORY.assert_called_with(app.log_path, 'a')
+                assert app._output_stream != fake_file
+
+    def test_setup_logging_silent(self):
+        deck = self._dummy_deck()
+
+        fake_logger = mock.Mock(spec=logging.Logger)
+        fake_requests_logger = mock.Mock(spec=logging.Logger)
+        fake_handler = mock.Mock(spec=logging.StreamHandler)
+        fake_formatter = mock.Mock(spec=logging.Formatter)
+
+        fake_requests_logger.handlers = ['spam', 'eggs']
+        fake_requests_logger.removeHandler = mock.Mock()
+
+        def fake_getLogger(name):
+            if name == 'PieTime':
+                return fake_logger
+            elif name == 'requests':
+                return fake_requests_logger
+            else:
+                return None
+
+        with mock.patch.object(app_logging, 'getLogger',
+                               side_effect=fake_getLogger):
+            with mock.patch.object(app_logging,
+                                   'StreamHandler', return_value=fake_handler):
+                with mock.patch.object(app_logging,
+                                       'Formatter',
+                                       return_value=fake_formatter):
+                    app = self._make_app(deck, verbose=False)
+                    app._output_stream = 'spam'
+                    app._setup_logging()
+
+                    fake_logger.setLevel.assert_called_with(logging.INFO)
+                    fake_requests_logger.setLevel.assert_called_with(
+                        logging.WARNING
+                    )
+
+                    app_logging.StreamHandler.assert_called_with(
+                        app._output_stream
+                    )
+
+                    assert app_logging.Formatter.called is True
+
+                    fake_handler.setFormatter.assert_called_with(
+                        fake_formatter
+                    )
+
+                    fake_logger.addHandler.assert_called_with(fake_handler)
+
+                    assert fake_requests_logger.removeHandler.call_count == 2
+                    fake_requests_logger.removeHandler.assert_any_call('spam')
+                    fake_requests_logger.removeHandler.assert_any_call('eggs')
+
+                    fake_requests_logger.addHandler.assert_called_with(
+                        fake_handler
+                    )
+
+    def test_setup_logging_verbose(self):
+        deck = self._dummy_deck()
+
+        fake_logger = mock.Mock(spec=logging.Logger)
+
+        fake_requests_logger = mock.Mock(spec=logging.Logger)
+        fake_requests_logger.handlers = []
+
+        def fake_getLogger(name):
+            if name == 'PieTime':
+                return fake_logger
+            elif name == 'requests':
+                return fake_requests_logger
+            else:
+                return None
+
+        with mock.patch.object(app_logging, 'getLogger',
+                               side_effect=fake_getLogger):
+            with mock.patch.object(app_logging, 'StreamHandler'):
+                with mock.patch.object(app_logging, 'Formatter'):
+                    app = self._make_app(deck, verbose=True)
+                    app._output_stream = 'spam'
+                    app._setup_logging()
+
+                    fake_logger.setLevel.assert_called_with(logging.DEBUG)
+                    assert fake_requests_logger.setLevel.called is False
+
+    def test_logger(self):
+        app = self._make_app(self._dummy_deck())
+        assert app.logger is not None
+
+    def test_init_pygame(self):
+        app = self._make_app(self._dummy_deck())
+
+        with mock.patch.object(app_module.pygame, 'init'):
+            with mock.patch.object(app_module.pygame.mouse, 'set_visible'):
+                app.init_pygame()
+                assert app_module.pygame.init.called
+                app_module.pygame.mouse.set_visible.assert_called_with(False)
+                assert app._clock is None
+
+    def test_quit_pygame(self):
+        app = self._make_app(self._dummy_deck())
+
+        with mock.patch.object(app_module.pygame, 'quit'):
+            app.quit_pygame()
+            assert app_module.pygame.quit.called
+            assert app._clock is None
+
+    def test_init_cards(self):
+        deck = [
+            mock.Mock(spec=DummyCard),
+            (mock.Mock(spec=DummyCard), 10),
+            (mock.Mock(spec=DummyCard), 20, {'spam': 'eggs'})
+        ]
+
+        app = self._make_app(deck)
+        app.init_cards()
+
+        assert len(app._cards) == 3
+
+        app._cards[0][0].set_app.assert_called_with(app)
+        app._cards[0][0].set_settings.assert_called_with({})
+        assert app._cards[0][0].initialize.called
+        assert not app._cards[0][0].show.called
+        assert app._cards[0][1] == PieTime.CARD_INTERVAL
+
+        app._cards[1][0].set_app.assert_called_with(app)
+        app._cards[1][0].set_settings.assert_called_with({})
+        assert app._cards[1][0].initialize.called
+        assert not app._cards[1][0].show.called
+        assert app._cards[1][1] == 10
+
+        app._cards[2][0].set_app.assert_called_with(app)
+        app._cards[2][0].set_settings.assert_called_with({'spam': 'eggs'})
+        assert app._cards[2][0].initialize.called
+        assert not app._cards[2][0].show.called
+        assert app._cards[2][1] == 20
+
+        assert app._current_card_idx is None
+        assert app._current_card_time is None
+
+    def test_destroy_cards(self):
+        with mock.patch.object(DummyCard, 'quit'):
+            app = self._make_app([DummyCard])
+
+            app.init_cards()
+            app.destroy_cards()
+
+            assert len(app._cards) == 0
+            assert DummyCard.quit.called
+
+    def test_get_screen(self):
+        with mock.patch.object(app_module.pygame.display, 'set_mode',
+                               return_value='spam'):
+                app = self._make_app(self._dummy_deck())
+                screen = app.get_screen()
+
+                assert screen == 'spam'
+                app_module.pygame.display.set_mode.\
+                    assert_called_with(app.screen_size)
+
+    def test_fill_screen(self):
+        app = self._make_app(self._dummy_deck())
+        app.screen = mock.Mock(pygame.Surface)
+
+        app.fill_screen()
+        app.screen.fill.assert_called_with(PieTime.BACKGROUND_COLOR)
+
+    def test_run(self):
+        app = self._mocked_app()
+
+        def new_start_clock(*args, **kwargs):
+            app._clock.tick = mock.Mock(side_effect=lambda x: app.quit())
+        app._start_clock = mock.Mock(side_effect=new_start_clock)
+
+        new_event_get = mock.Mock(return_value=[])
+
+        with mock.patch.object(app_module.sys, 'exit'):
+            with mock.patch.object(app_module.pygame.event, 'get',
+                                   new=new_event_get):
+                with mock.patch.object(app_module.pygame.display, 'flip'):
+                    app.run()
+
+                    assert app._setup_output_stream.called is True
+                    assert app._setup_logging.called is True
+
+                    assert app.init_pygame.called
+                    assert app.get_screen.called
+                    assert app.screen is not None
+                    assert app.init_cards.called
+                    assert app._start_clock.called
+                    assert app_module.pygame.event.get.called
+                    assert app._should_blank.called
+                    assert app._unblank.called
+                    assert not app._blank.called
+                    assert app._transition_cards.called
+                    assert app._cards[0][0].tick.called
+                    assert app.fill_screen.called
+                    app.screen.blit.assert_called_with(
+                        app._cards[0][0].surface,
+                        (0, 0, app._cards[0][0].width, app._cards[0][0].height)
+                    )
+                    assert pygame.display.flip.called
+                    app._clock.tick.assert_called_with(app._fps)
+                    assert app.destroy_cards.called
+                    assert app.quit_pygame.called
+                    app_module.sys.exit.assert_called_with(RET_OK)
+
+    def test_run_handling_exception(self):
+        app = self._mocked_app()
+        app._clock.tick = mock.Mock(side_effect=RuntimeError('spam'))
+
+        new_event_get = mock.Mock(return_value=[])
+
+        with mock.patch.object(app_module.sys, 'exit'):
+            with mock.patch.object(app_module.pygame.event, 'get',
+                                   new=new_event_get):
+                with mock.patch.object(app_module.pygame.display, 'flip'):
+                    app.run()
+                    sys.exit.assert_called_with(RET_ERROR)
+
+    def test_run_handling_quit_event(self):
+        app = self._mocked_app()
+        app._get_events = mock.Mock()
+        app._has_quit_event = mock.Mock(return_value=True)
+
+        with mock.patch.object(app_module.sys, 'exit'):
+            with mock.patch.object(app_module.pygame.display, 'flip'):
+                app.run()
+                sys.exit.assert_called_with(RET_OK)
+
+    def test_run_blanking(self):
+        app = self._mocked_app()
+
+        timer = FakeTimer()
+
+        def should_blank(*args, **kwargs):
+            return (timer.n % 2 == 1)
+
+        app._should_blank = mock.Mock(side_effect=should_blank)
+
+        def clock_tick(*args, **kwargs):
+            timer()
+            if timer.n == 3:
+                app.quit()
+
+        app._clock.tick = mock.Mock(side_effect=clock_tick)
+
+        new_event_get = mock.Mock(return_value=[])
+
+        with mock.patch.object(app_module.sys, 'exit'):
+            with mock.patch.object(app_module.pygame.event, 'get',
+                                   new=new_event_get):
+                with mock.patch.object(app_module.pygame.display, 'flip'):
+                    app.run()
+
+                    assert app._unblank.call_count == 2
+                    assert app._blank.call_count == 2
+
+    def test_run_handling_click_to_prev_event(self):
+        app = self._mocked_app()
+        app._internal_events = set([EVENT_CLICK_TO_PREV_CARD])
+
+        def clock_tick(*args, **kwargs):
+            app.quit()    
+
+        app._clock.tick = mock.Mock(side_effect=clock_tick)
+        app._get_events = mock.Mock()
+
+        with mock.patch.object(app_module.sys, 'exit'):
+            with mock.patch.object(app_module.pygame.display, 'flip'):
+                app.run()
+
+                app._transition_cards.assert_called_with(
+                    direction=-1, force=True
+                )
+
+    def test_run_handling_click_to_next_event(self):
+        app = self._mocked_app()
+        app._internal_events = set([EVENT_CLICK_TO_PREV_CARD])
+
+        def clock_tick(*args, **kwargs):
+            app.quit()    
+
+        app._clock.tick = mock.Mock(side_effect=clock_tick)
+        app._get_events = mock.Mock()
+
+        with mock.patch.object(app_module.sys, 'exit'):
+            with mock.patch.object(app_module.pygame.display, 'flip'):
+                app.run()
+
+                app._transition_cards.assert_called_with(
+                    direction=-1, force=True
+                )
+
+    def test_quit(self):
+        app = self._mocked_app()
+        app.quit()
+        assert app._should_quit is True

tests/test_clock_card.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+
+import datetime
+
+import mock
+import pygame
+
+from pie_time import application as app_module
+from pie_time.application import PieTime
+from pie_time.cards import ClockCard
+
+
+class Test_ClockCard(object):
+    def _dummy_card(self, **settings):
+        app = PieTime(None, screen_size=(320, 240))
+        app.path_for_resource = mock.Mock(
+            side_effect=lambda resource: resource
+        )
+        card = ClockCard()
+        card.set_app(app)
+        card.set_settings(settings)
+
+        return card
+
+    def test_initialize(self):
+        with mock.patch.object(app_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card = self._dummy_card()
+            card.initialize()
+            assert card._time_font is not None
+            assert card._date_font is not None
+
+    def test_render_time(self):
+        with mock.patch.object(app_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card = self._dummy_card()
+            card.initialize()
+
+            now = datetime.datetime.now().replace(second=0)
+            card._render_time(now)
+            card._time_font.render.assert_called_with(
+                now.strftime(card.TIME_FORMAT), True, card.GREEN
+            )
+
+            now = datetime.datetime.now().replace(second=1)
+            card._render_time(now)
+            card._time_font.render.assert_called_with(
+                now.strftime(card.TIME_FORMAT).replace(':', ' '), True,
+                card.GREEN
+            )
+
+    def test_render_time_override_format(self):
+        with mock.patch.object(app_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            time_format = '%H:%M'
+            card = self._dummy_card(time_format=time_format)
+            card.initialize()
+
+            now = datetime.datetime.now().replace(second=0)
+            card._render_time(now)
+            card._time_font.render.assert_called_with(
+                now.strftime(time_format), True, card.GREEN
+            )
+
+    def test_render_time_override_color(self):
+        with mock.patch.object(app_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            time_color = (255, 255, 255)
+            card = self._dummy_card(time_color=time_color)
+            card.initialize()
+
+            now = datetime.datetime.now().replace(second=0)
+            card._render_time(now)
+            card._time_font.render.assert_called_with(
+                now.strftime(card.TIME_FORMAT), True, (255, 255, 255)
+            )
+
+    def test_render_time_override_blink(self):
+        with mock.patch.object(app_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card = self._dummy_card(time_blink=False)
+            card.initialize()
+
+            now = datetime.datetime.now().replace(second=1)
+            card._render_time(now)
+            card._time_font.render.assert_called_with(
+                now.strftime(card.TIME_FORMAT), True, card.GREEN
+            )
+
+    def test_render_date(self):
+        with mock.patch.object(app_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card = self._dummy_card()
+            card.initialize()
+
+            now = datetime.datetime.now()
+            card._render_date(now)
+            card._date_font.render.assert_called_with(
+                now.strftime(card.DATE_FORMAT), True, card.GREEN
+            )
+
+    def test_render_date_override_format(self):
+        with mock.patch.object(app_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            date_format = '%Y-%M-%D'
+            card = self._dummy_card(date_format=date_format)
+            card.initialize()
+
+            now = datetime.datetime.now().replace(second=0)
+            card._render_date(now)
+            card._date_font.render.assert_called_with(
+                now.strftime(date_format), True, card.GREEN
+            )
+
+    def test_render_date_override_color(self):
+        with mock.patch.object(app_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            date_color = (255, 255, 255)
+            card = self._dummy_card(date_color=date_color)
+            card.initialize()
+
+            now = datetime.datetime.now().replace(second=0)
+            card._render_date(now)
+            card._date_font.render.assert_called_with(
+                now.strftime(card.DATE_FORMAT), True, (255, 255, 255)
+            )
+
+    def test_update_now(self):
+        now = datetime.datetime.now()
+        current_delta = 0
+
+        fake_datetime = mock.Mock(spec=datetime.datetime)
+
+        def fake_datetime_now(*args, **kwargs):
+            return now + datetime.timedelta(seconds=current_delta)
+
+        fake_datetime.now = mock.Mock(side_effect=fake_datetime_now)
+
+        with mock.patch.object(app_module.datetime, 'datetime',
+                               new=fake_datetime):
+            with mock.patch.object(app_module.pygame.font, 'Font',
+                                   spec=pygame.font.Font):
+                card = self._dummy_card()
+                card.initialize()
+
+                card._app = mock.Mock(spec=PieTime)
+                card._app._clock = mock.Mock(spec=pygame.time.Clock)
+                card._app._clock.get_time = mock.Mock(
+                    side_effect=lambda: current_delta
+                )
+
+                assert card._update_now() is True
+                assert card._now == now
+                assert card._current_interval == 0
+
+                current_delta = 500
+                assert card._update_now() is False
+                assert card._now == now
+                assert card._current_interval == current_delta
+
+                current_delta = 530
+                assert card._update_now() is True
+                assert card._now > now
+                assert card._current_interval == 30
+
+    def test_show(self):
+        card = self._dummy_card()
+        card._now = datetime.datetime.now()
+
+        card.show()
+        assert card._now is None
+
+    def test_tick_redraw(self):
+        now = datetime.datetime.now()
+
+        with mock.patch.object(app_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card = self._dummy_card()
+            card.initialize()
+
+            card._now = now
+            card._surface = mock.Mock(spec=pygame.surface.Surface)
+            card._update_now = mock.Mock(return_value=True)
+
+            time_surface = mock.Mock(spec=pygame.surface.Surface)
+            time_surface.get_size = mock.Mock(return_value=(120, 80))
+            card._render_time = mock.Mock(return_value=time_surface)
+
+            date_surface = mock.Mock(spec=pygame.surface.Surface)
+            date_surface.get_size = mock.Mock(return_value=(200, 60))
+            card._render_date = mock.Mock(return_value=date_surface)
+
+            card.tick()
+            assert card._update_now.called
+            card._render_time.assert_called_with(now)
+            card._render_date.assert_called_with(now)
+
+            assert time_surface.get_size.called
+            assert date_surface.get_size.called
+
+            card.surface.fill.assert_called_with(card.background_color)
+            card.surface.blit.assert_any_call(
+                time_surface, (100, 50, 120, 80)
+            )
+            card.surface.blit.assert_any_call(
+                date_surface, (60, 130, 200, 60)
+            )
+
+    def test_tick_dont_redraw(self):
+        with mock.patch.object(app_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card = self._dummy_card()
+            card.initialize()
+
+            card._surface = mock.Mock(spec=pygame.surface.Surface)
+            card._update_now = mock.Mock(return_value=False)
+
+            card._render_time = mock.Mock()
+            card._render_date = mock.Mock()
+
+            card.tick()
+
+            assert card._update_now.called
+
+            assert card._render_time.called is False
+            assert card._render_date.called is False
+
+            assert card.surface.fill.called is False
+            assert card.surface.blit.called is False

tests/test_picture_card.py

@@ -0,0 +1,266 @@
+# -*- coding: utf-8 -*-
+
+import cStringIO
+
+import mock
+import pygame
+import requests
+
+from pie_time.application import PieTime
+from pie_time.cards import picture as card_module
+from pie_time.cards import PictureCard
+
+
+class Test_PictureCard(object):
+    def _dummy_card(self, **settings):
+        app = PieTime(None, screen_size=(320, 240))
+        app.screen = mock.Mock(spec=pygame.surface.Surface)
+        app._logger = mock.Mock()
+
+        app.path_for_resource = mock.Mock(
+            side_effect=lambda resource: resource
+        )
+
+        card = PictureCard()
+        card.set_app(app)
+        card.set_settings(settings)
+
+        return card
+
+    def _dummy_initialized_card(self, **settings):
+        card = self._dummy_card(**settings)
+        card._load_picture = mock.Mock(
+            side_effect=lambda x: mock.Mock(spec=pygame.surface.Surface)
+        )
+
+        card.initialize()
+        return card
+
+    def test_initialize(self):
+        urls = ['spam', 'eggs']
+
+        card = self._dummy_card(urls=urls)
+        card._load_picture = mock.Mock()
+
+        card.initialize()
+        assert len(card._pictures) == len(urls)
+        assert card._current_picture_idx is None
+
+        assert card._load_picture.call_count == len(urls)
+        card._load_picture.assert_any_call(urls[0])
+        card._load_picture.assert_any_call(urls[1])
+
+    def test_load_picture_file(self):
+        fake_image = mock.Mock(spec=pygame.surface.Surface)
+
+        with mock.patch.object(card_module.pygame.image, 'load',
+                               return_value=fake_image):
+            card = self._dummy_card()
+            result = card._load_picture('file:///spam')
+            assert result == fake_image
+
+            card_module.pygame.image.load.assert_called_with('/spam')
+
+    def test_load_picture_file_load_error(self):
+        with mock.patch.object(card_module.pygame.image, 'load',
+                               side_effect=RuntimeError('ERROR')):
+            card = self._dummy_card()
+            result = card._load_picture('file:///spam')
+            assert result is None
+
+    def test_load_picture_net(self):
+        fake_image = mock.Mock(spec=pygame.surface.Surface)
+
+        fake_response = mock.Mock(spec=requests.Response)
+        fake_response.status_code = 200
+        fake_response.headers = {'Content-Type': ''}
+        fake_response.content = 'HERE IMAGE DATA BE'
+
+        fake_stringio = mock.Mock(spec=cStringIO.StringIO)
+
+        with mock.patch.object(card_module.pygame.image, 'load',
+                               return_value=fake_image):
+            with mock.patch.object(card_module.requests, 'get',
+                                   return_value=fake_response):
+                with mock.patch.object(card_module.cStringIO, 'StringIO',
+                                return_value=fake_stringio):
+                    url = 'http://spam.com/eggs'
+                    card = self._dummy_card()
+
+                    result = card._load_picture(url)
+                    assert result == fake_image
+
+                    card_module.requests.get.assert_called_with(url)
+
+                    card_module.cStringIO.StringIO.assert_called_with(
+                        fake_response.content
+                    )
+
+                    card_module.pygame.image.load.assert_called_with(
+                        fake_stringio, 'picture.'
+                    )
+
+    def test_load_picture_net_requests_error(self):
+        def _get(*args, **kwargs):
+            raise RuntimeError('ERROR')
+
+        new_get = mock.Mock(side_effect=_get)
+
+        with mock.patch.object(card_module.requests, 'get',
+                               side_effect=RuntimeError('TODO')):
+            url = 'http://spam.com/eggs'
+            card = self._dummy_card()
+
+            result = card._load_picture(url)
+            assert result is None
+
+    def test_load_picture_net_bad_response(self):
+        fake_response = mock.Mock(spec=requests.Response)
+        fake_response.status_code = 404
+
+        with mock.patch.object(card_module.requests, 'get',
+                               return_value=fake_response):
+            url = 'http://spam.com/eggs'
+            card = self._dummy_card()
+
+            result = card._load_picture(url)
+            assert result is None
+
+    def test_load_picture_net_load_error(self):
+        fake_response = mock.Mock(spec=requests.Response)
+        fake_response.status_code = 200
+        fake_response.headers = {'Content-Type': ''}
+        fake_response.content = 'HERE IMAGE DATA BE'
+
+        with mock.patch.object(card_module.pygame.image, 'load',
+                               side_effect=RuntimeError('ERROR')):
+            with mock.patch.object(card_module.requests, 'get',
+                                   return_value=fake_response):
+                url = 'http://spam.com/eggs'
+                card = self._dummy_card()
+
+                result = card._load_picture(url)
+                assert result is None
+
+    def test_load_picture_convert(self):
+        fake_image = mock.Mock(spec=pygame.surface.Surface)
+        fake_image.convert = mock.Mock(return_value=fake_image)
+
+        with mock.patch.object(card_module.pygame.image, 'load',
+                               return_value=fake_image):
+            card = self._dummy_card()
+            result = card._load_picture('file:///spam.jpg')
+            assert result == fake_image
+
+            fake_image.convert.assert_called_with(card._app.screen)
+
+    def test_load_picture_convert_alpha(self):
+        fake_image = mock.Mock(spec=pygame.surface.Surface)
+        fake_image.convert_alpha = mock.Mock(return_value=fake_image)
+
+        with mock.patch.object(card_module.pygame.image, 'load',
+                               return_value=fake_image):
+            card = self._dummy_card()
+            result = card._load_picture('file:///spam.png')
+            assert result == fake_image
+
+            fake_image.convert_alpha.assert_called_with(card._app.screen)
+
+    def test_show_no_pictures(self):
+        card = self._dummy_initialized_card(urls=[])
+        card.show()
+        assert card._current_picture_idx is None
+        assert card._should_redraw is True
+
+    def test_show_one_picture(self):
+        card = self._dummy_initialized_card(urls=['http://spam.com/eggs.png'])
+
+        card.show()
+        assert card._current_picture_idx == 0
+        assert card._should_redraw is True
+
+        card.show()
+        assert card._current_picture_idx == 0
+        assert card._should_redraw is True
+
+    def test_show_many_pictures(self):
+        card = self._dummy_initialized_card(
+            urls=[
+                'http://spam.com/eggs.png', 'http://spam.com/spam.png',
+                'http://spam.com/spameggs.png'
+            ]
+        )
+
+        card.show()
+        assert card._current_picture_idx == 0
+        assert card._should_redraw is True
+
+        card.show()
+        assert card._current_picture_idx == 1
+        assert card._should_redraw is True
+
+        card.show()
+        assert card._current_picture_idx == 2
+        assert card._should_redraw is True
+
+        card.show()
+        assert card._current_picture_idx == 0
+        assert card._should_redraw is True
+
+    def test_tick_no_pictures(self):
+        card = self._dummy_initialized_card(urls=[])
+        card._surface = mock.Mock(spec=pygame.surface.Surface)
+        card.show()
+
+        card.tick()
+        assert card._should_redraw is False
+
+        card.surface.fill.assert_called_with(card.background_color)
+
+    def test_tick_with_pictures(self):
+        card = self._dummy_initialized_card(
+            urls=['http://spam.com/eggs.png', 'http://spam.com/eggs.png']
+        )
+
+        card._surface = mock.Mock(spec=pygame.surface.Surface)
+
+        card._pictures[0].get_size = mock.Mock(return_value=(320, 240))
+        card._pictures[0].get_rect = mock.Mock(
+            return_value=(0, 0, 320, 240)
+        )
+
+        card._pictures[1].get_size = mock.Mock(return_value=(240, 180))
+        card._pictures[1].get_rect = mock.Mock(
+            return_value=(0, 0, 240, 180)
+        )
+
+        card.show()
+        card.tick()
+        assert card._should_redraw is False
+        card.surface.fill.assert_called_with(card.background_color)
+        card.surface.blit.assert_called_with(
+            card._pictures[0], (0, 0, 320, 240)
+        )
+
+        card.show()
+        card.tick()
+        assert card._should_redraw is False
+        card.surface.fill.assert_called_with(card.background_color)
+        card.surface.blit.assert_called_with(
+            card._pictures[1], (40, 30, 240, 180)
+        )
+
+    def test_tick_dont_redraw(self):
+        card = self._dummy_initialized_card(
+            urls=['http://spam.com/eggs.png', 'http://spam.com/eggs.png']
+        )
+
+        card._surface = mock.Mock(spec=pygame.surface.Surface)
+        card.show()
+        card._should_redraw = False
+
+        card.tick()
+        assert card._should_redraw is False
+
+        assert card.surface.fill.called is False
+        assert card.surface.blit.called is False

tests/test_weather_card.py

@@ -0,0 +1,697 @@
+# -*- coding: utf-8 -*-
+
+import threading
+
+import mock
+import pygame
+import requests
+
+from pie_time.application import PieTime
+from pie_time.cards import weather as card_module
+
+
+class Test_WeatherCard(object):
+    def _dummy_card(self, city='Wroclaw,PL', api_key='API key', **settings):
+        app = PieTime(None, screen_size=(320, 240))
+        app._logger = mock.Mock()
+        app.path_for_resource = mock.Mock(
+            side_effect=lambda resource: resource
+        )
+        card = card_module.WeatherCard()
+        card.set_app(app)
+
+        if city:
+            settings['city'] = city
+
+        if api_key:
+            settings['api_key'] = api_key
+
+        card.set_settings(settings)
+
+        return card
+
+    def _ok_payload(self):
+        return {
+            "base": "cmc stations",
+            "clouds": {
+                "all": 20
+            },
+            "cod": 200,
+            "coord": {
+                "lat": 51.1,
+                "lon": 17.03
+            },
+            "dt": 1413815400,
+            "id": 3081368,
+            "main": {
+                "humidity": 59,
+                "pressure": 1013,
+                "temp": 17,
+                "temp_max": 17,
+                "temp_min": 17
+            },
+            "name": "Wroclaw",
+            "sys": {
+                "country": "PL",
+                "id": 5375,
+                "message": 0.1316,
+                "sunrise": 1413782666,
+                "sunset": 1413820124,
+                "type": 1
+            },
+            "weather": [
+                {
+                    "description": "few clouds",
+                    "icon": "02d",
+                    "id": 801,
+                    "main": "Clouds"
+                }
+            ],
+            "wind": {
+                "deg": 280,
+                "speed": 6.2
+            }
+        }
+
+    def test_initialize_no_city(self):
+        card = self._dummy_card(city=None)
+
+        try:
+            card.initialize()
+        except Exception as exc:
+            assert isinstance(exc, AssertionError)
+            assert exc.args[0] == 'Configuration error: missing city'
+        else:
+            assert False, 'Nothing was raised :('
+
+    def test_initialize_no_api_key(self):
+        card = self._dummy_card(api_key=None)
+
+        try:
+            card.initialize()
+        except Exception as exc:
+            assert isinstance(exc, AssertionError)
+            assert exc.args[0] == 'Configuration error: missing API key'
+        else:
+            assert False, 'Nothing was raised :('
+
+    def test_initialize(self):
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card = self._dummy_card()
+            card._refresh_conditions = mock.Mock()
+
+            card.initialize()
+
+            assert card._text_font is not None
+            assert card._temp_font is not None
+            assert card._icon_font is not None
+            assert card._timer is None
+            assert card._current_conditions is None
+            assert card._refresh_conditions.called
+
+    def test_refresh_conditions_requests_error(self):
+        fake_timer = mock.Mock(spec=threading.Timer)
+        fake_timer.start = mock.Mock()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            with mock.patch.object(card_module.requests, 'get',
+                                   side_effect=RuntimeError('TODO')):
+                with mock.patch.object(card_module, 'Timer',
+                                       return_value=fake_timer):
+                    card = self._dummy_card()
+                    card.initialize(refresh=False)
+                    card._refresh_conditions()
+
+                    assert card_module.requests.get.called
+                    assert card._current_conditions is None
+
+                    assert card._timer is not None
+                    card_module.Timer.assert_called_with(
+                        card.REFRESH_INTERVAL, card._refresh_conditions
+                    )
+                    assert card._timer.start.called
+
+    def test_refresh_conditions_bad_status_code(self):
+        fake_response = mock.Mock(spec=requests.Response)
+        fake_response.status_code = 404
+
+        fake_timer = mock.Mock(spec=threading.Timer)
+        fake_timer.start = mock.Mock()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            with mock.patch.object(card_module.requests, 'get',
+                                   return_value=fake_response):
+                with mock.patch.object(card_module, 'Timer',
+                                       return_value=fake_timer):
+                    card = self._dummy_card()
+                    card.initialize(refresh=False)
+                    card._refresh_conditions()
+
+                    assert card_module.requests.get.called
+                    assert card._current_conditions is None
+
+                    assert card._timer is not None
+                    card_module.Timer.assert_called_with(
+                        card.REFRESH_INTERVAL, card._refresh_conditions
+                    )
+                    assert card._timer.start.called
+
+    def test_refresh_conditions_missing_weather_object(self):
+        payload = self._ok_payload()
+        payload['weather'] = []
+
+        fake_response = mock.Mock(spec=requests.Response)
+        fake_response.json = mock.Mock(return_value=payload)
+        fake_response.status_code = 200
+
+        fake_timer = mock.Mock(spec=threading.Timer)
+        fake_timer.start = mock.Mock()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            with mock.patch.object(card_module.requests, 'get',
+                                   return_value=fake_response):
+                with mock.patch.object(card_module, 'Timer',
+                                       return_value=fake_timer):
+                    card = self._dummy_card()
+                    card.initialize(refresh=False)
+                    card._refresh_conditions()
+
+                    assert card_module.requests.get.called
+                    assert card._current_conditions is None
+
+                    assert card._timer is not None
+                    card_module.Timer.assert_called_with(
+                        card.REFRESH_INTERVAL, card._refresh_conditions
+                    )
+                    assert card._timer.start.called
+
+    def test_refresh_conditions_missing_conditions(self):
+        payload = self._ok_payload()
+        payload['weather'][0].pop('main')
+
+        fake_response = mock.Mock(spec=requests.Response)
+        fake_response.json = mock.Mock(return_value=payload)
+        fake_response.status_code = 200
+
+        fake_timer = mock.Mock(spec=threading.Timer)
+        fake_timer.start = mock.Mock()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            with mock.patch.object(card_module.requests, 'get',
+                                   return_value=fake_response):
+                with mock.patch.object(card_module, 'Timer',
+                                       return_value=fake_timer):
+                    card = self._dummy_card()
+                    card.initialize(refresh=False)
+                    card._refresh_conditions()
+
+                    assert card_module.requests.get.called
+                    assert card._current_conditions is None
+
+                    assert card._timer is not None
+                    card_module.Timer.assert_called_with(
+                        card.REFRESH_INTERVAL, card._refresh_conditions
+                    )
+                    assert card._timer.start.called
+
+    def test_refresh_conditions_missing_temp(self):
+        payload = self._ok_payload()
+        payload['main'].pop('temp')
+
+        fake_response = mock.Mock(spec=requests.Response)
+        fake_response.json = mock.Mock(return_value=payload)
+        fake_response.status_code = 200
+
+        fake_timer = mock.Mock(spec=threading.Timer)
+        fake_timer.start = mock.Mock()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            with mock.patch.object(card_module.requests, 'get',
+                                   return_value=fake_response):
+                with mock.patch.object(card_module, 'Timer',
+                                       return_value=fake_timer):
+                    card = self._dummy_card()
+                    card.initialize(refresh=False)
+                    card._refresh_conditions()
+
+                    assert card_module.requests.get.called
+                    assert card._current_conditions is None
+
+                    assert card._timer is not None
+                    card_module.Timer.assert_called_with(
+                        card.REFRESH_INTERVAL, card._refresh_conditions
+                    )
+                    assert card._timer.start.called
+
+    def test_refresh_conditions(self):
+        payload = self._ok_payload()
+
+        fake_response = mock.Mock(spec=requests.Response)
+        fake_response.json = mock.Mock(return_value=payload)
+        fake_response.status_code = 200
+
+        fake_timer = mock.Mock(spec=threading.Timer)
+        fake_timer.start = mock.Mock()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            with mock.patch.object(card_module.requests, 'get',
+                                   return_value=fake_response):
+                with mock.patch.object(card_module, 'Timer',
+                                       return_value=fake_timer):
+                    card = self._dummy_card()
+                    card.initialize(refresh=False)
+                    card._refresh_conditions()
+
+                    assert card_module.requests.get.called
+                    assert card._current_conditions == {
+                        'conditions': payload['weather'][0]['main'],
+                        'icon': payload['weather'][0]['icon'],
+                        'temperature': payload['main']['temp'],
+                    }
+
+                    assert card._timer is not None
+                    card_module.Timer.assert_called_with(
+                        card.REFRESH_INTERVAL, card._refresh_conditions
+                    )
+                    assert card._timer.start.called
+
+    def test_refresh_conditions_no_icon(self):
+        payload = self._ok_payload()
+        payload['weather'][0].pop('icon')
+
+        fake_response = mock.Mock(spec=requests.Response)
+        fake_response.json = mock.Mock(return_value=payload)
+        fake_response.status_code = 200
+
+        fake_timer = mock.Mock(spec=threading.Timer)
+        fake_timer.start = mock.Mock()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            with mock.patch.object(card_module.requests, 'get',
+                                   return_value=fake_response):
+                with mock.patch.object(card_module, 'Timer',
+                                       return_value=fake_timer):
+                    card = self._dummy_card()
+                    card.initialize(refresh=False)
+                    card._refresh_conditions()
+
+                    assert card_module.requests.get.called
+                    assert card._current_conditions == {
+                        'conditions': payload['weather'][0]['main'],
+                        'icon': None,
+                        'temperature': payload['main']['temp'],
+                    }
+
+                    assert card._timer is not None
+                    card_module.Timer.assert_called_with(
+                        card.REFRESH_INTERVAL, card._refresh_conditions
+                    )
+                    assert card._timer.start.called
+
+    def test_render_city(self):
+        card = self._dummy_card()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+
+            card._text_font.render = mock.Mock(
+                return_value=mock.Mock(spec=pygame.surface.Surface)
+            )
+
+            surface = card._render_city()
+
+            card._text_font.render.assert_called_with(
+                card._settings['city'], True, card.WHITE
+            )
+            assert isinstance(surface, pygame.surface.Surface)
+
+    def test_render_city_override_color(self):
+        card = self._dummy_card(city_color=(255, 0, 0))
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+
+            card._text_font.render = mock.Mock(
+                return_value=mock.Mock(spec=pygame.surface.Surface)
+            )
+
+            surface = card._render_city()
+
+            card._text_font.render.assert_called_with(
+                card._settings['city'], True, (255, 0, 0)
+            )
+            assert isinstance(surface, pygame.surface.Surface)
+
+    def test_render_conditions(self):
+        card = self._dummy_card()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            card._current_conditions = {
+                'conditions': 'clouds'
+            }
+
+            card._text_font.render = mock.Mock(
+                return_value=mock.Mock(spec=pygame.surface.Surface)
+            )
+
+            surface = card._render_conditions()
+
+            card._text_font.render.assert_called_with(
+                'Clouds', True, card.WHITE
+            )
+            assert isinstance(surface, pygame.surface.Surface)
+
+    def test_render_conditions_override_color(self):
+        card = self._dummy_card(conditions_color=(255, 0, 0))
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            card._current_conditions = {
+                'conditions': 'clouds'
+            }
+
+            card._text_font.render = mock.Mock(
+                return_value=mock.Mock(spec=pygame.surface.Surface)
+            )
+
+            surface = card._render_conditions()
+
+            card._text_font.render.assert_called_with(
+                'Clouds', True, (255, 0, 0)
+            )
+            assert isinstance(surface, pygame.surface.Surface)
+
+    def test_render_icon(self):
+        card = self._dummy_card()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            icon_code = '01d'
+            card._current_conditions = {'icon': icon_code}
+
+            card._text_font.render = mock.Mock(
+                return_value=mock.Mock(spec=pygame.surface.Surface)
+            )
+
+            surface = card._render_icon()
+
+            card._icon_font.render.assert_called_with(
+                card.WEATHER_CODE_TO_ICON[icon_code], True, card.WHITE
+            )
+            assert isinstance(surface, pygame.surface.Surface)
+
+    def test_render_icon_override_color(self):
+        card = self._dummy_card(icon_color=(255, 0, 0))
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            icon_code = '01d'
+            card._current_conditions = {'icon': icon_code}
+
+            card._text_font.render = mock.Mock(
+                return_value=mock.Mock(spec=pygame.surface.Surface)
+            )
+
+            surface = card._render_icon()
+
+            card._icon_font.render.assert_called_with(
+                card.WEATHER_CODE_TO_ICON[icon_code], True, (255, 0, 0)
+            )
+            assert isinstance(surface, pygame.surface.Surface)
+
+    def test_render_icon_no_icon(self):
+        card = self._dummy_card()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            icon_code = None
+            card._current_conditions = {'icon': icon_code}
+
+            card._text_font.render = mock.Mock(
+                return_value=mock.Mock(spec=pygame.surface.Surface)
+            )
+
+            surface = card._render_icon()
+
+            assert card._icon_font.render.called is False
+            assert surface is None
+
+    def test_render_icon_unknown_icon(self):
+        card = self._dummy_card()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            icon_code = 'spam'
+            card._current_conditions = {'icon': icon_code}
+
+            card._text_font.render = mock.Mock(
+                return_value=mock.Mock(spec=pygame.surface.Surface)
+            )
+
+            surface = card._render_icon()
+
+            assert card._icon_font.render.called is False
+            assert surface is None
+
+    def test_render_temperature(self):
+        card = self._dummy_card()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            card._current_conditions = {
+                'temperature': 17
+            }
+
+            card._text_font.render = mock.Mock(
+                return_value=mock.Mock(spec=pygame.surface.Surface)
+            )
+
+            surface = card._render_temperature()
+
+            card._text_font.render.assert_called_with(
+                u'17°', True, card.WHITE
+            )
+            assert isinstance(surface, pygame.surface.Surface)
+
+    def test_render_temperature_override_color(self):
+        card = self._dummy_card(temperature_color=(255, 0, 0))
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            card._current_conditions = {
+                'temperature': 17
+            }
+
+            card._text_font.render = mock.Mock(
+                return_value=mock.Mock(spec=pygame.surface.Surface)
+            )
+
+            surface = card._render_temperature()
+
+            card._text_font.render.assert_called_with(
+                u'17°', True, (255, 0, 0)
+            )
+            assert isinstance(surface, pygame.surface.Surface)
+
+    def test_quit(self):
+        card = self._dummy_card()
+        card._timer = None
+        card.quit()
+
+        card = self._dummy_card()
+        card._timer = mock.Mock(spec=threading.Timer)
+        card._timer.cancel = mock.Mock()
+
+        card.quit()
+        assert card._timer.cancel.called
+
+    def test_tick_redraw(self):
+        card = self._dummy_card()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            card._current_conditions = {
+                'conditions': 'Clouds',
+                'icon': '01d',
+                'temperature': 17
+            }
+
+            card._surface = mock.Mock(spec=pygame.surface.Surface)
+
+            city_surface = mock.Mock(spec=pygame.surface.Surface)
+            city_surface.get_size = mock.Mock(return_value=(120, 40))
+            card._render_city = mock.Mock(return_value=city_surface)
+
+            conditions_surface = mock.Mock(spec=pygame.surface.Surface)
+            conditions_surface.get_size = mock.Mock(return_value=(200, 40))
+            card._render_conditions = mock.Mock(
+                return_value=conditions_surface
+            )
+
+            icon_surface = mock.Mock(spec=pygame.surface.Surface)
+            icon_surface.get_size = mock.Mock(return_value=(128, 128))
+            card._render_icon = mock.Mock(return_value=icon_surface)
+
+            temperature_surface = mock.Mock(spec=pygame.surface.Surface)
+            temperature_surface.get_size = mock.Mock(return_value=(100, 82))
+            card._render_temperature = mock.Mock(
+                return_value=temperature_surface
+            )
+
+            card.tick()
+
+            card.surface.blit.assert_any_call(
+                city_surface, (100, 0, 120, 40)
+            )
+
+            card.surface.blit.assert_any_call(
+                conditions_surface, (60, 200, 200, 40)
+            )
+
+            card.surface.blit.assert_any_call(
+                icon_surface, (34, 56, 128, 128)
+            )
+
+            card.surface.blit.assert_any_call(
+                temperature_surface, (186, 79, 100, 82)
+            )
+
+            assert card._should_redraw is False
+
+    def test_tick_dont_redraw(self):
+        card = self._dummy_card()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            card._should_redraw = False
+
+            card._surface = mock.Mock(spec=pygame.surface.Surface)
+
+            city_surface = mock.Mock(spec=pygame.surface.Surface)
+            city_surface.get_size = mock.Mock(return_value=(120, 40))
+            card._render_city = mock.Mock(return_value=city_surface)
+
+            conditions_surface = mock.Mock(spec=pygame.surface.Surface)
+            conditions_surface.get_size = mock.Mock(return_value=(200, 40))
+            card._render_conditions = mock.Mock(
+                return_value=conditions_surface
+            )
+
+            icon_surface = mock.Mock(spec=pygame.surface.Surface)
+            icon_surface.get_size = mock.Mock(return_value=(128, 128))
+            card._render_icon = mock.Mock(return_value=icon_surface)
+
+            temperature_surface = mock.Mock(spec=pygame.surface.Surface)
+            temperature_surface.get_size = mock.Mock(return_value=(100, 82))
+            card._render_temperature = mock.Mock(
+                return_value=temperature_surface
+            )
+
+            card.tick()
+
+            assert card._render_city.called is False
+            assert card._render_conditions.called is False
+            assert card._render_icon.called is False
+            assert card._render_temperature.called is False
+            assert card.surface.blit.called is False
+
+            assert card._should_redraw is False
+
+    def test_tick_without_icon(self):
+        card = self._dummy_card()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+            card._current_conditions = {
+                'conditions': 'Clouds',
+                'icon': '01d',
+                'temperature': 17
+            }
+
+            card._surface = mock.Mock(spec=pygame.surface.Surface)
+
+            city_surface = mock.Mock(spec=pygame.surface.Surface)
+            city_surface.get_size = mock.Mock(return_value=(120, 40))
+            card._render_city = mock.Mock(return_value=city_surface)
+
+            conditions_surface = mock.Mock(spec=pygame.surface.Surface)
+            conditions_surface.get_size = mock.Mock(return_value=(200, 40))
+            card._render_conditions = mock.Mock(
+                return_value=conditions_surface
+            )
+
+            card._render_icon = mock.Mock(return_value=None)
+
+            temperature_surface = mock.Mock(spec=pygame.surface.Surface)
+            temperature_surface.get_size = mock.Mock(return_value=(100, 82))
+            card._render_temperature = mock.Mock(
+                return_value=temperature_surface
+            )
+
+            card.tick()
+
+            card.surface.blit.assert_any_call(
+                city_surface, (100, 0, 120, 40)
+            )
+
+            card.surface.blit.assert_any_call(
+                conditions_surface, (60, 200, 200, 40)
+            )
+
+            card.surface.blit.assert_any_call(
+                temperature_surface, (110, 79, 100, 82)
+            )
+
+            assert card._should_redraw is False
+
+    def test_tick_without_conditions(self):
+        card = self._dummy_card()
+
+        with mock.patch.object(card_module.pygame.font, 'Font',
+                               spec=pygame.font.Font):
+            card.initialize(refresh=False)
+
+            card._surface = mock.Mock(spec=pygame.surface.Surface)
+
+            city_surface = mock.Mock(spec=pygame.surface.Surface)
+            city_surface.get_size = mock.Mock(return_value=(120, 40))
+            card._render_city = mock.Mock(return_value=city_surface)
+
+            card._render_conditions = mock.Mock()
+            card._render_icon = mock.Mock()
+            card._render_temperature = mock.Mock()
+
+            card.tick()
+
+            assert card.surface.blit.call_count == 1
+            card.surface.blit.assert_called_with(
+                city_surface, (100, 0, 120, 40)
+            )
+
+            assert card._render_conditions.called is False
+            assert card._render_icon.called is False
+            assert card._render_temperature.called is False
+
+            assert card._should_redraw is False