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.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_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.leaderboards = MagicMock(return_value="data")

    result = r.leaderboards("foo")

    self.assertEqual(result, "data")
    r._store.leaderboards.assert_called_once_with("foo")
    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_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_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_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.channel = MagicMock(return_value="data")

    result = r.channel("channel")

    self.assertEqual(result, "data")
    r._store.channel.assert_called_once_with("channel")
    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_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)
Example #15
0
    def record(self):
        # summaries are written to the database
        if not self.storage:
            from twitchcancer.storage.writeonlystorage import WriteOnlyStorage
            self.storage = WriteOnlyStorage()

        self.storage.record()
Example #16
0
  def store(self, channel, cancer):
    # messages are stored in-memory only
    if not self.storage:
      from twitchcancer.storage.memorystorage import MemoryStorage
      self.storage = MemoryStorage()

    self.storage.store(channel, cancer)
Example #17
0
  def record(self):
    # summaries are written to the database
    if not self.storage:
      from twitchcancer.storage.writeonlystorage import WriteOnlyStorage
      self.storage = WriteOnlyStorage()

    self.storage.record()
Example #18
0
    def store(self, channel, cancer):
        # messages are stored in-memory only
        if not self.storage:
            from twitchcancer.storage.memorystorage import MemoryStorage
            self.storage = MemoryStorage()

        self.storage.store(channel, cancer)
Example #19
0
  def leaderboard(self, name):
    if not self.storage:
      from twitchcancer.storage.readonlystorage import ReadOnlyStorage
      self.storage = ReadOnlyStorage()

    return self.storage.leaderboard(name)
    def test_not_implemented(self, init):
        r = ReadOnlyStorage()

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

        return self.storage.status()
Example #22
0
    def leaderboard(self, name):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.leaderboard(name)
  def test_not_implemented(self, init):
    r = ReadOnlyStorage()

    self.assertRaises(NotImplementedError, lambda: r.record())
    self.assertRaises(NotImplementedError, lambda: r.store(None, None))
Example #24
0
    def channel(self, channel):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.channel(channel)
Example #25
0
  def status(self):
    if not self.storage:
      from twitchcancer.storage.readonlystorage import ReadOnlyStorage
      self.storage = ReadOnlyStorage()

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

    return self.storage.channel(channel)
Example #27
0
  def leaderboards(self, horizon):
    if not self.storage:
      from twitchcancer.storage.readonlystorage import ReadOnlyStorage
      self.storage = ReadOnlyStorage()

    return self.storage.leaderboards(horizon)
Example #28
0
    def leaderboards(self, horizon):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.leaderboards(horizon)
Example #29
0
class Storage(StorageInterface):

  def __init__(self):
    super().__init__()

    self.storage = None

  # defaults to ReadOnlyStorage
  def cancer(self):
    if not self.storage:
      from twitchcancer.storage.readonlystorage import ReadOnlyStorage
      self.storage = ReadOnlyStorage()

    return self.storage.cancer()

  # defaults to ReadOnlyStorage
  def leaderboards(self, horizon):
    if not self.storage:
      from twitchcancer.storage.readonlystorage import ReadOnlyStorage
      self.storage = ReadOnlyStorage()

    return self.storage.leaderboards(horizon)

  # defaults to ReadOnlyStorage
  def leaderboard(self, name):
    if not self.storage:
      from twitchcancer.storage.readonlystorage import ReadOnlyStorage
      self.storage = ReadOnlyStorage()

    return self.storage.leaderboard(name)

  # defaults to ReadOnlyStorage
  def channel(self, channel):
    if not self.storage:
      from twitchcancer.storage.readonlystorage import ReadOnlyStorage
      self.storage = ReadOnlyStorage()

    return self.storage.channel(channel)

  # defaults to ReadOnlyStorage
  def status(self):
    if not self.storage:
      from twitchcancer.storage.readonlystorage import ReadOnlyStorage
      self.storage = ReadOnlyStorage()

    return self.storage.status()

  # defaults to MemoryStorage
  def store(self, channel, cancer):
    # messages are stored in-memory only
    if not self.storage:
      from twitchcancer.storage.memorystorage import MemoryStorage
      self.storage = MemoryStorage()

    self.storage.store(channel, cancer)

  # defaults to WriteOnlyStorage
  def record(self):
    # summaries are written to the database
    if not self.storage:
      from twitchcancer.storage.writeonlystorage import WriteOnlyStorage
      self.storage = WriteOnlyStorage()

    self.storage.record()

  # defaults to ReadOnlyStorage
  def search(self, channel):
    if not self.storage:
      from twitchcancer.storage.readonlystorage import ReadOnlyStorage
      self.storage = ReadOnlyStorage()

    return self.storage.search(channel)
Example #30
0
class Storage(StorageInterface):

    def __init__(self):
        super().__init__()

        self.storage = None

    # defaults to ReadOnlyStorage
    def cancer(self):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.cancer()

    # defaults to ReadOnlyStorage
    def leaderboards(self, horizon):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.leaderboards(horizon)

    # defaults to ReadOnlyStorage
    def leaderboard(self, name):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.leaderboard(name)

    # defaults to ReadOnlyStorage
    def channel(self, channel):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.channel(channel)

    # defaults to ReadOnlyStorage
    def status(self):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.status()

    # defaults to MemoryStorage
    def store(self, channel, cancer):
        # messages are stored in-memory only
        if not self.storage:
            from twitchcancer.storage.memorystorage import MemoryStorage
            self.storage = MemoryStorage()

        self.storage.store(channel, cancer)

    # defaults to WriteOnlyStorage
    def record(self):
        # summaries are written to the database
        if not self.storage:
            from twitchcancer.storage.writeonlystorage import WriteOnlyStorage
            self.storage = WriteOnlyStorage()

        self.storage.record()

    # defaults to ReadOnlyStorage
    def search(self, channel):
        if not self.storage:
            from twitchcancer.storage.readonlystorage import ReadOnlyStorage
            self.storage = ReadOnlyStorage()

        return self.storage.search(channel)