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

# pylint: disable=C0111,C0103,C0321,R0904
import json
import tempfile
import os
import hashlib

from django.test import TestCase
from django.conf import settings
from mock import Mock, patch

from polls.models import PollResultFile, Poll
from utils.test import MongoTestCase, create_results_dir


def json_construc(data):
    return json.dumps(data, sort_keys=True, indent=4, separators=(',', ': '))


def make_temp_file(data):
    json_str = json_construc(data)
    file_ = tempfile.NamedTemporaryFile(suffix='.poll_result',
                                        delete=False)
    file_.write(json_str)
    file_.close()
    return file_.name


class PollResultFileTest(MongoTestCase):

    def setUp(self):
        create_results_dir()

        data = {}
        data['result'] = {}
        data['result']['0'] = {}
        data['result']['0']['polled'] = {}
        self.data = data

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

    def test_it_should_respond_to_pollster_username(self):
        data = self.data
        pollster_username = "encuestador1"
        data['pollster_username'] = pollster_username
        file_path = make_temp_file(data)
        result = PollResultFile(file_path)
        self.assertEqual(pollster_username, result.get_pollster_username())

    def test_it_should_respond_to_polled_count(self):
        data = {}
        data['result'] = {}

        for polled_count in range(1, 3):
            data['result'][str(polled_count - 1)] = {}
            file_path = make_temp_file(data)
            result = PollResultFile(file_path)
            self.assertEqual(polled_count, result.get_polled_count())

    def test_it_should_respond_to_poll_result_filename(self):
        file_path = make_temp_file({})
        poll_result = PollResultFile(file_path)

        filename = os.path.basename(file_path)
        self.assertEqual(filename, poll_result.get_file_name())

    def test_it_should_respond_to_upload_timestamp(self):
        time_string = "31/12/2000 23:59hs"

        data = self.data
        data['upload_timestamp'] = time_string
        file_path = make_temp_file(data)
        result = PollResultFile(file_path)
        self.assertEqual(time_string, result.get_upload_timestamp())

    def test_it_should_return_None_when_there_is_no_timestamp(self):
        data = self.data
        file_path = make_temp_file(data)
        result = PollResultFile(file_path)
        self.assertIsNone(result.get_upload_timestamp())

    def test_it_should_set_the_upload_timestamp(self):
        data = self.data
        file_path = make_temp_file(data)
        result = PollResultFile(file_path)
        expected_time_string = "31/12/1999 23:59hs"

        result.set_upload_timestamp(expected_time_string)

        time_string = result.get_upload_timestamp()
        self.assertEqual(expected_time_string, time_string)

    def test_the_upload_timestamp_should_be_persistent(self):
        expected_time_string = "31/12/1999 23:59hs"
        data = self.data
        file_path = make_temp_file(data)

        result = PollResultFile(file_path)
        result.set_upload_timestamp(expected_time_string)
        del(result)

        new_result_same_file = PollResultFile(file_path)
        time_string = new_result_same_file.get_upload_timestamp()
        self.assertEqual(expected_time_string, time_string)

    def test_it_should_be_available_for_his_related_poll_when_it_saves(self):
        poll = self.poll
        poll_id = poll.id.__str__()
        self.assertEqual(0, len(poll.get_result_files()))

        data = self.data
        data['poll_id'] = poll_id

        file_path = make_temp_file(data)
        result_file = PollResultFile(file_path)
        result_file.save()

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

    def test_it_should_saves_with_a_chosen_name(self):
        poll = self.poll
        poll_id = poll.id.__str__()
        self.assertEqual(0, len(poll.get_result_files()))

        data = self.data
        data['poll_id'] = poll_id

        file_path = make_temp_file(data)
        result_file = PollResultFile(file_path)
        result_file.name = chosen_name = 'super_name.poll_result'
        result_file.save()

        result_name = poll.get_result_files()[0].get_file_name()
        self.assertEqual(chosen_name, result_name)

    def test_it_should_respond_with_data_structure(self):
        data = self.data
        file_path = make_temp_file(data)
        poll_result_file = PollResultFile(file_path)

        expected_data = data
        self.assertEqual(expected_data, poll_result_file.get_data())

    def test_it_should_respond_with_absolute_url_for_poll_result_file(self):
        poll = self.poll
        poll_id = poll.id.__str__()
        data = self.data
        data['poll_id'] = poll_id

        file_path = make_temp_file(data)
        result_file = PollResultFile(file_path)

        expected_url = os.path.join(
            settings.RESULT_BCK_URL, poll_id, result_file.name)
        self.assertEqual(expected_url, result_file.get_absolute_url())

    def test_it_should_respond_with_hash(self):
        data = {}
        expected_hash = hashlib.md5(str(data)).hexdigest()

        data["upload_timestamp"] = "timestamp"
        file_path = make_temp_file(data)
        result_file = PollResultFile(file_path)

        self.assertEqual(expected_hash, result_file.hash)


