class TestMaterials(TestCase):
fixtures = ['initial_data.yaml', '*']
def setUp(self):
self.material = Material()
self.material.save()
self.other_material = Material()
self.other_material.save()
self.stream = Stream()
self.stream.save()
def test_serialization(self):
material = u'(created: %s, modified: %s)' % (
unicode(self.material.created),
unicode(self.material.modified))
other_material = u'(created: %s, modified: %s)' % (
unicode(self.other_material.created),
unicode(self.other_material.modified))
# check if the __str__ method return the created and modified datetime.
self.assertEquals(str(self.material), str(material))
self.assertEquals(str(self.other_material), str(other_material))
# check if the __unicode__ method is defined to return the created and
# modified datetime.
self.assertEquals(unicode(self.material), material)
self.assertEquals(unicode(self.other_material), other_material)
def test_inject_into(self):
# check if the inject_into method create a new file_status.
material_status = self.material.inject_into(self.stream)
self.assertEquals(material_status.__class__, MaterialStatus)
# check if the new material_status has the same stream, the same
# material object and the unprocessed state.
self.assertEquals(material_status.stream, self.stream)
self.assertEquals(material_status.material, self.material)
self.assertEquals(material_status.status(), u'unprocessed')
def test_requiring_work(self):
# check if return all the streams with pending material statusese.
self.assertEquals(len(Stream.requiring_work()), 1)
self.assertEquals(Stream.requiring_work()[0], self.stream)
[ms.clone_for(self.other_stream) for ms in self.stream.materials.all()]
self.assertEquals(len(Stream.requiring_work()), 2)
self.assertEquals(Stream.requiring_work()[0], self.stream)
class TestPushs(TestCase):
fixtures = ['initial_data.yaml', '*']
def setUp(self):
self.stream = Stream()
self.stream.save()
self.pusher = Push.objects.get_or_create(name='abstract one')[0]
self.now = datetime.utcnow().replace(tzinfo=pytz.UTC)
self.pusher.streams.add(self.stream)
def test_setup_unloaded(self):
# check if create a thread for each unloaded pusher.
self.actives = threading.activeCount()
self.unloaded = [
i for i in Push.objects.all() if not hasattr(i, 'thread')
]
self.loaded = Push.setup_unloaded()
self.assertEquals(self.actives + len(self.unloaded),
threading.activeCount())
for i in self.loaded:
i.thread.cancel()
def test_should_adapt(self):
# check if should_adapt return false until the right time.
self.pusher.frequency = 10
delta = timedelta(seconds=self.pusher.frequency - 1)
self.pusher.previous = self.now - delta
self.assertFalse(self.pusher.should_adapt())
self.assertEquals(self.pusher.previous, self.now - delta)
# check if should_adapt return true after the right time.
delta = timedelta(seconds=self.pusher.frequency + 1)
self.pusher.previous = self.now - delta
self.assertTrue(self.pusher.should_adapt())
self.assertNotEquals(self.pusher.previous, self.now - delta)
class TestPushs(TestCase):
fixtures = ['initial_data.yaml', '*']
def setUp(self):
self.stream = Stream()
self.stream.save()
self.pusher = Push.objects.get_or_create(name='abstract one')[0]
self.now = datetime.utcnow().replace(tzinfo=pytz.UTC)
self.pusher.streams.add(self.stream)
def test_setup_unloaded(self):
# check if create a thread for each unloaded pusher.
self.actives = threading.activeCount()
self.unloaded = [i for i in Push.objects.all()
if not hasattr(i, 'thread')]
self.loaded = Push.setup_unloaded()
self.assertEquals(
self.actives + len(self.unloaded),
threading.activeCount())
for i in self.loaded:
i.thread.cancel()
def test_should_adapt(self):
# check if should_adapt return false until the right time.
self.pusher.frequency = 10
delta = timedelta(seconds=self.pusher.frequency - 1)
self.pusher.previous = self.now - delta
self.assertFalse(self.pusher.should_adapt())
self.assertEquals(self.pusher.previous, self.now - delta)
# check if should_adapt return true after the right time.
delta = timedelta(seconds=self.pusher.frequency + 1)
self.pusher.previous = self.now - delta
self.assertTrue(self.pusher.should_adapt())
self.assertNotEquals(self.pusher.previous, self.now - delta)
class TestAdapters(TestCase):
fixtures = ['initial_data.yaml', '*']
def setUp(self):
self.stream = Stream()
self.stream.save()
self.adapter = Adapt.objects.get_or_create(name='abstract one')[0]
self.adapter.streams.add(self.stream)
def test_update(self):
# check if the update method raise a "Subclass responsability"
# exception because the subclass should implement the method update.
with self.assertRaisesRegexp(Exception, u'Subclass responsability'):
self.adapter.update()
def test_should_adapt(self):
# by default an adapter should not adapt anything.
self.assertFalse(self.adapter.should_adapt())
def test_step(self):
# by default dont should execute the update.
self.assertEquals(self.adapter.step(), None)
# when a subclass should_adapt, it execute the update and raise
# the exception.
self.adapter.should_adapt = lambda: True
with self.assertRaisesRegexp(Exception, u'Subclass responsability'):
self.adapter.step()
def setUp(self):
self.stream = Stream()
self.stream.save()
self.second_stream = Stream()
self.second_stream.save()
self.material = Material()
self.material.save()
self.material_status = MaterialStatus.objects.get_or_create(
material=self.material, stream=self.stream)[0]
self.material_status.save()
def setUp(self):
self.begin = datetime.utcnow().replace(tzinfo=pytz.UTC)
self.stream = Stream.objects.get_or_create(id=7)[0]
self.other_stream = Stream()
self.other_stream.save()
self.end = datetime.utcnow().replace(tzinfo=pytz.UTC)
self.materials = self.stream.materials.all()[:]
for i in range(len(self.materials)):
state = 0 if (i % 2 == 0) else 2
self.materials[i].state = state
self.materials[i].save()
def setUp(self):
self.stream = Stream()
self.stream.save()
self.second_stream = Stream()
self.second_stream.save()
self.material = Material()
self.material.save()
self.material_status = MaterialStatus.objects.get_or_create(
material=self.material,
stream=self.stream
)[0]
self.material_status.save()
def wrap(managers, ids):
self.flag = True
l = Stream.requiring_work().values_list('id', flat=True)
self.assertEquals(len(ids), len(l))
for i in ids:
self.assertIn(i, l)
return original_map(managers, ids)
def setUp(self):
self.material = Material()
self.material.save()
self.other_material = Material()
self.other_material.save()
self.stream = Stream()
self.stream.save()
def test_create_empty(self):
# check if it create an empty stream.
stream = Stream.create_empty()
self.assertEquals(stream.__class__, Stream)
self.assertEquals(stream.unprocessed_count, 0)
self.assertEquals(stream.feed, None)
self.assertEquals(Stream.objects.filter(id=stream.id).count(), 1)
def step(self):
ids = Stream.requiring_work().values_list('id', flat=True)
# here the map function should not return any value.
self.managers.map(manager_job, ids)
connection.close()
class TestMaterialStatuses(TestCase):
fixtures = ['initial_data.yaml', '*']
def setUp(self):
self.stream = Stream()
self.stream.save()
self.second_stream = Stream()
self.second_stream.save()
self.material = Material()
self.material.save()
self.material_status = MaterialStatus.objects.get_or_create(
material=self.material,
stream=self.stream
)[0]
self.material_status.save()
def test_serialization(self):
material_status = u'%s -> %s' % (
unicode(self.material_status.stream),
unicode(self.material_status.material))
# check if the __str__ method return the created and modified datetime.
self.assertEquals(str(self.material_status), str(material_status))
# check if the __unicode__ method is defined to return the created and
# modified datetime.
self.assertEquals(unicode(self.material_status), material_status)
def test_statuses_number(self):
# check if return the list of statuses indexed by number.
self.assertEquals(MaterialStatus.statuses_number().keys(), [0, 1, 2])
self.assertEquals(MaterialStatus.statuses_number().values(),
[u'unprocessed', u'processing', u'processed'])
def test_statuses_name(self):
# check if return the list of statuses indexed by name.
self.assertEquals(MaterialStatus.statuses_name().keys(),
[u'unprocessed', u'processing', u'processed'])
self.assertEquals(MaterialStatus.statuses_name().values(), [0, 1, 2])
def test_clone_for(self):
# check if the clone method create a new file_status.
clone = self.material_status.clone_for(self.second_stream)
self.assertNotEquals(clone, self.material_status)
# check if the cloned material_status has the second_stream
# and the same material object.
self.assertEquals(self.material_status.stream, self.stream)
self.assertEquals(clone.stream, self.second_stream)
self.assertEquals(clone.material, self.material_status.material)
def test_status(self):
# check if return the status as a name.
for i, name in MaterialStatus.statuses_number().items():
self.material_status.state = i
self.assertEquals(self.material_status.status(), name)
def test_change_status(self):
# check if set the right status when use valid ids.
for name in MaterialStatus.statuses_name().keys():
self.material_status.change_status(name)
self.assertEquals(self.material_status.status(), name)
# check if rise an exception when use invalid ids.
self.material_status.change_status(u'unprocessed')
for name in [u'just an invalid status', u'invalid key']:
with self.assertRaises(InvalidStatus):
self.material_status.change_status(name)
self.assertEquals(self.material_status.status(), u'unprocessed')
def test_processed(self):
# check if the processed getter return true when the material
# was processed.
for name in MaterialStatus.statuses_name().keys():
self.material_status.change_status(name)
self.assertEquals(self.material_status.processed,
self.material_status.status() == u'processed')
# check if the processed setter change the processed attribute.
self.material_status.change_status(u'unprocessed')
self.assertFalse(self.material_status.processed)
self.material_status.processed = True
self.assertEquals(self.material_status.status(), u'processed')
self.assertTrue(self.material_status.processed)
self.material_status.processed = False
self.assertEquals(self.material_status.status(), u'unprocessed')
class TestStreams(TestCase):
fixtures = ['initial_data.yaml', '*']
def setUp(self):
self.begin = datetime.utcnow().replace(tzinfo=pytz.UTC)
self.stream = Stream.objects.get_or_create(id=7)[0]
self.other_stream = Stream()
self.other_stream.save()
self.end = datetime.utcnow().replace(tzinfo=pytz.UTC)
self.materials = self.stream.materials.all()[:]
for i in range(len(self.materials)):
state = 0 if (i % 2 == 0) else 2
self.materials[i].state = state
self.materials[i].save()
def test_serialization(self):
# check if the __str__ method is defined to return the object pk and
# parameter.
result = u'[id: %s unprocessed: %s] -> %s' % (unicode(
self.stream.pk), unicode(
self.stream.unprocessed_count), unicode(self.stream.feed))
self.assertEquals(str(self.stream), str(result))
# check if the __unicode__ method is defined to return the object pk
# parameter.
self.assertEquals(unicode(self.stream), result)
def test_save(self):
# check if hte instance was created between the begining and the ending
# of the setup.
self.assertTrue(self.begin <= self.other_stream.created <= self.end)
# check if the created and modified datetime are equals
self.assertEquals(self.other_stream.created,
self.other_stream.modified)
# check if the modified datetime change when the objects is saved
# again.
self.other_stream.save()
self.assertTrue(self.other_stream.modified > self.other_stream.created)
def test_clone(self):
# check if the clone method create a new stream.
clone = self.stream.clone()
self.assertNotEquals(clone, self.stream)
# check if the cloned stream is different from the original
self.assertNotEquals(clone, self.stream)
# self.assertEquals(clone, self.stream)
# check if the cloned stream is empty, and if the clone method avoid
# clone the files.
self.assertEquals(self.stream.materials.count(), 5)
self.assertEquals(clone.materials.count(), 0)
def test_unprocessed(self):
# check if return only the unprocessed files.
for fs in self.stream.unprocessed():
self.assertFalse(fs.processed)
fs.delete()
# check if return an empty list when it don't have pending files.
self.assertEquals(self.stream.unprocessed().count(), 0)
def test_empty(self):
# check if return True when it has got pending files.
self.assertFalse(self.stream.empty())
for fs in self.stream.unprocessed():
fs.delete()
# check if return False when it hasn't got pending files.
self.assertTrue(self.stream.empty())
def test_create_empty(self):
# check if it create an empty stream.
stream = Stream.create_empty()
self.assertEquals(stream.__class__, Stream)
self.assertEquals(stream.unprocessed_count, 0)
self.assertEquals(stream.feed, None)
self.assertEquals(Stream.objects.filter(id=stream.id).count(), 1)
def test_requiring_work(self):
# check if return all the streams with pending material statusese.
self.assertEquals(len(Stream.requiring_work()), 1)
self.assertEquals(Stream.requiring_work()[0], self.stream)
[ms.clone_for(self.other_stream) for ms in self.stream.materials.all()]
self.assertEquals(len(Stream.requiring_work()), 2)
self.assertEquals(Stream.requiring_work()[0], self.stream)
class TestMaterialStatuses(TestCase):
fixtures = ['initial_data.yaml', '*']
def setUp(self):
self.stream = Stream()
self.stream.save()
self.second_stream = Stream()
self.second_stream.save()
self.material = Material()
self.material.save()
self.material_status = MaterialStatus.objects.get_or_create(
material=self.material, stream=self.stream)[0]
self.material_status.save()
def test_serialization(self):
material_status = u'%s -> %s' % (unicode(
self.material_status.stream), unicode(
self.material_status.material))
# check if the __str__ method return the created and modified datetime.
self.assertEquals(str(self.material_status), str(material_status))
# check if the __unicode__ method is defined to return the created and
# modified datetime.
self.assertEquals(unicode(self.material_status), material_status)
def test_statuses_number(self):
# check if return the list of statuses indexed by number.
self.assertEquals(MaterialStatus.statuses_number().keys(), [0, 1, 2])
self.assertEquals(MaterialStatus.statuses_number().values(),
[u'unprocessed', u'processing', u'processed'])
def test_statuses_name(self):
# check if return the list of statuses indexed by name.
self.assertEquals(MaterialStatus.statuses_name().keys(),
[u'unprocessed', u'processing', u'processed'])
self.assertEquals(MaterialStatus.statuses_name().values(), [0, 1, 2])
def test_clone_for(self):
# check if the clone method create a new file_status.
clone = self.material_status.clone_for(self.second_stream)
self.assertNotEquals(clone, self.material_status)
# check if the cloned material_status has the second_stream
# and the same material object.
self.assertEquals(self.material_status.stream, self.stream)
self.assertEquals(clone.stream, self.second_stream)
self.assertEquals(clone.material, self.material_status.material)
def test_status(self):
# check if return the status as a name.
for i, name in MaterialStatus.statuses_number().items():
self.material_status.state = i
self.assertEquals(self.material_status.status(), name)
def test_change_status(self):
# check if set the right status when use valid ids.
for name in MaterialStatus.statuses_name().keys():
self.material_status.change_status(name)
self.assertEquals(self.material_status.status(), name)
# check if rise an exception when use invalid ids.
self.material_status.change_status(u'unprocessed')
for name in [u'just an invalid status', u'invalid key']:
with self.assertRaises(InvalidStatus):
self.material_status.change_status(name)
self.assertEquals(self.material_status.status(), u'unprocessed')
def test_processed(self):
# check if the processed getter return true when the material
# was processed.
for name in MaterialStatus.statuses_name().keys():
self.material_status.change_status(name)
self.assertEquals(self.material_status.processed,
self.material_status.status() == u'processed')
# check if the processed setter change the processed attribute.
self.material_status.change_status(u'unprocessed')
self.assertFalse(self.material_status.processed)
self.material_status.processed = True
self.assertEquals(self.material_status.status(), u'processed')
self.assertTrue(self.material_status.processed)
self.material_status.processed = False
self.assertEquals(self.material_status.status(), u'unprocessed')
def step(self):
ids = Stream.requiring_work().values_list('id', flat=True)
# here the map function should not return any value.
self.managers.map(manager_job, ids)
connection.close()
def setUp(self):
self.stream = Stream()
self.stream.save()
self.pusher = Push.objects.get_or_create(name='abstract one')[0]
self.now = datetime.utcnow().replace(tzinfo=pytz.UTC)
self.pusher.streams.add(self.stream)
def setUp(self):
self.stream = Stream()
self.stream.save()
self.adapter = Adapt.objects.get_or_create(name='abstract one')[0]
self.adapter.streams.add(self.stream)
def setUp(self):
self.stream = Stream()
self.stream.save()
self.pusher = Push.objects.get_or_create(name='abstract one')[0]
self.now = datetime.utcnow().replace(tzinfo=pytz.UTC)
self.pusher.streams.add(self.stream)