validation.tests.test_views

Complexity

Total Complexity

24

Size/Duplication

Total Lines	277
Duplicated Lines	42.96 %

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	NoValidateViewTest.setUp()	16	16	1
A	ValidateViewTest.test_url_resolves_view()	0	3	1
A	SuccessfulValidateViewTest.test_validation_status()	0	14	1
A	ValidateViewTest.test_status_code()	0	2	1
A	ValidateViewTest.setUp()	0	7	1
A	ValidateViewTest.test_csrf()	0	2	1
A	NoValidateViewTest.test_submission_error()	5	5	1
A	SuccessfulValidateViewTest.test_redirect()	0	5	1
A	NoValidateViewTest.test_submission_completed()	5	5	1
A	NoValidateViewTest.test_submission_submitted()	5	5	1
A	ErrorValidateViewtest.test_does_not_exists()	11	11	1
A	NoValidateViewTest.test_submission_ready()	5	5	1
A	InvalidValidateViewTest.setUp()	0	11	1
A	InvalidValidateViewTest.test_status_code()	0	4	1
A	ValidateViewTest.test_contains_form()	0	4	1
A	ErrorValidateViewtest.test_ownership()	11	11	1
A	ErrorValidateViewtest.setUp()	20	20	1
A	InvalidValidateViewTest.test_novalidation()	0	4	1
A	NoValidateViewTest.test_submission_waiting()	5	5	1
A	ValidateViewTest.test_redirection()	0	10	1
A	TestMixin.setUp()	0	3	1
A	ValidateViewTest.test_form_inputs()	0	7	1
A	SuccessfulValidateViewTest.setUp()	0	25	1
A	NoValidateViewTest.__common_stuff()	23	23	1

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Oct  5 11:39:34 2018