class ExistenceTest(MongoTestCase):

    def setUp(self):
        poll = Poll({'name': 'poll'})
        poll_id = str(poll.save())
        self.poll = Poll.get(poll_id)

    def test_exists_when_other_poll_result_file_has_same_name(self):
        poll = self.poll
        poll_id = poll.id.__str__()
        data = {}
        data['poll_id'] = poll_id

        file_path = make_temp_file(data)
        result_file = PollResultFile(file_path)
        self.assertFalse(result_file.exists())

        result_file.save()
        self.assertTrue(result_file.exists())

    def test_it_should_respond_True_when_content_exists_already(self):
        poll = self.poll
        poll_id = poll.id.__str__()
        self.assertEqual(0, len(poll.get_result_files()))

        data = {}
        data['poll_id'] = poll_id

        file_path = make_temp_file(data)
        original_result_file = PollResultFile(file_path)
        original_result_file.save()
        self.assertEqual(1, len(poll.get_result_files()))

        file_path = make_temp_file(data)
        duplicated_result_file = PollResultFile(file_path)

        self.assertTrue(duplicated_result_file.exists())


class RueeTest(MongoTestCase):

    def test_it_should_get_all_ruee_as_unique_items(self):
        data = {}
        data['result'] = {}
        data['result']['0'] = {}
        data['result']['0']['polled'] = {}
        ruee1 = '1'
        data['result']['0']['polled']['RUEE'] = ruee1
        ruee2 = '2'
        data['result']['1'] = {}
        data['result']['1']['polled'] = {}
        data['result']['1']['polled']['RUEE'] = ruee2
        data['result']['2'] = {}
        data['result']['2']['polled'] = {}
        data['result']['2']['polled']['RUEE'] = ruee2

        json_str = json_construc(data)
        file_ = tempfile.NamedTemporaryFile(suffix='.poll_result',
                                            delete=False)
        file_.write(json_str)
        file_.close()
        file_path = file_.name

        result = PollResultFile(file_path)
        expected = set([ruee1, ruee2])
        self.assertEqual(expected, result.get_ruees())


class RemovePollResultFileTest(TestCase):

    def test_it_should_respond_to_delete(self):
        data = {}
        file_path = make_temp_file(data)
        result_file = PollResultFile(file_path)
        self.assertTrue(hasattr(result_file, 'delete'))

    def test_it_should_remove_the_file(self):
        data = {}
        file_path = make_temp_file(data)
        result_file = PollResultFile(file_path)
        result_file.delete()
        saved_file_path = result_file.file_path
        self.assertFalse(os.path.exists(saved_file_path))


class AuthoredByTest(TestCase):

    def test_it_should_be_True_if_user_is_in_result_file(self):
        username = "Is my result"
        user = Mock()
        user.username = username
        file_path = "a_path"
        with patch('__builtin__.open'), patch('polls.models.json'):
            prf = PollResultFile(file_path)
        prf.get_pollster_username = Mock(return_value=username)
        self.assertTrue(prf.is_authored_by(user))

    def test_it_should_be_False_if_user_is_not_in_result_file(self):
        username = "Is not my result"
        user = Mock()
        user.username = username
        file_path = "a_path"
        with patch('__builtin__.open'), patch('polls.models.json'):
            prf = PollResultFile(file_path)
        prf.get_pollster_username = Mock(return_value="Other pollster")
        self.assertFalse(prf.is_authored_by(user))


class PollAssignationTest(TestCase):

    def setUp(self):
        self.poll_id = "poll id"
        self.user = Mock(pollster=Mock())
        file_path = "a_path"
        with patch('__builtin__.open'), patch('polls.models.json'):
            self.prf = PollResultFile(file_path)
            self.prf.get_data = Mock(return_value={"poll_id": self.poll_id})

    def test_it_return_True_if_user_is_assigned_to_poll_in_result(self):
        user = self.user
        prf = self.prf
        mock_poll_id = Mock(id=self.poll_id)
        with patch('polls.models.Poll') as PollMock:
            PollMock.assigned_to_pollster.return_value = [mock_poll_id]
            self.assertTrue(prf.poll_is_assigned_to(user))

    def test_it_return_False_if_user_is_not_assigned_to_poll_in_result(self):
        user = self.user
        prf = self.prf
        mock_poll_id = Mock(id="poll id 2")
        with patch('polls.models.Poll') as PollMock:
            PollMock.assigned_to_pollster.return_value = [mock_poll_id]
            self.assertFalse(prf.poll_is_assigned_to(user))