path: root/webapp/polls/tests/poll_tests.py

# -*- encoding: utf-8 -*-
import json
import warnings
import tempfile
from bson import ObjectId
import os

from polls.models import Poll, Field, Structure
from polls.views import clean_data, is_image_file
from polls.forms import PollForm
from pollster.models import Pollster
from django.conf import settings
from django.test import TestCase

from utils.test import MongoTestCase
from polls.tests.poll_result_file_tests import make_temp_file


class PollTests(MongoTestCase):

    def test_poll_init(self):
        pollster = Pollster.create(username="test", password="test")

        name = 'nombre de encuesta'
        data = {'name': name, 'pollsters': pollster.id}

        poll = Poll(data=data)
        self.assertIsNone(poll.id)
        self.assertEqual(name, poll.name)
        self.assertEqual(pollster.id, poll.pollsters)

        id = '513a0634421aa932884daa5c'
        data = {'id': id, 'name': name}

        poll = Poll(data=data)
        self.assertEqual(ObjectId(id), poll.id)
        self.assertEqual(name, poll.name)

    def test_validate(self):
        data = {}
        poll = Poll(data=data)

        self.assertRaises(Poll.ValidationError, poll.validate)

    def test_save(self):

        name = 'nombre de encuesta'
        data = {'name': name}

        poll = Poll(data=data)
        poll.save()

        self.assertEqual(1, self.db.polls.count())

    def test_unique_name(self):

        name = "unique name"
        data = {'name': name}

        poll = Poll(data=data)
        poll.save()

        poll = Poll(data=data)

        self.assertRaisesRegexp(
            Poll.ValidationError,
            "Poll name '%s' already in use." % poll.name,
            poll.validate
        )

        data = {'name': "name"}
        poll = Poll(data=data)

        fail = True
        try:
            poll.save()
        except Poll.ValidationError:
            fail = False

        self.assertTrue(fail)

    def test_get(self):

        self.assertIsNone(Poll.get(id=None))

        name = 'nombre de encuesta'
        data = {'name': name}

        poll = Poll(data=data)
        poll_id = poll.save()

        poll = Poll.get(id=poll_id)

        self.assertIsNotNone(poll)
        self.assertIsNotNone(poll.id)
        self.assertIsInstance(poll_id, ObjectId)
        self.assertEqual(name, poll.name)
        self.assertEqual(Poll.OPEN, poll.status)
        self.assertIsNotNone(poll.creation_date)
        self.assertIsNotNone(poll.modification_date)

    def test_status(self):

        name = 'nombre de encuesta'
        data = {'name': name}

        poll = Poll(data=data)

        self.assertEqual(Poll.OPEN, poll.status)

        poll_id = poll.save()

        self.assertEqual(Poll.OPEN, Poll.get(poll_id).status)

    def test_is_open(self):

        name = 'nombre de encuesta'
        data = {'name': name}

        poll = Poll(data=data)

        self.assertTrue(poll.is_open())

        poll.status = Poll.CLOSED

        self.assertFalse(poll.is_open())

    def test_pollster_assignment(self):

        poll1 = Poll(data={'name': "poll #1"})
        poll1_id = poll1.save()
        poll2 = Poll(data={'name': "poll #2"})
        poll2_id = poll2.save()
        poll3 = Poll(data={'name': "poll #3"})
        poll3_id = poll3.save()

        pollster = Pollster.create(username="test", password="test")

        poll_ids = [str(poll1_id), str(poll2_id)]

        Poll.pollster_assignment(str(pollster.id), poll_ids)

        poll1 = Poll.get(poll1_id)
        poll2 = Poll.get(poll2_id)
        poll3 = Poll.get(poll3_id)

        self.assertTrue(pollster in poll1.get_pollsters())
        self.assertTrue(pollster in poll2.get_pollsters())
        self.assertEqual(0, len(poll3.get_pollsters()))

    def test_two_pollsters_into_one_poll(self):

        poll = Poll(data={'name': "poll"})
        poll_id = poll.save()

        pollster_1 = Pollster.create(username="test1", password="test1")
        pollster_2 = Pollster.create(username="test2", password="test2")

        Poll.pollster_assignment(str(pollster_1.id), [poll_id])
        Poll.pollster_assignment(str(pollster_2.id), [poll_id])

        pollster_1 = Pollster.get(pollster_1.id)
        pollster_2 = Pollster.get(pollster_2.id)

        poll = Poll.get(poll_id)

        self.assertTrue(pollster_1 in poll.get_pollsters())
        self.assertTrue(pollster_2 in poll.get_pollsters())

    def test_pollster_assignment_to_poll_dont_repeat_pollster(self):

        poll = Poll(data={'name': "poll"})
        poll_id = poll.save()

        pollster = Pollster.create(username="test", password="test")

        Poll.pollster_assignment(str(pollster.id), [poll_id])
        poll = Poll.get(poll_id)

        self.assertEqual(1, len(poll.get_pollsters()))

        Poll.pollster_assignment(str(pollster.id), [str(poll.id)])
        poll = Poll.get(poll_id)

        self.assertEqual(1, len(poll.get_pollsters()))

    # TODO: Mock file system methods
    def test_clone(self):

        poll = Poll(data={'name': 'name'})
        poll_id = poll.save()
        poll = Poll.get(poll_id)

        data = {
            'groups': {
                '0': {
                    'name': 'group_0',
                    'fields': {
                        '0': {
                            'widget_type': Field.TextInput,
                            'name': 'field_0_0'
                        },
                        '1': {
                            'widget_type': Field.RadioButton,
                            'name': 'field_0_1'
                        }
                    },
                },
                '1': {
                    'name': 'group_1',
                    'fields': {
                        '0': {
                            'widget_type': Field.MultipleCheckBox,
                            'name': 'field_1_0'
                        },
                        '1': {
                            'widget_type': Field.DropDownList,
                            'name': 'field_1_1'
                        }
                    },
                }
            }
        }

        structure = Structure(data=data, poll=poll)
        structure.save()
        poll = Poll.get(poll_id)

        poll_clone = poll.clone()

        poll_data = poll.to_python()
        poll_structure_data = poll.structure.to_python()
        poll_id = poll_data['_id']
        del poll_data['_id']
        del poll_data['name']
        poll_data['status'] = Poll.OPEN
        poll_structure_data_id = poll_structure_data['_id']
        del poll_structure_data['_id']

        poll_clone_data = poll_clone.to_python()
        poll_clone_structure_data = poll_clone.structure.to_python()
        poll_clone_id = poll_clone_data['_id']
        del poll_clone_data['_id']
        del poll_clone_data['name']
        poll_clone_structure_data_id = poll_clone_structure_data['_id']
        del poll_clone_structure_data['_id']

        self.assertIsNotNone(poll_clone_id)
        self.assertIsNotNone(poll_clone_structure_data_id)
        self.assertNotEqual(poll_clone_id, poll_id)
        self.assertEqual('clon-%s' % poll.name, poll_clone.name)
        self.assertTrue(poll_clone.is_open())
        self.assertNotEqual(
            poll_clone_structure_data_id, poll_structure_data_id)

        self.assertEqual(poll_clone_data, poll_data)
        self.assertEqual(poll_clone_structure_data, poll_structure_data)

    def test_get_template(self):

        pollster = Pollster.create(username="test", password="test")

        poll_data = {
            "name": "test",
            "pollsters": [pollster],
            "status": Poll.OPEN
        }

        structure_data = {
            'groups': {
                '0': {
                    'name': 'group_0',
                    'fields': {
                        '0': {
                            'widget_type': Field.TextInput,
                            'name': 'field_0_0',
                            'options': {
                                '1': {
                                    'text': 'Default text',
                                    'order': 0
                                }
                            },
                        }
                    }
                }
            }
        }

        poll = Poll(data=poll_data)
        poll_id = poll.save()
        poll = Poll.get(poll_id)
        structure = Structure(data=structure_data, poll=poll)
        structure.save()

        template = poll.get_template()

        expected_dict = {
            'groups': structure.to_python()['groups'],
            'poll_id': str(poll.id),
            'poll_name': poll.name,
            'pollster_id': None,
            'pollster_username': None,
        }
        expected = json.dumps(
            expected_dict,
            sort_keys=True,
            indent=4,
            separators=(',', ': '),
            ensure_ascii=False
        )

        self.assertEqual(expected, template)

        template = poll.get_template(pollster=pollster)

        expected_dict = {
            'groups': structure.to_python()['groups'],
            'poll_id': str(poll.id),
            'poll_name': poll.name,
            'pollster_id': str(pollster.id),
            'pollster_username': pollster.username,
        }
        expected = json.dumps(
            expected_dict,
            sort_keys=True,
            indent=4,
            separators=(',', ': '),
            ensure_ascii=False
        )

        self.assertEqual(expected, template)

        new_pollster = Pollster.create(username="test1", password="test1")

        with warnings.catch_warnings(record=True) as w:
            # Cause all warnings to always be triggered.
            warnings.simplefilter("always")
            # Trigger a warning.
            template = poll.get_template(pollster=new_pollster)
            # Verify some things
            assert len(w) == 1
            assert issubclass(w[-1].category, Warning)
            assert "Pollster given not belongs to this poll" in str(
                w[-1].message)

        expected_dict = {
            'groups': structure.to_python()['groups'],
            'poll_id': str(poll.id),
            'poll_name': poll.name,
            'pollster_id': str(new_pollster.id),
            'pollster_username': new_pollster.username,
        }
        expected = json.dumps(
            expected_dict,
            sort_keys=True,
            indent=4,
            separators=(',', ': '),
            ensure_ascii=False
        )

        self.assertEqual(expected, template)

    def test_results_path_shoud_be_what_is_in_settings_plus_poll_id(self):
        poll_without_id = Poll({})
        with self.assertRaises(Exception):
            poll_without_id.results_path

        poll_id = ObjectId()
        poll_with_id = Poll({'id': poll_id})
        expected = settings.RESULT_BCK_ROOT
        self.assertIn(expected, poll_with_id.results_path)

    def test_it_should_a_PollResult_when_get_result(self):
        poll = Poll(data={'name': "poll"})
        poll_id = poll.save()
        poll = Poll.get(poll_id)

        poll_result = poll.get_result()
        self.assertTrue(hasattr(poll_result, "to_csv"))

    def test_has_result_with_no_results(self):
        poll = Poll(data={'name': "poll"})
        poll_id = poll.save()
        poll = Poll.get(poll_id)

        self.assertFalse(poll.has_result())

    def test_has_result_with_at_least_one_result(self):
        poll = Poll(data={'name': "poll"})
        poll_id = poll.save()
        poll = Poll.get(poll_id)

        temp_dir = '/tmp'
        uploaded_file = tempfile.NamedTemporaryFile(dir=temp_dir,
                                                    suffix='.poll_result')
        uploaded_file_path = uploaded_file.name
        uploaded_filename = os.path.basename(uploaded_file_path)

        poll.add_result_files([(uploaded_file_path, uploaded_filename)])
        stub = lambda path: os.path.basename(path)

        self.assertTrue(poll.has_result(as_instance_of=stub))


