biosample.tests.test_submit

Complexity

Total Complexity

34

Size/Duplication

Total Lines	466
Duplicated Lines	24.68 %

Importance

Changes

0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	ExpiredTokenViewTest.generate_token()	0	9	1
A	ErrorSubmitViewtest.test_ownership()	11	11	1
A	ExpiredTokenViewTest.test_expired_token()	0	9	1
A	NoSubmitViewTest.test_submission_waiting()	5	5	1
A	NoSubmitViewTest.__common_stuff()	23	23	1
A	NoSubmitViewTest.test_submission_error()	5	5	1
A	CreateTokenSubmitViewTest.setUpClass()	0	7	1
A	CreateTokenSubmitViewTest.tearDownClass()	0	4	1
A	NoTokenSubmitViewTest.generate_token()	0	10	2
A	ErrorSubmitViewtest.setUp()	20	20	1
A	ErrorTokenSubmitViewTest.setUp()	0	31	1
A	SubmitMixin.setUp()	0	31	1
A	SuccessfulSubmitViewTest.test_redirect()	0	5	1
A	ErrorTokenSubmitViewTest.test_issue_with_biosample()	0	9	1
A	InvalidSubmitViewTest.setUp()	0	7	1
A	SuccessfulSubmitViewTest.generate_token()	0	6	1
A	ErrorSubmitViewtest.test_does_not_exists()	11	11	1
A	SubmitViewTest.test_form_inputs()	0	9	1
A	TestMixin.setUp()	0	3	1
A	NoSubmitViewTest.setUp()	16	16	1
A	SuccessfulSubmitViewTest.test_valid_token()	0	8	1
A	SubmitViewTest.setUp()	0	7	1
A	NoSubmitViewTest.test_submission_completed()	5	5	1
A	SubmitViewTest.test_url_resolves_view()	0	3	1
A	SubmitMixin.setUpClass()	0	9	1
A	CreateTokenSubmitViewTest.setUp()	0	36	1
A	InvalidSubmitViewTest.test_status_code()	0	4	1
A	SuccessfulSubmitViewTest.test_submit_status()	0	14	1
A	SubmitMixin.tearDownClass()	0	8	2
A	NoTokenSubmitViewTest.test_no_token()	0	9	1
A	NoSubmitViewTest.test_submission_submitted()	5	5	1
A	SubmitMixin.generate_token()	0	4	1

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Oct  9 16:05:54 2018

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

import redis

from pyUSIrest.exceptions import USIConnectionError

from unittest.mock import Mock, patch

from django.test import Client, TestCase
from django.urls import resolve, reverse
from django.conf import settings
from django.utils import timezone

from uid.models import Submission
from common.constants import (
    WAITING, ERROR, READY, SUBMITTED, COMPLETED)
from common.tests import (
        FormMixinTestCase, MessageMixinTestCase, InvalidFormMixinTestCase)

from ..forms import SubmitForm
from ..views import SubmitView, TOKEN_DURATION_THRESHOLD

from .session_enabled_test_case import SessionEnabledTestCase
from .common import generate_token, TOKEN_DURATION


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

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

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


class SubmitViewTest(TestMixin, FormMixinTestCase, TestCase):
    form_class = SubmitForm

    def setUp(self):
        # call base methods
        super(SubmitViewTest, self).setUp()

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

    def test_url_resolves_view(self):
        view = resolve('/biosample/submit/')
        self.assertIsInstance(view.func.view_class(), SubmitView)

    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', 4)
        self.assertContains(self.response, '<input type="hidden"', 3)
        self.assertContains(self.response, 'type="password"', 1)


# --- testing view


class SubmitMixin(TestMixin, MessageMixinTestCase, SessionEnabledTestCase):
    @classmethod
    def setUpClass(cls):
        # calling my base class setup
        super().setUpClass()

        cls.redis = redis.StrictRedis(
            host=settings.REDIS_HOST,
            port=settings.REDIS_PORT,
            db=settings.REDIS_DB)

    @classmethod
    def tearDownClass(cls):
        key = "token:submission:1:test"

        if cls.redis.exists(key):
            cls.redis.delete(key)

        super().tearDownClass()

    @patch('biosample.views.SplitSubmissionTask.delay')
    def setUp(self, my_submit):
        # call base methods
        super(SubmitMixin, self).setUp()

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

        # set a status which I can submit
        submission.status = READY
        submission.save()

        # track submission ID
        self.submission_id = submission.id

        # track owner
        self.owner = submission.owner

        # generate a valid token
        self.generate_token()

        # get the url for dashboard (make request)
        self.url = reverse('biosample:submit')
        self.response = self.client.post(
            self.url, {
                'submission_id': self.submission_id
            }
        )

        # track my patched function
        self.my_submit = my_submit

    def generate_token(self):
        """Placeholder for token generation"""

        self.fail("Please define this method")


