submissions.tests.test_view_reload_submission.TemplateReloadSubmissionViewTest.test_message() - Code Metrics - Inspection of ":sparkles: import from Template file" - cnr-ibba/IMAGE-InjectTool - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#40)

by Paolo

created 2019-07-09 14:58 UTC

submissions.tests.test_view_reload_submission.TemplateReloadSubmissionViewTest.test_message() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines	5
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	5
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	1
nop	1

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Nov  8 16:35:48 2018

@author: Paolo Cozzi <[email protected]>
"""

import os

from unittest.mock import patch

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

from common.tests import (
    FormMixinTestCase, OwnerMixinTestCase, InvalidFormMixinTestCase,
    MessageMixinTestCase, StatusMixinTestCase)
from common.constants import (
    CRB_ANIM_TYPE, CRYOWEB_TYPE, TEMPLATE_TYPE, ERROR, WAITING)
from image_app.models import Submission
from image_app.tests import DataSourceMixinTestCase

from .common import SubmissionFormMixin
from ..views import ReloadSubmissionView
from ..forms import ReloadForm


class TestBase(SubmissionFormMixin, DataSourceMixinTestCase, TestCase):
    fixtures = [
        "image_app/user",
        "image_app/dictcountry",
        "image_app/dictrole",
        "image_app/organization",
        "image_app/submission"
    ]

    def setUp(self):
        # call base method
        super().setUp()

        # login a test user (defined in fixture)
        self.client = Client()
        self.client.login(username='test', password='test')

        self.url = reverse('submissions:reload', kwargs={'pk': 1})

    def tearDown(self):
        if hasattr(self, "submission"):
            # read written file
            self.submission.refresh_from_db()

            # delete uploaded file if exists
            fullpath = self.submission.uploaded_file.path

            if os.path.exists(fullpath):
                os.remove(fullpath)

        # call super method
        super().tearDown()

    def get_data(self, ds_file=CRYOWEB_TYPE):
        """Get data dictionary"""

        ds_type, ds_path = super().get_data(ds_file)

        # define test data
        data = {
            'uploaded_file': open(ds_path, "rb"),
            'datasource_type': ds_type,
            'datasource_version': "reload",
            'agree_reload': True
        }

        return data


class ReloadSubmissionViewTest(
        FormMixinTestCase, OwnerMixinTestCase, TestBase):

    form_class = ReloadForm

    def setUp(self):
        # call base method
        super().setUp()

        self.response = self.client.get(self.url)

    def test_url_resolves_view(self):
        view = resolve('/submissions/1/reload/')
        self.assertIsInstance(view.func.view_class(), ReloadSubmissionView)

    def test_form_inputs(self):

        # total input is n of form fields + (CSRF) + 1 file + 1 checkbox
        # +1 select + text
        self.assertContains(self.response, '<input', 4)
        self.assertContains(self.response, '<select', 1)
        self.assertContains(self.response, 'type="file"', 1)
        self.assertContains(self.response, 'type="checkbox"', 1)

    def test_reload_not_found_status_code(self):
        url = reverse('submissions:reload', kwargs={'pk': 99})
        response = self.client.get(url)
        self.assertEqual(response.status_code, 404)

    def test_contains_navigation_links(self):
        """Contain links to DetailSubmissionView"""

        link = reverse('submissions:detail', kwargs={'pk': 1})
        self.assertContains(self.response, 'href="{0}"'.format(link))


class SuccessfulReloadMixin(StatusMixinTestCase):
    def test_redirect(self):
        url = reverse('submissions:detail', kwargs={'pk': 1})
        self.assertRedirects(self.response, url)

    def test_task_called(self):
        self.assertTrue(self.my_task.called)

    def test_submission_status(self):
        self.submission.refresh_from_db()
        self.assertEqual(self.submission.status, WAITING)
        self.assertEqual(
            self.submission.message,
            "waiting for data loading")


class SuccessfulReloadSubmissionViewTest(
        SuccessfulReloadMixin, OwnerMixinTestCase, TestBase):
    # patch to simulate data load
    @patch('cryoweb.tasks.import_from_cryoweb.delay')
    def setUp(self, my_task):
        # call base method
        super().setUp()

        # this post request create a new data_source file
        self.response = self.client.post(
            self.url,
            self.get_data(),
            follow=True)

        # setting task
        self.my_task = my_task

        # get submission, with the new data_source file
        self.submission = Submission.objects.get(pk=1)


class InvalidReloadSubmissionViewTest(
        InvalidFormMixinTestCase, OwnerMixinTestCase, TestBase):

    # patch to simulate data load
    @patch('cryoweb.tasks.import_from_cryoweb.delay')
    def setUp(self, my_task):
        # call base method
        super().setUp()

        self.response = self.client.post(self.url, {})
        self.my_task = my_task

    def test_task_called(self):
        self.assertFalse(self.my_task.called)


class ReloadValidationTest(TestBase):
    @patch('submissions.views.ImportCRBAnimTask.delay')
    def test_crb_anim_wrong_encoding(self, my_task):
        # submit a cryoweb like dictionary
        response = self.client.post(
            self.url,
            self.get_data(ds_file="latin_type"))

        # check errors
        form = response.context.get('form')
        self.assertGreater(len(form.errors), 0)

        # test task
        self.assertFalse(my_task.called)

    @patch('submissions.views.ImportCRBAnimTask.delay')
    def test_crb_anim_wrong_columns(self, my_task):
        # submit a cryoweb like dictionary
        response = self.client.post(
            self.url,
            self.get_data(ds_file="not_valid_crbanim"))

        # check errors
        form = response.context.get('form')
        self.assertGreater(len(form.errors), 0)

        # test task
        self.assertFalse(my_task.called)


class CRBAnimReloadSubmissionViewTest(
        SuccessfulReloadMixin, TestBase):

    @patch('submissions.views.ImportCRBAnimTask.delay')
    def setUp(self, my_task):
        # call base method
        super().setUp()

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

        # change template type
        self.submission.datasource_type = CRB_ANIM_TYPE
        self.submission.save()

        # this post request create a new data_source file
        self.response = self.client.post(
            self.url,
            self.get_data(ds_file=CRB_ANIM_TYPE),
            follow=True)

        # track task
        self.my_task = my_task


class TemplateReloadSubmissionViewTest(
        SuccessfulReloadMixin, TestBase):

    @patch('submissions.views.ImportTemplateTask.delay')
    def setUp(self, my_task):
        # call base method
        super().setUp()

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

        # change template type
        self.submission.datasource_type = TEMPLATE_TYPE
        self.submission.save()

        # this post request create a new data_source file
        self.response = self.client.post(
            self.url,
            self.get_data(ds_file=TEMPLATE_TYPE),
            follow=True)

        # track task
        self.my_task = my_task


1			#!/usr/bin/env python3
2			# -- coding: utf-8 --
3			"""
4			Created on Thu Nov 8 16:35:48 2018
5
6			@author: Paolo Cozzi <[email protected]>
7			"""
8
9			import os
10
11			from unittest.mock import patch
12
13			from django.test import TestCase, Client
14			from django.urls import resolve, reverse
15
16			from common.tests import (
17			FormMixinTestCase, OwnerMixinTestCase, InvalidFormMixinTestCase,
18			MessageMixinTestCase, StatusMixinTestCase)
19			from common.constants import (
20			CRB_ANIM_TYPE, CRYOWEB_TYPE, TEMPLATE_TYPE, ERROR, WAITING)
21			from image_app.models import Submission
22			from image_app.tests import DataSourceMixinTestCase
23
24			from .common import SubmissionFormMixin
25			from ..views import ReloadSubmissionView
26			from ..forms import ReloadForm
27
28
29			class TestBase(SubmissionFormMixin, DataSourceMixinTestCase, TestCase):
30			fixtures = [
31			"image_app/user",
32			"image_app/dictcountry",
33			"image_app/dictrole",
34			"image_app/organization",
35			"image_app/submission"
36			]
37
38			def setUp(self):
39			# call base method
40			super().setUp()
41
42			# login a test user (defined in fixture)
43			self.client = Client()
44			self.client.login(username='test', password='test')
45
46			self.url = reverse('submissions:reload', kwargs={'pk': 1})
47
48			def tearDown(self):
49			if hasattr(self, "submission"):
50			# read written file
51			self.submission.refresh_from_db()
52
53			# delete uploaded file if exists
54			fullpath = self.submission.uploaded_file.path
55
56			if os.path.exists(fullpath):
57			os.remove(fullpath)
58
59			# call super method
60			super().tearDown()
61
62			def get_data(self, ds_file=CRYOWEB_TYPE):
63			"""Get data dictionary"""
64
65			ds_type, ds_path = super().get_data(ds_file)
66
67			# define test data
68			data = {
69			'uploaded_file': open(ds_path, "rb"),
70			'datasource_type': ds_type,
71			'datasource_version': "reload",
72			'agree_reload': True
73			}
74
75			return data
76
77
78			class ReloadSubmissionViewTest(
79			FormMixinTestCase, OwnerMixinTestCase, TestBase):
80
81			form_class = ReloadForm
82
83			def setUp(self):
84			# call base method
85			super().setUp()
86
87			self.response = self.client.get(self.url)
88
89			def test_url_resolves_view(self):
90			view = resolve('/submissions/1/reload/')
91			self.assertIsInstance(view.func.view_class(), ReloadSubmissionView)
92
93			def test_form_inputs(self):
94
95			# total input is n of form fields + (CSRF) + 1 file + 1 checkbox
96			# +1 select + text
97			self.assertContains(self.response, '<input', 4)
98			self.assertContains(self.response, '<select', 1)
99			self.assertContains(self.response, 'type="file"', 1)
100			self.assertContains(self.response, 'type="checkbox"', 1)
101
102			def test_reload_not_found_status_code(self):
103			url = reverse('submissions:reload', kwargs={'pk': 99})
104			response = self.client.get(url)
105			self.assertEqual(response.status_code, 404)
106
107			def test_contains_navigation_links(self):
108			"""Contain links to DetailSubmissionView"""
109
110			link = reverse('submissions:detail', kwargs={'pk': 1})
111			self.assertContains(self.response, 'href="{0}"'.format(link))
112
113
114			class SuccessfulReloadMixin(StatusMixinTestCase):
115			def test_redirect(self):
116			url = reverse('submissions:detail', kwargs={'pk': 1})
117			self.assertRedirects(self.response, url)
118
119			def test_task_called(self):
120			self.assertTrue(self.my_task.called)
121
122			def test_submission_status(self):
123			self.submission.refresh_from_db()
124			self.assertEqual(self.submission.status, WAITING)
125			self.assertEqual(
126			self.submission.message,
127			"waiting for data loading")
128
129
130			class SuccessfulReloadSubmissionViewTest(
131			SuccessfulReloadMixin, OwnerMixinTestCase, TestBase):
132			# patch to simulate data load
133			@patch('cryoweb.tasks.import_from_cryoweb.delay')
134			def setUp(self, my_task):
135			# call base method
136			super().setUp()
137
138			# this post request create a new data_source file
139			self.response = self.client.post(
140			self.url,
141			self.get_data(),
142			follow=True)
143
144			# setting task
145			self.my_task = my_task
146
147			# get submission, with the new data_source file
148			self.submission = Submission.objects.get(pk=1)
149
150
151			class InvalidReloadSubmissionViewTest(
152			InvalidFormMixinTestCase, OwnerMixinTestCase, TestBase):
153
154			# patch to simulate data load
155			@patch('cryoweb.tasks.import_from_cryoweb.delay')
156			def setUp(self, my_task):
157			# call base method
158			super().setUp()
159
160			self.response = self.client.post(self.url, {})
161			self.my_task = my_task
162
163			def test_task_called(self):
164			self.assertFalse(self.my_task.called)
165
166
167			class ReloadValidationTest(TestBase):
168			@patch('submissions.views.ImportCRBAnimTask.delay')
169			def test_crb_anim_wrong_encoding(self, my_task):
170			# submit a cryoweb like dictionary
171			response = self.client.post(
172			self.url,
173			self.get_data(ds_file="latin_type"))
174
175			# check errors
176			form = response.context.get('form')
177			self.assertGreater(len(form.errors), 0)
178
179			# test task
180			self.assertFalse(my_task.called)
181
182			@patch('submissions.views.ImportCRBAnimTask.delay')
183			def test_crb_anim_wrong_columns(self, my_task):
184			# submit a cryoweb like dictionary
185			response = self.client.post(
186			self.url,
187			self.get_data(ds_file="not_valid_crbanim"))
188
189			# check errors
190			form = response.context.get('form')
191			self.assertGreater(len(form.errors), 0)
192
193			# test task
194			self.assertFalse(my_task.called)
195
196
197			class CRBAnimReloadSubmissionViewTest(
198			SuccessfulReloadMixin, TestBase):
199
200			@patch('submissions.views.ImportCRBAnimTask.delay')
201			def setUp(self, my_task):
202			# call base method
203			super().setUp()
204
205			# get a submission object
206			self.submission = Submission.objects.get(pk=1)
207
208			# change template type
209			self.submission.datasource_type = CRB_ANIM_TYPE
210			self.submission.save()
211
212			# this post request create a new data_source file
213			self.response = self.client.post(
214			self.url,
215			self.get_data(ds_file=CRB_ANIM_TYPE),
216			follow=True)
217
218			# track task
219			self.my_task = my_task
220
221
222			class TemplateReloadSubmissionViewTest(
223			SuccessfulReloadMixin, TestBase):
224
225			@patch('submissions.views.ImportTemplateTask.delay')
226			def setUp(self, my_task):
227			# call base method
228			super().setUp()
229
230			# get a submission object
231			self.submission = Submission.objects.get(pk=1)
232
233			# change template type
234			self.submission.datasource_type = TEMPLATE_TYPE
235			self.submission.save()
236
237			# this post request create a new data_source file
238			self.response = self.client.post(
239			self.url,
240			self.get_data(ds_file=TEMPLATE_TYPE),
241			follow=True)
242
243			# track task
244			self.my_task = my_task
245

cnr-ibba / IMAGE-InjectTool

Pull Request — master (#40)

submissions.tests.test_view_reload_submission.TemplateReloadSubmissionViewTest.test_message() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like