class PollFormTests(MongoTestCase):

    def test_save(self):
        self.assertEqual(0, self.db.polls.count())

        name = 'nombre de encuesta'
        data = {'name': name, 'status': Poll.OPEN}

        form = PollForm(data=data)

        self.assertTrue(form.is_valid())

        poll = form.save()

        self.assertIsNotNone(poll)
        self.assertIsInstance(poll, Poll)
        self.assertEqual(1, self.db.polls.count())

    def test_no_valid_data(self):
        form = PollForm()

        self.assertFalse(form.is_valid())


class PollResultFilesTest(MongoTestCase):

    def setUp(self):
        name = 'nombre de encuesta'
        data = {'name': name}
        poll = Poll(data=data)
        poll_id = poll.save()
        self.poll = Poll.get(poll_id)

    def test_it_should_return_empty_list_with_no_files(self):
        poll = self.poll
        self.assertListEqual([], poll.get_result_files())

    def test_it_should_return_one_result_file(self):
        poll = self.poll

        tmp_path = tempfile.mkstemp(suffix='.poll_result')[1]
        with open(tmp_path, 'w') as tmp:
            tmp.write(
                json.dumps(
                    '', sort_keys=True, indent=4, separators=(',', ': ')
                )
            )

        uploaded_file_path = tmp_path
        name = 'result.poll_result'
        poll.add_result_files([(uploaded_file_path, name)])
        results_files = poll.get_result_files()
        self.assertEqual(1, len(results_files))
        self.assertTrue(hasattr(results_files[0], 'get_file_name'))


