def test_default(self, init):
        r = ReadOnlyStorage()
        r._store = MagicMock()
        r._store.status = MagicMock(return_value={
            'channels': 1,
            'messages': 2,
            'cancer': 3,
        })
        r.cancer = MagicMock(return_value=[
            {
                'messages': 1,
                'cancer': 2
            },
            {
                'messages': 3,
                'cancer': 4
            },
        ])

        expected = {
            'total': {
                'channels': 1,
                'messages': 2,
                'cancer': 3,
            },
            'live': {
                'channels': 2,
                'messages': 4,
                'cancer': 6,
            }
        }

        result = r.status()

        self.assertEqual(result, expected)
    def test_fail(self, cancer, init):
        r = ReadOnlyStorage()
        r._store = MagicMock()
        r._store.status = MagicMock(return_value={
            'channels': 1,
            'messages': 2,
            'cancer': 3,
        })

        expected = {
            'total': {
                'channels': 1,
                'messages': 2,
                'cancer': 3,
            },
            'live': {
                'channels': 0,
                'messages': 0,
                'cancer': 0,
            }
        }

        result = r.status()

        self.assertEqual(result, expected)
    def test_default(self, init):
        r = ReadOnlyStorage()
        r._store = MagicMock()
        r._store.channel = MagicMock(return_value="data")

        result = r.channel("channel")

        self.assertEqual(result, "data")
        r._store.channel.assert_called_once_with("channel")
    def test_default(self, init):
        r = ReadOnlyStorage()
        r._store = MagicMock()
        r._store.leaderboard = MagicMock(return_value="data")

        result = r.leaderboard("foo")

        self.assertEqual(result, "data")
        self.assertEqual(r._store.leaderboard.call_count, 1)
    def test_default(self, init):
        r = ReadOnlyStorage()
        r._store = MagicMock()
        r._store.leaderboards = MagicMock(return_value="data")

        result = r.leaderboards("foo")

        self.assertEqual(result, "data")
        r._store.leaderboards.assert_called_once_with("foo")
    def test_request(self, init):
        r = ReadOnlyStorage()
        r.socket = MagicMock()
        r.socket.recv_pyobj = MagicMock(return_value="data")
        r.poller = MagicMock()

        result = r.cancer()

        self.assertEqual(result, "data")
    def test_fail(self, connect, disconnect, init):
        r = ReadOnlyStorage()
        r.socket = MagicMock()
        r.poller = MagicMock()
        r.poller.poll = MagicMock(return_value=False)

        result = r.cancer()

        self.assertEqual(result, [])
        self.assertEqual(connect.call_count, 1)
        self.assertEqual(disconnect.call_count, 1)
    def test_not_implemented(self, init):
        r = ReadOnlyStorage()

        self.assertRaises(NotImplementedError, lambda: r.record())
        self.assertRaises(NotImplementedError, lambda: r.store(None, None))
示例#9
0
    def status(self):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.status()
示例#10
0
    def channel(self, channel):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.channel(channel)
示例#11
0
    def leaderboard(self, name):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.leaderboard(name)
示例#12
0
    def leaderboards(self, horizon):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.leaderboards(horizon)