@author: Paolo Cozzi <cozzi@ibba.cnr.it>
"""

from unittest.mock import patch

from django.test import Client, TestCase
from django.urls import resolve, reverse

from common.constants import (
    WAITING, ERROR, SUBMITTED, LOADED, COMPLETED, READY)
from uid.models import Submission

from ..forms import ValidateForm
from ..views import ValidateView


class TestMixin(object):
    """Base class for validation tests"""

    fixtures = [
        "uid/user",
        "uid/dictcountry",
        "uid/dictrole",
        "uid/organization",
        "uid/submission"
    ]

    def setUp(self):
        self.client = Client()
        self.client.login(username='test', password='test')


class ValidateViewTest(TestMixin, TestCase):
    def setUp(self):
        # call base methods
        super(ValidateViewTest, self).setUp()

        # get the url for dashboard
        self.url = reverse('validation:validate')
        self.response = self.client.get(self.url)

    def test_redirection(self):
        '''Non Authenticated user are directed to login page'''

        login_url = reverse("login")
        client = Client()
        response = client.get(self.url)

        self.assertRedirects(
            response, '{login_url}?next={url}'.format(
                login_url=login_url, url=self.url)
        )

    def test_status_code(self):
        self.assertEqual(self.response.status_code, 200)

    def test_url_resolves_view(self):
        view = resolve('/validation/validate')
        self.assertIsInstance(view.func.view_class(), ValidateView)

    def test_csrf(self):
        self.assertContains(self.response, 'csrfmiddlewaretoken')

    def test_contains_form(self):
        form = self.response.context.get('form')

        self.assertIsInstance(form, ValidateForm)

    def test_form_inputs(self):
        '''
        The view two inputs: csrf, submission_id"
        '''

        # total input is n of form fields + (CSRF)
        self.assertContains(self.response, '<input', 2)


class SuccessfulValidateViewTest(TestMixin, TestCase):
    @patch('validation.views.ValidateTask.delay')
    def setUp(self, my_validation):
        # call base methods
        super(SuccessfulValidateViewTest, self).setUp()

        # get a submission object
        submission = Submission.objects.get(pk=1)

        # set a status which I can validate
        submission.status = LOADED
        submission.save()

        # track submission ID
        self.submission_id = submission.id

        # get the url for dashboard
        self.url = reverse('validation:validate')
        self.response = self.client.post(
            self.url, {
                'submission_id': self.submission_id
            }
        )

        # track my patched function
        self.my_validation = my_validation

    def test_redirect(self):
        """test redirection after validation occurs"""

        url = reverse('submissions:detail', kwargs={'pk': self.submission_id})
        self.assertRedirects(self.response, url)

    def test_validation_status(self):
        """check validation started and submission.state"""

        # check validation started
        self.assertTrue(self.my_validation.called)

        # get submission object
        submission = Submission.objects.get(pk=self.submission_id)

        # check submission.state changed
        self.assertEqual(submission.status, WAITING)
        self.assertEqual(
            submission.message,
            "waiting for data validation")


class NoValidateViewTest(TestMixin, TestCase):

This code seems to be duplicated in your project.

    @patch('validation.views.ValidateTask.delay')
    def setUp(self, my_validation):
        # call base methods
        super(NoValidateViewTest, self).setUp()

        # get a submission object
        submission = Submission.objects.get(pk=1)

        # track submission ID
        self.submission_id = submission.id

        # get the url for dashboard
        self.url = reverse('validation:validate')

        # track my patched function
        self.my_validation = my_validation

    def __common_stuff(self, status):
        """Common function for statuses"""

        # get submission
        submission = Submission.objects.get(pk=self.submission_id)

        # update status and save
        submission.status = status
        submission.save()

        # call valiate views with cyrrent status WAITING
        response = self.client.post(
            self.url, {
                'submission_id': self.submission_id
            }
        )

        # assert redirect
        url = reverse('submissions:detail', kwargs={'pk': self.submission_id})
        self.assertRedirects(response, url)

        # get number of call (equal to first call)
        self.assertEqual(self.my_validation.call_count, 0)

    def test_submission_waiting(self):
        """check no validation with submission status WAITING"""

        # valutate status and no function called
        self.__common_stuff(WAITING)

    def test_submission_ready(self):
        """check no validation with submission status READY"""

        # valutate status and no function called
        self.__common_stuff(READY)

    def test_submission_error(self):
        """check no validation with submission status ERROR"""

        # valutate status and no function called
        self.__common_stuff(ERROR)

    def test_submission_submitted(self):
        """check no validation with submission status SUBMITTED"""

        # valutate status and no function called
        self.__common_stuff(SUBMITTED)

    def test_submission_completed(self):
        """check no validation with submission status COMPLETED"""

        # valutate status and no function called
        self.__common_stuff(COMPLETED)


class InvalidValidateViewTest(TestMixin, TestCase):
    @patch('validation.views.ValidateTask.delay')
    def setUp(self, my_validation):
        # call base methods
        super(InvalidValidateViewTest, self).setUp()

        # get the url for dashboard
        self.url = reverse('validation:validate')
        self.response = self.client.post(self.url, {})

        # track my patched function
        self.my_validation = my_validation

    def test_status_code(self):
        """Invalid post data returns the form"""

        self.assertEqual(self.response.status_code, 200)

    def test_novalidation(self):
        """check no validation process started"""

        self.assertFalse(self.my_validation.called)


class ErrorValidateViewtest(TestMixin, TestCase):

This code seems to be duplicated in your project.

    """A class to test submission not belonging to the user or which doesn't
    exists"""

    @patch('validation.views.ValidateTask.delay')
    def setUp(self, my_validation):
        self.client = Client()
        self.client.login(username='test2', password='test2')

        # get a submission object
        submission = Submission.objects.get(pk=1)

        # set a status which I can validate
        submission.status = LOADED
        submission.save()

        # track submission ID
        self.submission_id = submission.id

        # get the url for dashboard
        self.url = reverse('validation:validate')

        # track my patched function
        self.my_validation = my_validation

    def test_ownership(self):
        """Test a non-owner having a 404 response"""

        response = self.client.post(
            self.url, {
                'submission_id': self.submission_id
            }
        )

        self.assertEqual(response.status_code, 404)
        self.assertFalse(self.my_validation.called)

    def test_does_not_exists(self):
        """Test a submission which doesn't exists"""

        response = self.client.post(
            self.url, {
                'submission_id': 99
            }
        )

        self.assertEqual(response.status_code, 404)
        self.assertFalse(self.my_validation.called)