class AddResultFilesTest(MongoTestCase):

    def setUp(self):
        name = 'nombre de encuesta'
        data = {'name': name}
        poll = Poll(data=data)
        poll_id = poll.save()
        self.poll = Poll.get(poll_id)

    def test_add_a_result_file(self):
        temp_dir = '/tmp'
        uploaded_file = tempfile.NamedTemporaryFile(dir=temp_dir,
                                                    suffix='.poll_result')
        uploaded_file_path = uploaded_file.name
        uploaded_filename = 'other_name.poll_result'
        poll = self.poll

        poll.add_result_files([(uploaded_file_path, uploaded_filename)])
        stub = lambda path: os.path.basename(path)
        results = poll.get_result_files(as_instance_of=stub)
        result_filename = results[0]
        self.assertEqual(uploaded_filename, result_filename)


class MockImageFileInterface(object):

    def __init__(self, name="a_name.jpg", size=(250, 250)):
        self.name = name
        self.size = size


class CleanDataMustCheckImagesTypes(TestCase):

    def test_is_image(self):
        image_mock = MockImageFileInterface()
        self.assertTrue(is_image_file(image_mock))

    def test_it_should_no_raises_with_a_image_file_value(self):
        data_to_clean = {'some_img': MockImageFileInterface()}
        try:
            clean_data(data_to_clean)
        except AttributeError as e:
            self.fail(e)

    def test_it_should_strip_values_that_are_not_image_files(self):
        data_to_clean = {'value': " to strip "}
        cleaned_data = clean_data(data_to_clean)
        self.assertEqual("to strip", cleaned_data['value'])


class RemoveResultsTest(MongoTestCase):

    def test_it_should_respond_to_remove_results(self):
        name = 'poll'
        data = {'name': name}
        poll = Poll(data=data)
        self.assertTrue(hasattr(poll, 'remove_results'))

    def test_it_should_remove_the_result_files(self):
        data = {}
        uploaded_file_path = make_temp_file(data)
        uploaded_filename = os.path.basename(uploaded_file_path)

        poll = Poll(data={'name': "poll"})
        poll_id = poll.save()
        poll = Poll.get(poll_id)

        poll.add_result_files([(uploaded_file_path, uploaded_filename)])
        self.assertEqual(1, len(poll.get_result_files()))

        poll.remove_results()
        self.assertEqual(0, len(poll.get_result_files()))