def test_handles_blank_answer_text(self):
poll = Poll.objects.create(question_text='listening to your heart', title=random_title())
Answer.objects.create(poll=poll, answer_text='')
response = requests.get(
'https://onion.sodahead.com/api/polls/{}'.format(poll.sodahead_id)
).json()
self.assertEqual(response['poll']['answers'][0]['title'], 'Intentionally blank')
def test_set_end_date_to_null(self):
poll = Poll.objects.create(question_text='dont end this poll',
title=random_title())
poll.published = timezone.now()
poll.end_date = timezone.now() + timedelta(1)
poll.save()
data = {
'published': poll.published.isoformat(),
'title': poll.title,
'question_text': poll.question_text,
'end_date': None,
}
self.give_permissions()
detail_url = reverse('poll-detail', kwargs={'pk': poll.id})
response = self.api_client.put(
detail_url,
data=json.dumps(data),
content_type='application/json',
)
response = requests.get(
'https://onion.sodahead.com/api/polls/{}'.format(
poll.sodahead_id)).json()
self.assertIsNone(response['poll']['endDate'])
def test_handles_sodahead_answer_creation_errors(self):
sodahead_endpoint = re.compile('https://onion.sodahead.com/api/polls/[\d]+/')
poll = Poll.objects.create(question_text='listening to your heart', title=random_title())
with requests_mock.Mocker() as mocker:
mocker.post(sodahead_endpoint, status_code=500, json={})
with self.assertRaises(SodaheadResponseError):
Answer.objects.create(poll=poll, answer_text='something')
def test_sodahead_id_increments_properly_after_answer_delete(self):
poll = Poll.objects.create(question_text='good text', title=random_title())
answer = Answer.objects.create(poll=poll, answer_text='hello')
answer.delete()
self.assertFalse(Answer.objects.filter(id=poll.id).exists())
next_answer = Answer.objects.create(poll=poll, answer_text='yawp!')
self.assertEqual(next_answer.sodahead_answer_id, 'answer_02')
def test_get_poll_data(self):
poll = Poll.objects.create(question_text=u'are we on vox!?',
title=random_title())
Answer.objects.create(poll=poll, answer_text=u'affirmative')
Answer.objects.create(poll=poll, answer_text=u'that is a negatory')
poll_data_url = reverse('get-merged-poll-data', kwargs={'pk': poll.id})
response = self.api_client.get(poll_data_url,
**{'HTTP_ORIGIN': 'this.cool.origin'})
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Access-Control-Allow-Origin'],
'this.cool.origin')
self.assertEqual(response['Access-Control-Allow-Credentials'], 'true')
if PY2:
data = json.loads(response.content)
else:
data = json.loads(response.content.decode('utf-8'))
self.assertEqual(data['id'], poll.id)
self.assertEqual(data['total_votes'], 0)
self.assertEqual(data['answers'][0]['total_votes'], 0)
self.assertIsNotNone(data['answers'][0]['sodahead_id'], 0)
self.assertEqual(data['answers'][1]['total_votes'], 0)
self.assertIsNotNone(data['answers'][1]['sodahead_id'], 0)
def test_setting_published_sets_sodahead_activation_date(self):
poll = Poll.objects.create(question_text='lettuce is good in a salad', title=random_title())
collins_birthtime = datetime(1987, 4, 11, 8, 45, 0, tzinfo=pytz.utc)
poll.published = collins_birthtime
poll.save()
response = requests.get('http://onion.sodahead.com/api/polls/{}'.format(poll.sodahead_id))
self.assertEqual(response.json()['poll']['activationDate'], u'1987-04-11 08:45:00')
def test_poll_image_serialization(self):
poll = Poll.objects.create(
question_text='Where are we?',
title=random_title(),
end_date=timezone.now() + timedelta(hours=9),
)
serializer = PollSerializer(poll)
self.assertTrue(serializer['poll_image'])
def test_answer_serialization(self):
poll = Poll.objects.create(
question_text='good text',
title=random_title(),
)
answer = Answer.objects.create(poll=poll, answer_text='this is some text')
serializer = AnswerSerializer(answer)
self.assertEqual(serializer.data['answer_text'], answer.answer_text)
def test_get_poll(self):
poll = Poll.objects.create(question_text='good text',
title=random_title())
detail_url = reverse('poll-detail', kwargs={'pk': poll.id})
self.give_permissions()
response = self.api_client.get(detail_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['id'], poll.id)
def test_answer_image_serialization(self):
poll = Poll.objects.create(
question_text='Where are we?',
title=random_title(),
end_date=timezone.now() + timedelta(hours=9),
)
answer = Answer.objects.create(poll=poll, answer_text='woop')
serializer = AnswerSerializer(answer)
self.assertTrue(serializer['answer_image'])
def test_setting_end_date_sets_sodahead_end_date(self):
poll = Poll.objects.create(question_text='this poll ends', title=random_title())
collins_birthtime = datetime(1987, 4, 11, 8, 45, 0, tzinfo=pytz.utc)
poll.published = collins_birthtime
end_of_the_poll = datetime(2050, 4, 11, 8, 45, 0, tzinfo=pytz.utc)
poll.end_date = end_of_the_poll
poll.save()
response = requests.get('http://onion.sodahead.com/api/polls/{}'.format(poll.sodahead_id))
self.assertEqual(response.json()['poll']['endDate'], u'2050-04-11 08:45:00')
def test_delete_answer(self):
poll = Poll.objects.create(question_text='dreams',
title=random_title())
answer = Answer.objects.create(answer_text='are fun', poll=poll)
answer_url = reverse('answer-detail', kwargs={'pk': answer.id})
self.give_permissions()
response = self.api_client.delete(answer_url)
self.assertEqual(response.status_code, 204)
response2 = self.api_client.get(answer_url)
self.assertEqual(response2.data['detail'], u'Not found.')
def test_put_proctected(self):
poll = Poll.objects.create(
question_text='decent text',
title=random_title(),
)
detail_url = reverse('poll-detail', kwargs={'pk': poll.id})
response = self.api_client.put(detail_url,
data=json.dumps({}),
content_type='application/json')
self.assertEqual(response.status_code, 403)
def test_multiple_answer_serialization(self):
poll = Poll.objects.create(
question_text='good text',
title=random_title(),
)
answer1 = Answer.objects.create(poll=poll, answer_text='this is some text')
answer2 = Answer.objects.create(poll=poll, answer_text='forest path')
serializer = AnswerSerializer(Answer.objects.all(), many=True)
self.assertEqual(serializer.data[0]['answer_text'], answer1.answer_text)
self.assertEqual(serializer.data[1]['answer_text'], answer2.answer_text)
def test_post_to_answers(self):
poll = Poll.objects.create(question_text='Russell\'s time was over',
title=random_title())
answers_url = reverse('answer-list')
data = {'poll': poll.id, 'answer_text': 'he\'s getting stale'}
self.give_permissions()
response = self.api_client.post(answers_url,
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, 201)
def test_serializing_unpublished_poll_does_serialize(self):
poll = Poll.objects.create(
question_text='it is not published yet',
title=random_title(),
)
serializer = PollPublicSerializer(Poll.objects.get(id=poll.id))
data = serializer.data
self.assertEqual(data['answers'], [])
self.assertIsNone(data.get('published'))
def test_changing_question_text_updates_sodahoad(self):
poll = Poll.objects.create(
question_text='do you want to wear a hat?',
title=random_title()
)
poll.question_text = 'let us have it'
poll.save()
response = requests.get(
'https://onion.sodahead.com/api/polls/{}'.format(poll.sodahead_id)
).json()
self.assertEqual(response['poll']['title'], 'let us have it')
def test_search_polls(self):
with vcr.use_cassette('test_search_polls'):
poll1 = Poll.objects.create(
question_text='find me',
title=random_title(),
)
Poll.objects.create(
question_text='dont find me',
title=random_title(),
)
Poll.search_objects.refresh()
self.give_permissions()
list_url = reverse('poll-list') + '?search=' + poll1.title
response = self.api_client.get(list_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data['results']), 1)
self.assertEqual(response.data['results'][0]['question_text'],
'find me')
def test_put_to_update_poll(self):
poll = Poll.objects.create(
question_text='decent text',
title=random_title(),
)
detail_url = reverse('poll-detail', kwargs={'pk': poll.id})
data = {
'question_text': 'better text',
'title': random_title(),
'published': timezone.now().isoformat(),
'end_date': (timezone.now() + timedelta(10)).isoformat(),
}
self.give_permissions()
response = self.api_client.put(
detail_url,
data=json.dumps(data),
content_type='application/json',
)
self.assertEqual(response.status_code, 200)
self.assertEqual(
Poll.objects.get(id=poll.id).question_text, 'better text')
def test_poll_serialization(self):
poll = Poll.objects.create(
question_text='good text',
title=random_title(),
published=timezone.now(),
end_date=timezone.now() + timedelta(1),
)
serializer = PollSerializer(poll)
self.assertEqual(serializer.data['id'], poll.id)
self.assertEqual(serializer.data['question_text'], poll.question_text)
self.assertEqual(serializer.data['title'], poll.title)
self.assertIsNotNone(serializer.data['end_date'])
def test_multiple_answer_creation(self):
poll = Poll.objects.create(question_text='melissas adventure', title=random_title())
Answer.objects.create(poll=poll, answer_text='something')
Answer.objects.create(poll=poll, answer_text='bridge')
Answer.objects.create(poll=poll, answer_text='alibaster')
response = requests.get(
'https://onion.sodahead.com/api/polls/{}'.format(poll.sodahead_id)
).json()
self.assertEqual(len(response['poll']['answers']), 3)
self.assertEqual(response['poll']['answers'][0]['title'], 'something')
self.assertEqual(response['poll']['answers'][1]['title'], 'bridge')
self.assertEqual(response['poll']['answers'][2]['title'], 'alibaster')
def test_filter_to_active_polls(self):
with vcr.use_cassette('test_filter_to_active_polls'):
Poll.objects.create(
question_text='find me',
title=random_title(),
published=(timezone.now() - timedelta(1)),
)
poll2 = Poll.objects.create(
question_text='dont find me',
title=random_title(),
)
poll2.published = timezone.now() + timedelta(2)
poll2.save()
Poll.search_objects.refresh()
self.give_permissions()
list_url = reverse('poll-list') + '?active=true'
response = self.api_client.get(list_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data['results']), 1)
self.assertEqual(response.data['results'][0]['question_text'],
'find me')
def test_serializing_poll_published_in_the_future_does_serialize(self):
poll = Poll.objects.create(
question_text='it is not published yet',
title=random_title(),
)
poll.published = timezone.now() + timedelta(1)
poll.save()
serializer = PollPublicSerializer(Poll.objects.get(id=poll.id))
data = serializer.data
self.assertEqual(data['answers'], [])
self.assertIsNotNone(data.get('published'))
def test_answer_names_survive_multiple_saves(self):
poll = Poll.objects.create(
question_text='dangerous waters ahead',
title=random_title()
)
Answer.objects.create(answer_text='watch out', poll=poll)
Answer.objects.create(answer_text='it\'s bad', poll=poll)
poll.question_text = 'use a quarter pound of reasons'
poll.save()
response = requests.get(
'https://onion.sodahead.com/api/polls/{}'.format(poll.sodahead_id)
).json()
self.assertEqual(response['poll']['answers'][0]['title'], 'watch out')
self.assertEqual(response['poll']['answers'][1]['title'], 'it\'s bad')
def test_serialization_includes_sodahead_data(self):
poll = Poll.objects.create(
question_text='is it powerful?',
title=random_title(),
)
answer1 = Answer.objects.create(poll=poll, answer_text=u'yes')
answer2 = Answer.objects.create(poll=poll, answer_text=u'no')
answer3 = Answer.objects.create(poll=poll, answer_text=u'maybe')
serializer = PollPublicSerializer(Poll.objects.get(id=poll.id))
answers_data = serializer.data['answers']
first_sodahead_id = answers_data[0]['sodahead_id']
second_sodahead_id = answers_data[1]['sodahead_id']
third_sodahead_id = answers_data[2]['sodahead_id']
self.assertEqual(answers_data[0]['id'], answer1.id)
self.assertEqual(answers_data[0]['sodahead_id'], first_sodahead_id)
self.assertEqual(answers_data[0]['answer_text'], u'yes')
self.assertEqual(answers_data[0]['poll'], poll.id)
self.assertEqual(answers_data[0]['total_votes'], 0)
self.assertEqual(answers_data[1]['id'], answer2.id)
self.assertEqual(answers_data[1]['sodahead_id'], second_sodahead_id)
self.assertEqual(answers_data[1]['answer_text'], u'no')
self.assertEqual(answers_data[1]['poll'], poll.id)
self.assertEqual(answers_data[1]['total_votes'], 0)
self.assertEqual(answers_data[2]['id'], answer3.id)
self.assertEqual(answers_data[2]['sodahead_id'], third_sodahead_id)
self.assertEqual(answers_data[2]['answer_text'], u'maybe')
self.assertEqual(answers_data[2]['poll'], poll.id)
self.assertEqual(answers_data[2]['total_votes'], 0)
answer2.delete()
serializer = PollPublicSerializer(Poll.objects.get(id=poll.id))
answers_data = serializer.data['answers']
self.assertEqual(answers_data[0]['id'], answer1.id)
self.assertEqual(answers_data[0]['sodahead_id'], first_sodahead_id)
self.assertEqual(answers_data[0]['answer_text'], u'yes')
self.assertEqual(answers_data[0]['poll'], poll.id)
self.assertEqual(answers_data[0]['total_votes'], 0)
self.assertEqual(answers_data[1]['id'], answer3.id)
self.assertEqual(answers_data[1]['sodahead_id'], third_sodahead_id)
self.assertEqual(answers_data[1]['answer_text'], u'maybe')
self.assertEqual(answers_data[1]['poll'], poll.id)
self.assertEqual(answers_data[1]['total_votes'], 0)
def test_post_to_create_poll(self):
list_url = reverse('poll-list')
data = {
'question_text': 'go underneath the bridge!',
'title': random_title()
}
self.give_permissions()
response = self.api_client.post(list_url,
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, 201)
id = response.data.get('id')
self.assertIsNotNone(id)
poll = Poll.objects.get(id=int(id))
self.assertIsNotNone(poll)
def test_put_to_update_answer(self):
poll = Poll.objects.create(question_text='Russell actually never was',
title=random_title())
answer = Answer.objects.create(answer_text='isn\'t that disturbing?',
poll=poll)
answer_url = reverse('answer-detail', kwargs={'pk': answer.id})
data = {'answer_text': 'he\'s getting stale'}
self.give_permissions()
response = self.api_client.put(answer_url,
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, 200)
self.assertEqual(
Answer.objects.get(id=answer.id).answer_text,
'he\'s getting stale')
def test_sodahead_service_failure(self):
with requests_mock.Mocker() as mocker:
sodahead_endpoint = re.compile(
'https://onion.sodahead.com/api/polls/')
mocker.post(sodahead_endpoint, status_code=500)
list_url = reverse('poll-list')
data = {
'questions_text': 'go underneath the bridge!',
'title': random_title()
}
self.give_permissions()
response = self.api_client.post(list_url,
json.dumps(data),
content_type='application/json')
self.assertEqual(response.status_code, 503)
def test_poll_answer_serialization(self):
poll = Poll.objects.create(
question_text=u'good text',
title=random_title(),
)
answer1 = Answer.objects.create(poll=poll, answer_text=u'this is some text')
answer2 = Answer.objects.create(poll=poll, answer_text=u'forest path')
serializer = PollSerializer(poll)
answers_data = serializer.data['answers']
self.assertEqual(answers_data[0]['id'], answer1.id)
self.assertEqual(answers_data[0]['answer_text'], u'this is some text')
self.assertEqual(answers_data[0]['poll'], poll.id)
self.assertEqual(answers_data[1]['id'], answer2.id)
self.assertEqual(answers_data[1]['answer_text'], u'forest path')
self.assertEqual(answers_data[1]['poll'], poll.id)
def test_poll_delete_on_sodahead(self):
poll = Poll.objects.create(question_text='good text', title=random_title())
poll.delete()
response = requests.get('https://onion.sodahead.com/api/polls/{}'.format(poll.sodahead_id))
self.assertEqual(response.status_code, 400)
def test_poll_delete(self):
poll = Poll.objects.create(question_text='good text', title=random_title())
poll.delete()
self.assertFalse(Poll.objects.filter(id=poll.id))
def test_poll_creation_fails_when_sodahead_request_fails(self):
with requests_mock.Mocker() as mocker:
mocker.post('https://onion.sodahead.com/api/polls/', status_code=500)
with self.assertRaises(SodaheadResponseError):
Poll.objects.create(question_text='other text', title=random_title())
def test_poll_creation_gets_sodahead_id(self):
poll = Poll.objects.create(question_text='other text', title=random_title())
self.assertNotEqual(poll.sodahead_id, '')
def test_create(self):
poll = Poll.objects.create(question_text='good text', title=random_title())
self.assertTrue(Poll.objects.filter(id=poll.id).exists())
def test_create_answer(self):
poll = Poll.objects.create(question_text='collins adventure', title=random_title())
answer = Answer.objects.create(poll=poll)
self.assertEqual(answer.sodahead_answer_id, 'answer_01')