class SuccessfulSubmitViewTest(SubmitMixin):
    def generate_token(self):
        """generate a valid token"""
        session = self.get_session()
        session['token'] = generate_token()
        session.save()
        self.set_session_cookies(session)

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

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

    def test_submit_status(self):
        """check submission to biosample started and submission.state"""

        # check validation started
        self.assertTrue(self.my_submit.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 biosample submission")

    def test_valid_token(self):
        """check that a valid token is writtein in redis"""

        key = "token:submission:{submission_id}:{username}".format(
            submission_id=self.submission_id,
            username=self.owner.username)

        self.assertIsNotNone(self.redis.get(key))


# --- issues with token


class NoTokenSubmitViewTest(SubmitMixin):
    """Do a submission without a token"""

    def generate_token(self):
        """remove token from session if present """

        # get session and remove token
        session = self.get_session()

        if 'token' in session:
            del(session['token'])
            session.save()
            self.set_session_cookies(session)

    def test_no_token(self):
        """check no token redirects to form"""

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

        self.check_messages(
            self.response,
            "error",
            "You haven't generated any token yet")


class ExpiredTokenViewTest(SubmitMixin):
    def generate_token(self):
        """generate an expired token"""

        session = self.get_session()
        now = int(timezone.now().timestamp())
        session['token'] = generate_token(
            now - (TOKEN_DURATION-TOKEN_DURATION_THRESHOLD))
        session.save()
        self.set_session_cookies(session)

    def test_expired_token(self):
        """check that an expired token redirects to form"""

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

        self.check_messages(
            self.response,
            "error",
            "Your token is expired or near to expire")


class CreateTokenSubmitViewTest(SuccessfulSubmitViewTest):
    """Test that by providing submission id and password I can do a
    submission"""

    @classmethod
    def setUpClass(cls):
        # calling my base class setup
        super().setUpClass()

        cls.mock_get_patcher = patch('pyUSIrest.auth.requests.get')
        cls.mock_get = cls.mock_get_patcher.start()

    @classmethod
    def tearDownClass(cls):
        cls.mock_get_patcher.stop()
        super().tearDownClass()

    @patch('biosample.views.SplitSubmissionTask.delay')
    def setUp(self, my_submit):
        """Custom setUp"""

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

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

        # set a status which I can submit
        submission.status = READY
        submission.save()

        # track submission ID
        self.submission_id = submission.id

        # track owner
        self.owner = submission.owner

        # generate token
        self.mock_get.return_value = Mock()
        self.mock_get.return_value.text = generate_token()
        self.mock_get.return_value.status_code = 200

        self.data = {
            'password': 'image-password',
            'submission_id': self.submission_id
        }

        # get the url for dashboard (make request)
        self.url = reverse('biosample:submit')
        self.response = self.client.post(self.url, self.data)

        # track my patched function
        self.my_submit = my_submit


class ErrorTokenSubmitViewTest(SubmitMixin):
    @patch("pyUSIrest.auth.Auth", side_effect=USIConnectionError("test"))
    def setUp(self, my_auth):
        """Custom setUp"""

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

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

        # set a status which I can submit
        submission.status = READY
        submission.save()

        # track submission ID
        self.submission_id = submission.id

        # track owner
        self.owner = submission.owner

        self.data = {
            'password': 'image-password',
            'submission_id': self.submission_id
        }

        # get the url for dashboard (make request)
        self.url = reverse('biosample:submit')
        self.response = self.client.post(self.url, self.data)

        # track my patched function
        self.my_auth = my_auth

    def test_issue_with_biosample(self):
        """check that issues with biosample redirects to form"""

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

        self.check_messages(
            self.response,
            "error",
            "Unable to generate token")

# --- check status before submission


class NoSubmitViewTest(TestMixin, MessageMixinTestCase, TestCase):

This code seems to be duplicated in your project.

    """No submission if status is not OK"""

    @patch('biosample.views.SplitSubmissionTask.delay')
    def setUp(self, my_submit):
        # call base methods
        super(NoSubmitViewTest, self).setUp()

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

        # track submission ID
        self.submission_id = submission.id

        # set URL
        self.url = reverse('biosample:submit')

        # track my patched function
        self.my_submit = my_submit

    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_submit.call_count, 0)

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

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

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

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

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

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

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

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


# errors with form


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

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

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

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


# --- submission owenership


class ErrorSubmitViewtest(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('biosample.views.SplitSubmissionTask.delay')
    def setUp(self, my_submit):
        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 ready
        submission.status = READY
        submission.save()

        # track submission ID
        self.submission_id = submission.id

        # get the url for dashboard
        self.url = reverse('biosample:submit')

        # track my patched function
        self.my_submit = my_submit

    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_submit.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_submit.called)