def test_with_nested_initial_elements(self):
fake = Fake.objects.create(nested=[
Nested(name=faker.name(), sub=SubNested(name=faker.word())),
Nested(name=faker.name(), sub=SubNested(name=faker.word())),
])
order = [n.id for n in fake.nested]
data = [
{'id': str(fake.nested[0].id)},
{'id': str(fake.nested[1].id)},
{'name': faker.name(), 'sub': {'name': faker.name()}},
]
form = self.factory({'nested': data}, fake, sub=True)
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), 3)
for idx, id in enumerate(order):
nested = fake.nested[idx]
self.assertEqual(nested.id, id)
self.assertIsNotNone(nested.sub)
self.assertIsNotNone(nested.sub.name)
self.assertIsNotNone(fake.nested[2].id)
self.assertEqual(fake.nested[2].sub.name, data[2]['sub']['name'])
def test_reorder_initial_elements_with_raw(self):
fake = Fake.objects.create(nested=[
Nested(name=faker.name(), raw={'test': 0}),
Nested(name=faker.name(), raw={'test': 1}),
Nested(name=faker.name(), raw={'test': 2}),
Nested(name=faker.name(), raw={'test': 3}),
])
initial = [(n.id, n.name) for n in fake.nested]
new_order = [1, 2, 3, 0]
form = self.factory({'nested': [
{'id': str(fake.nested[i].id)} for i in new_order
]}, fake)
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), len(initial))
for nested, old_idx in zip(fake.nested, new_order):
id, name = initial[old_idx]
self.assertEqual(nested.id, id)
self.assertEqual(nested.name, name)
self.assertEqual(nested.raw['test'], old_idx)
def test_with_initial_elements(self):
fake = Fake.objects.create(nested=Nested(name=faker.name()))
new_name = faker.name()
form = self.factory({'nested': {'name': new_name}}, fake)
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertIsNotNone(fake.nested.id)
self.assertEqual(fake.nested.name, new_name)
def test_non_submitted_subnested(self):
form = self.factory({'nested': [
{'name': faker.name()},
{'name': faker.name(), 'sub': {'name': faker.name()}},
]}, sub=True)
form.validate()
self.assertEqual(form.errors, {})
fake = form.save()
self.assertEqual(len(fake.nested), 2)
self.assertIsNone(fake.nested[0].sub)
self.assertIsNotNone(fake.nested[1].sub)
def feed(self,
feed_title,
title,
content,
url,
published=None,
summary=None,
enclosure=None,
media_thumbnail=None):
feed = FeedGenerator()
feed.title(feed_title)
feed.description(faker.sentence())
feed.link({'href': WP_FEED_URL})
entry = feed.add_entry()
entry.title(title)
entry.link({'href': url})
entry.author(name=faker.name())
entry.content(content, type="cdata")
if summary:
entry.description(summary)
if enclosure:
entry.enclosure(url=enclosure['url'],
type=enclosure['type'],
length=str(faker.pyint()))
if media_thumbnail:
feed.load_extension('media')
entry.media.thumbnail({'url': media_thumbnail})
tz = pytz.timezone(faker.timezone())
published = published or faker.date_time(tzinfo=tz)
entry.published(published)
entry.updated(faker.date_time_between(start_date=published, tzinfo=tz))
return feed.rss_str().decode('utf8')
def test_with_multiple_valid_data(self):
fake = Fake()
form = self.factory(MultiDict([
('nested-0-name', faker.name()),
('nested-1-name', faker.name()),
('nested-2-name', faker.name()),
]))
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), 3)
for nested in fake.nested:
self.assertIsInstance(nested, Nested)
def test_update_job_change_type(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5'))
self.login(AdminFactory())
response = self.put(
url_for('api.job', id=task.id), {
'name': task.name,
'description': task.description,
'task': task.task,
'interval': {
'every': 5,
'period': 'minutes',
}
})
self.assert200(response)
self.assertEqual(response.json['id'], str(task.id))
self.assertEqual(response.json['name'], task.name)
self.assertEqual(response.json['task'], task.task)
self.assertEqual(response.json['description'], task.description)
self.assertEqual(response.json['interval']['every'], 5)
self.assertEqual(response.json['interval']['period'], 'minutes')
self.assertIsNone(response.json['crontab'])
def feed(self, feed_title, title, content, url, published=None, summary=None,
enclosure=None, media_thumbnail=None):
feed = FeedGenerator()
feed.title(feed_title)
feed.description(faker.sentence())
feed.link({'href': WP_FEED_URL})
entry = feed.add_entry()
entry.title(title)
entry.link({'href': url})
entry.author(name=faker.name())
entry.content(content, type="cdata")
if summary:
entry.description(summary)
if enclosure:
entry.enclosure(url=enclosure['url'],
type=enclosure['type'],
length=str(faker.pyint()))
if media_thumbnail:
feed.load_extension('media')
entry.media.thumbnail({'url': media_thumbnail})
tz = pytz.timezone(faker.timezone())
published = published or faker.date_time(tzinfo=tz)
entry.published(published)
entry.updated(faker.date_time_between(start_date=published, tzinfo=tz))
return feed.rss_str().decode('utf8')
def feed(self, feed_title, title, content, url, published=None, summary=None,
enclosure=None, media_thumbnail=None):
feed = AtomFeed(feed_title, feed_url=WP_FEED_URL)
tz = pytz.timezone(faker.timezone())
published = published or faker.date_time(tzinfo=tz)
kwargs = {
'content_type': 'html',
'author': faker.name(),
'url': url,
'updated': faker.date_time_between(start_date=published, tzinfo=tz),
'published': published
}
if summary:
kwargs['summary'] = summary
if enclosure:
kwargs['links'] = [{
'type': enclosure['type'],
'href': enclosure['url'],
'rel': 'enclosure',
'length': faker.pyint(),
}]
feed.add(title, content, **kwargs)
out = feed.to_string()
if media_thumbnail:
el = '<media:thumbnail url="{0}" />'.format(media_thumbnail)
out = out.replace('<feed', '<feed xmlns:media="http://search.yahoo.com/mrss/"')
out = out.replace('</entry>', '{0}</entry>'.format(el))
return out
def test_with_multiple_valid_json(self):
fake = Fake()
form = self.factory({'nested': [
{'name': faker.name()},
{'name': faker.name()},
{'name': faker.name()},
]})
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), 3)
for nested in fake.nested:
self.assertIsInstance(nested, Nested)
def test_update_job(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5'))
self.login(AdminFactory())
response = self.put(
url_for('api.job', id=task.id), {
'name': task.name,
'description': 'New description',
'task': task.task,
'crontab': task.crontab.to_json()
})
self.assert200(response)
self.assertEqual(response.json['id'], str(task.id))
self.assertEqual(response.json['name'], task.name)
self.assertEqual(response.json['task'], task.task)
self.assertEqual(response.json['description'], 'New description')
self.assertIsNotNone(response.json['crontab'])
self.assertIsNone(response.json['interval'])
def test_update_job(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5')
)
self.login(AdminFactory())
response = self.put(url_for('api.job', id=task.id), {
'name': task.name,
'description': 'New description',
'task': task.task,
'crontab': task.crontab.to_json()
})
self.assert200(response)
self.assertEqual(response.json['id'], str(task.id))
self.assertEqual(response.json['name'], task.name)
self.assertEqual(response.json['task'], task.task)
self.assertEqual(response.json['description'], 'New description')
self.assertIsNotNone(response.json['crontab'])
self.assertIsNone(response.json['interval'])
def test_with_multiple_valid_json(self):
fake = Fake()
form = self.factory({'nested': [
{'name': faker.name()},
{'name': faker.name()},
{'name': faker.name()},
]})
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), 3)
for nested in fake.nested:
self.assertIsInstance(nested, Nested)
def test_update_job_change_type(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5')
)
self.login(AdminFactory())
response = self.put(url_for('api.job', id=task.id), {
'name': task.name,
'description': task.description,
'task': task.task,
'interval': {
'every': 5,
'period': 'minutes',
}
})
self.assert200(response)
self.assertEqual(response.json['id'], str(task.id))
self.assertEqual(response.json['name'], task.name)
self.assertEqual(response.json['task'], task.task)
self.assertEqual(response.json['description'], task.description)
self.assertEqual(response.json['interval']['every'], 5)
self.assertEqual(response.json['interval']['period'], 'minutes')
self.assertIsNone(response.json['crontab'])
def test_with_valid_json_data_id_only(self):
nested = Nested.objects.create(name=faker.name())
form = WithGenericChoicesForm.from_json({'nested': str(nested.id)})
form.validate()
self.assertIn('nested', form.errors)
self.assertEqual(len(form.errors['nested']), 1)
def test_with_invalid_id(self):
Nested.objects.create(name=faker.name())
form = WithReferenceForm.from_json({'nested': 'bad'})
form.validate()
self.assertIn('nested', form.errors)
self.assertEqual(len(form.errors['nested']), 1)
def feed(self, feed_title, title, content, url, published=None, summary=None,
enclosure=None, media_thumbnail=None):
feed = AtomFeed(feed_title, feed_url=WP_FEED_URL)
tz = pytz.timezone(faker.timezone())
published = published or faker.date_time(tzinfo=tz)
kwargs = {
'content_type': 'html',
'author': faker.name(),
'url': url,
'updated': faker.date_time_between(start_date=published, tzinfo=tz),
'published': published
}
if summary:
kwargs['summary'] = summary
if enclosure:
kwargs['links'] = [{
'type': enclosure['type'],
'href': enclosure['url'],
'rel': 'enclosure',
'length': faker.pyint(),
}]
feed.add(title, content, **kwargs)
out = feed.to_string()
if media_thumbnail:
el = '<media:thumbnail url="{0}" />'.format(media_thumbnail)
out = out.replace('<feed', '<feed xmlns:media="http://search.yahoo.com/mrss/"')
out = out.replace('</entry>', '{0}</entry>'.format(el))
return out
def test_with_multiple_valid_data(self):
fake = Fake()
form = self.factory(MultiDict([
('nested-0-name', faker.name()),
('nested-1-name', faker.name()),
('nested-2-name', faker.name()),
]))
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), 3)
for nested in fake.nested:
self.assertIsInstance(nested, Nested)
def test_with_non_submitted_initial_elements(self):
fake = Fake.objects.create(nested=[
Nested(name=faker.name()),
Nested(name=faker.name()),
])
initial = [(n.id, n.name) for n in fake.nested]
form = self.factory({'name': faker.word()}, fake)
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), len(initial))
for idx, (id, name) in enumerate(initial):
nested = fake.nested[idx]
self.assertEqual(nested.id, id)
self.assertEqual(nested.name, name)
def test_with_valid_form_data_id_only(self):
nested = Nested.objects.create(name=faker.name())
form = WithGenericForm(MultiDict({
'nested': str(nested.id)
}))
form.validate()
self.assertIn('nested', form.errors)
self.assertEqual(len(form.errors['nested']), 1)
def test_with_non_submitted_initial_elements(self):
fake = Fake.objects.create(nested=[
Nested(name=faker.name()),
Nested(name=faker.name()),
])
initial = [(n.id, n.name) for n in fake.nested]
form = self.factory({'name': faker.word()}, fake)
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), len(initial))
for idx, (id, name) in enumerate(initial):
nested = fake.nested[idx]
self.assertEqual(nested.id, id)
self.assertEqual(nested.name, name)
def test_with_invalid_ref_id(self):
Nested.objects.create(name=faker.name())
form = self.form.from_json({'nested': {
'class': 'Nested',
'id': 'bad'
}})
form.validate()
self.assertIn('nested', form.errors)
self.assertEqual(len(form.errors['nested']), 1)
def test_with_ref_class_not_in_choices(self):
nested = Nested.objects.create(name=faker.name())
form = self.form.from_json({'nested': {
'class': 'Nested3',
'id': str(nested.id)
}})
form.validate()
self.assertIn('nested', form.errors)
self.assertEqual(len(form.errors['nested']), 1)
def test_initial_data(self):
nested = Nested.objects.create(name=faker.name())
model = self.model(nested=nested)
form = self.form(obj=model)
self.assertEqual(form.nested.data, nested)
form.populate_obj(model)
self.assertEqual(model.nested, nested)
def test_with_initial_elements_as_ids(self):
fake = Fake.objects.create(nested=[
Nested(name=faker.name()),
Nested(name=faker.name()),
])
order = [n.id for n in fake.nested]
form = self.factory({'nested': [
str(fake.nested[0].id),
str(fake.nested[1].id),
{'name': faker.name()},
]}, fake)
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), 3)
for idx, id in enumerate(order):
self.assertEqual(fake.nested[idx].id, id)
self.assertIsNotNone(fake.nested[2].id)
def test_with_initial_elements_as_ids(self):
fake = Fake.objects.create(nested=[
Nested(name=faker.name()),
Nested(name=faker.name()),
])
order = [n.id for n in fake.nested]
form = self.factory({'nested': [
str(fake.nested[0].id),
str(fake.nested[1].id),
{'name': faker.name()},
]}, fake)
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), 3)
for idx, id in enumerate(order):
self.assertEqual(fake.nested[idx].id, id)
self.assertIsNotNone(fake.nested[2].id)
def test_with_one_valid_json_object(self):
nested = Nested.objects.create(name=faker.name())
fake = Fake()
form = FakeForm.from_json({'nested': [{'id': str(nested.id)}]})
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), 1)
self.assertIsInstance(fake.nested[0], Nested)
self.assertEqual(fake.nested[0], nested)
def test_with_valid_json_data_id_only(self):
nested = Nested.objects.create(name=faker.name())
model = WithReference()
form = WithReferenceForm.from_json({'nested': str(nested.id)})
form.validate()
self.assertEqual(form.errors, {})
self.assertEqual(form.nested.data, nested)
form.populate_obj(model)
self.assertIsInstance(model.nested, Nested)
self.assertEqual(model.nested, nested)
def test_with_non_submitted_initial_elements(self):
fake = Fake.objects.create(nested=Nested(name=faker.name()))
initial_id = fake.nested.id
initial_name = fake.nested.name
form = self.factory({'name': faker.word()}, fake)
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(fake.nested.id, initial_id)
self.assertEqual(fake.nested.name, initial_name)
def test_with_multiple_valid_data(self):
nesteds = [Nested.objects.create(name=faker.name()) for _ in range(3)]
ids = [str(n.id) for n in nesteds]
fake = Fake()
form = FakeForm(MultiDict({'nested': ','.join(ids)}))
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), len(nesteds))
self.assertIsInstance(fake.nested[0], Nested)
self.assertEqual(fake.nested, nesteds)
def test_delete_job_need_admin(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5'))
self.login()
response = self.delete(url_for('api.job', id=task.id))
self.assert403(response)
def test_with_multiple_valid_json_id(self):
nested = [Nested.objects.create(name=faker.name()) for _ in range(3)]
ids = [str(n.id) for n in nested]
fake = Fake()
form = FakeForm.from_json({'nested': ids})
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), len(nested))
self.assertIsInstance(fake.nested[0], Nested)
self.assertEqual(fake.nested, nested)
def test_reorder_initial_elements(self):
fake = Fake.objects.create(nested=[
Nested(name=faker.name()),
Nested(name=faker.name()),
Nested(name=faker.name()),
Nested(name=faker.name()),
])
initial = [(n.id, n.name) for n in fake.nested]
new_order = [1, 2, 3, 0]
form = self.factory({'nested': [
{'id': str(fake.nested[i].id)} for i in new_order
]}, fake)
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), len(initial))
for nested, old_idx in zip(fake.nested, new_order):
id, name = initial[old_idx]
self.assertEqual(nested.id, id)
self.assertEqual(nested.name, name)
def test_unschedule(self):
periodic_task = PeriodicTask.objects.create(
task='harvest',
name=faker.name(),
description=faker.sentence(),
enabled=True,
crontab=PeriodicTask.Crontab())
source = HarvestSourceFactory(periodic_task=periodic_task)
with assert_emit(signals.harvest_source_unscheduled):
actions.unschedule(str(source.id))
source.reload()
self.assertEqual(len(PeriodicTask.objects), 0)
self.assertIsNone(source.periodic_task)
def test_update_initial_elements(self):
fake = Fake.objects.create(nested=[
Nested(name=faker.name()),
Nested(name=faker.name()),
])
initial = [n.id for n in fake.nested]
form = self.factory({'nested': [
{'id': str(fake.nested[0].id), 'name': faker.name()},
{'id': str(fake.nested[1].id), 'name': faker.name()},
{'name': faker.name()},
]}, fake)
names = [n['name'] for n in form.data['nested']]
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), 3)
for idx, id in enumerate(initial):
nested = fake.nested[idx]
self.assertEqual(nested.id, id)
self.assertEqual(nested.name, names[idx])
self.assertIsNotNone(fake.nested[2].id)
def test_unschedule(self):
periodic_task = PeriodicTask.objects.create(
task='harvest',
name=faker.name(),
description=faker.sentence(),
enabled=True,
crontab=PeriodicTask.Crontab()
)
source = HarvestSourceFactory(periodic_task=periodic_task)
with assert_emit(signals.harvest_source_unscheduled):
actions.unschedule(str(source.id))
source.reload()
assert len(PeriodicTask.objects) == 0
assert source.periodic_task is None
def test_delete_job_need_admin(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5')
)
self.login()
response = self.delete(url_for('api.job', id=task.id))
self.assert403(response)
def test_render_home_with_blog_without_thumbnail(self, home):
'''It should render the home page with the latest blog article'''
post = {
'title': faker.name(),
'link': faker.uri(),
'summary': faker.sentence(),
'date': faker.date_time(),
}
response = home(post)
assert200(response)
page = response.data.decode('utf8')
assert post['title'] in page
assert post['link'] in page
assert post['summary'] in page
assert 'blog-thumbnail' not in page
def test_render_home_with_blog_without_thumbnail(self, home):
'''It should render the home page with the latest blog article'''
post = {
'title': faker.name(),
'link': faker.uri(),
'summary': faker.sentence(),
'date': faker.date_time(),
}
response = home(post)
assert200(response)
page = response.data.decode('utf8')
assert post['title'] in page
assert post['link'] in page
assert post['summary'] in page
assert 'blog-thumbnail' not in page
def test_update_initial_elements(self):
fake = Fake.objects.create(nested=[
Nested(name=faker.name()),
Nested(name=faker.name()),
])
initial = [n.id for n in fake.nested]
form = self.factory({'nested': [
{'id': str(fake.nested[0].id), 'name': faker.name()},
{'id': str(fake.nested[1].id), 'name': faker.name()},
{'name': faker.name()},
]}, fake)
names = [n['name'] for n in form.data['nested']]
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(fake)
self.assertEqual(len(fake.nested), 3)
for idx, id in enumerate(initial):
nested = fake.nested[idx]
self.assertEqual(nested.id, id)
self.assertEqual(nested.name, names[idx])
self.assertIsNotNone(fake.nested[2].id)
def test_minimal_ckan_response(rmock):
'''CKAN Harvester should accept the minimum dataset payload'''
CKAN_URL = 'https://harvest.me/'
API_URL = '{}api/3/action/'.format(CKAN_URL)
PACKAGE_LIST_URL = '{}package_list'.format(API_URL)
PACKAGE_SHOW_URL = '{}package_show'.format(API_URL)
name = faker.unique_string()
json = {
'success': True,
'result': {
'id': faker.uuid4(),
'name': name,
'title': faker.sentence(),
'maintainer': faker.name(),
'tags': [],
'private': False,
'maintainer_email': faker.email(),
'license_id': None,
'metadata_created': faker.iso8601(),
'organization': None,
'metadata_modified': faker.iso8601(),
'author': None,
'author_email': None,
'notes': faker.paragraph(),
'license_title': None,
'state': None,
'revision_id': faker.unique_string(),
'type': 'dataset',
'resources': [],
# extras is not always present so we exclude it from the minimal payload
}
}
source = HarvestSourceFactory(backend='ckan', url=CKAN_URL)
rmock.get(PACKAGE_LIST_URL,
json={
'success': True,
'result': [name]
},
status_code=200,
headers={'Content-Type': 'application/json'})
rmock.get(PACKAGE_SHOW_URL,
json=json,
status_code=200,
headers={'Content-Type': 'application/json'})
actions.run(source.slug)
source.reload()
assert source.get_last_job().status == 'done'
def test_with_valid_json_data_ref(self):
nested = Nested.objects.create(name=faker.name())
model = self.model()
form = self.form.from_json({'nested': {
'class': 'Nested',
'id': str(nested.id)
}})
form.validate()
self.assertEqual(form.errors, {})
self.assertEqual(form.nested.data, nested)
form.populate_obj(model)
self.assertIsInstance(model.nested, Nested)
self.assertEqual(model.nested, nested)
def test_delete_job(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5'))
self.login(AdminFactory())
response = self.delete(url_for('api.job', id=task.id))
self.assert204(response)
self.assertIsNone(PeriodicTask.objects(id=task.id).first())
def test_get_job(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5'))
response = self.get(url_for('api.job', id=task.id))
self.assert200(response)
self.assertEqual(response.json['id'], str(task.id))
self.assertEqual(response.json['name'], task.name)
self.assertEqual(response.json['description'], task.description)
self.assertEqual(response.json['task'], task.task)
def test_delete_job(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5')
)
self.login(AdminFactory())
response = self.delete(url_for('api.job', id=task.id))
self.assert204(response)
self.assertIsNone(PeriodicTask.objects(id=task.id).first())
def test_unschedule_source_is_admin_only(self, api):
'''It should only allow admins to unschedule a source'''
api.login()
periodic_task = PeriodicTask.objects.create(
task='harvest',
name=faker.name(),
description=faker.sentence(),
enabled=True,
crontab=PeriodicTask.Crontab())
source = HarvestSourceFactory(periodic_task=periodic_task)
url = url_for('api.schedule_harvest_source', ident=str(source.id))
response = api.delete(url)
assert403(response)
source.reload()
assert source.periodic_task is not None
def test_unschedule_source(self):
'''It should allow to unschedule a source if admin'''
self.login(AdminFactory())
periodic_task = PeriodicTask.objects.create(
task='harvest',
name=faker.name(),
description=faker.sentence(),
enabled=True,
crontab=PeriodicTask.Crontab())
source = HarvestSourceFactory(periodic_task=periodic_task)
url = url_for('api.schedule_harvest_source', ident=str(source.id))
response = self.delete(url)
self.assert204(response)
source.reload()
self.assertIsNone(source.periodic_task)
def test_render_home_with_blog(self):
'''It should render the home page with the latest blog article'''
post_url = faker.uri()
feed = AtomFeed('Some blog', feed_url=WP_ATOM_URL)
feed.add('Some post',
'<div>Some content</div>',
content_type='html',
author=faker.name(),
url=post_url,
updated=faker.date_time(),
published=faker.date_time())
httpretty.register_uri(httpretty.GET, WP_ATOM_URL,
body=feed.to_string(),
content_type='application/atom+xml')
response = self.get(url_for('site.home'))
self.assert200(response)
self.assertIn('Some post', response.data.decode('utf8'))
self.assertIn(post_url, response.data.decode('utf8'))
def test_get_job(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5')
)
response = self.get(url_for('api.job', id=task.id))
self.assert200(response)
self.assertEqual(response.json['id'], str(task.id))
self.assertEqual(response.json['name'], task.name)
self.assertEqual(response.json['description'], task.description)
self.assertEqual(response.json['task'], task.task)
def test_update_job_need_admin(self):
@job('a-job')
def test_job():
pass
task = PeriodicTask.objects.create(
name=faker.name(),
description=faker.sentence(),
task='a-job',
crontab=PeriodicTask.Crontab(minute='5')
)
self.login()
response = self.put(url_for('api.job', id=task.id), {
'name': task.name,
'description': 'New description',
'task': task.task,
'crontab': task.crontab.to_json()
})
self.assert403(response)
def test_scheduled_jobs_list(self):
@job('a-job')
def test_job():
pass
for i in range(6):
params = {
'name': faker.name(),
'description': faker.sentence(),
'task': 'a-job'
}
if i % 2:
params['crontab'] = PeriodicTask.Crontab(minute=str(i))
else:
params['interval'] = PeriodicTask.Interval(every=i,
period='minutes')
PeriodicTask.objects.create(**params)
response = self.get(url_for('api.jobs'))
self.assert200(response)
