Beispiel #1
0
  def testBadEvent(self):
    event, cert = _CreateEventAndCert()
    # Create an event with no expands.
    broken_event = bit9_test_utils.CreateEvent()

    self._AppendMockApiResults([event, broken_event], cert)
    self.Patch(time_utils, 'TimeRemains', side_effect=[True, True, False])

    sync.Pull()

    events = (sync._UnsyncedEvent.query()
              .order(sync._UnsyncedEvent.bit9_id)
              .fetch())
    self.assertEqual(1, len(events))
    self.assertEqual(event._obj_dict, events[0].event)
Beispiel #2
0
  def testBadEvent(self):
    event, signing_chain = _CreateEventTuple(id=100)
    # Create an event with no expands.
    broken_event = bit9_test_utils.CreateEvent()

    self._PatchGetEvents([(event, signing_chain), (broken_event, None)])
    self.Patch(time_utils, 'TimeRemains', side_effect=[True, True, False])

    sync.Pull()

    events = (sync._UnsyncedEvent.query()
              .order(sync._UnsyncedEvent.bit9_id)
              .fetch())
    self.assertEqual(1, len(events))
    self.assertEqual(event._obj_dict, events[0].event)
Beispiel #3
0
  def testOrder(self):
    event_1, cert_1 = _CreateEventAndCert()
    event_2, cert_2 = _CreateEventAndCert()

    self._AppendMockApiResults([event_1], cert_1, [event_2], cert_2)
    self.Patch(time_utils, 'TimeRemains', side_effect=[True, True, False])

    sync.Pull(batch_size=1)

    events = (sync._UnsyncedEvent.query()
              .order(sync._UnsyncedEvent.bit9_id)
              .fetch())
    self.assertEqual(2, len(events))
    self.assertEqual(event_1._obj_dict, events[0].event)
    self.assertEqual(event_2._obj_dict, events[1].event)
    self.assertEqual(2, self.mock_events_pulled.IncrementBy.call_count)
Beispiel #4
0
  def testOrder(self):
    event1, signing_chain1 = _CreateEventTuple(id=100)
    event2, signing_chain2 = _CreateEventTuple(id=200)

    self._PatchGetEvents([(event1, signing_chain1)], [(event2, signing_chain2)])
    self.Patch(time_utils, 'TimeRemains', side_effect=[True, True, False])

    sync.Pull(batch_size=1)

    events = (sync._UnsyncedEvent.query()
              .order(sync._UnsyncedEvent.bit9_id)
              .fetch())
    self.assertEqual(2, len(events))
    self.assertEqual(event1._obj_dict, events[0].event)
    self.assertEqual(event2._obj_dict, events[1].event)
    self.assertEqual(2, self.mock_events_pulled.IncrementBy.call_count)
Beispiel #5
0
  def testMultiple(self):

    batch_count = 3
    events_per_batch = 5

    for _ in xrange(batch_count):
      events, certs = _CreateEventsAndCerts(count=events_per_batch)
      self._AppendMockApiResults(events, *certs)

    self.Patch(time_utils, 'TimeRemains', side_effect=[True, True, True, False])

    sync.Pull(batch_size=events_per_batch)

    self.assertEntityCount(sync._UnsyncedEvent, batch_count * events_per_batch)
    self.assertEqual(
        batch_count, self.mock_events_pulled.IncrementBy.call_count)

    self.assertTaskCount(constants.TASK_QUEUE.BIT9_PULL, 0)
Beispiel #6
0
  def testMultiple(self):
    batch_count = 3
    events_per_batch = 5
    batches = []
    for batch_num in xrange(batch_count):
      batches.append([
          _CreateEventTuple(id=batch_num * events_per_batch + event_num)
          for event_num in xrange(events_per_batch)])
    self._PatchGetEvents(*batches)
    self.Patch(time_utils, 'TimeRemains', side_effect=[True, True, True, False])

    sync.Pull(batch_size=events_per_batch)

    self.assertEntityCount(sync._UnsyncedEvent, batch_count * events_per_batch)
    self.assertEqual(batch_count,
                     self.mock_events_pulled.IncrementBy.call_count)

    self.assertTaskCount(constants.TASK_QUEUE.BIT9_PULL, 0)