submissions.tests.test_view_reload_submission.InvalidReplaceSubmissionViewTest.test_task_called() - Code Metrics - Inspection of ":bug: fix bug in reload submission" - cnr-ibba/IMAGE-InjectTool - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — devel ( ae9b96...8edacd )

by Paolo

created 2020-05-22 19:21 UTC

InvalidReplaceSubmissionViewTest.test_task_called() A

↳ Parent: submissions.tests.test_view_reload_submission

Complexity

Conditions

Size

Total Lines	2
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	2
dl	0
loc	2
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,
    StatusMixinTestCase)
from common.constants import (
    CRB_ANIM_TYPE, CRYOWEB_TYPE, TEMPLATE_TYPE, WAITING)
from uid.models import Submission
from uid.tests import DataSourceMixinTestCase

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


class TestBase(SubmissionFormMixin, DataSourceMixinTestCase, TestCase):
    fixtures = [
        "uid/user",
        "uid/dictcountry",
        "uid/dictrole",
        "uid/organization",
        "submissions/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, version="reload"):
        """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': version,
            '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('submissions.views.ImportCryowebTask.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 SuccessfulReplaceSubmissionViewTest(
        SuccessfulReloadMixin, OwnerMixinTestCase, TestBase):
    """Test reloading a new file without changing version or ds type"""

    # patch to simulate data load
    @patch('submissions.views.ImportCryowebTask.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(version="test"),
            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('submissions.views.ImportCryowebTask.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 InvalidReplaceSubmissionViewTest(
        InvalidFormMixinTestCase, OwnerMixinTestCase, TestBase):
    """Test reloading a new file with changing version or ds type"""

    # patch to simulate data load
    @patch('submissions.views.ImportCryowebTask.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(
                version="collision"),
            follow=True)

        self.my_task = my_task

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


class ReloadValidationTest(TestBase):
    def common_check(self, response, my_task):
        # 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_encoding(self, my_task):
        # submit a cryoweb like dictionary
        response = self.client.post(
            self.url,
            self.get_data(ds_file="latin_type"))

        # check errors
        self.common_check(response, my_task)

    @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
        self.common_check(response, my_task)

    @patch('xlrd.book.Book.sheet_names', return_value=['animal', 'sample'])
    @patch('submissions.views.ImportTemplateTask.delay')
    def test_template_issues_in_sheets(self, my_task, my_excel):
        # submit a template file
        response = self.client.post(
            self.url,
            self.get_data(ds_file=TEMPLATE_TYPE))

        # check errors
        self.common_check(response, my_task)

        self.assertTrue(my_excel.called)

    @patch.dict(

            "excel.helpers.exceltemplate.TEMPLATE_COLUMNS",
            {'breed': ["a column"]})
    @patch('submissions.views.ImportTemplateTask.delay')
    def test_template_issues_in_columns(self, my_task):
        # submit a template file
        response = self.client.post(
            self.url,
            self.get_data(ds_file=TEMPLATE_TYPE))

        # check errors
        self.common_check(response, my_task)


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		StatusMixinTestCase)
19		from common.constants import (
20		CRB_ANIM_TYPE, CRYOWEB_TYPE, TEMPLATE_TYPE, WAITING)
21		from uid.models import Submission
22		from uid.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		"uid/user",
32		"uid/dictcountry",
33		"uid/dictrole",
34		"uid/organization",
35		"submissions/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, version="reload"):
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': version,
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('submissions.views.ImportCryowebTask.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 SuccessfulReplaceSubmissionViewTest(
152		SuccessfulReloadMixin, OwnerMixinTestCase, TestBase):
153		"""Test reloading a new file without changing version or ds type"""
154
155		# patch to simulate data load
156		@patch('submissions.views.ImportCryowebTask.delay')
157		def setUp(self, my_task):
158		# call base method
159		super().setUp()
160
161		# this post request create a new data_source file
162		self.response = self.client.post(
163		self.url,
164		self.get_data(version="test"),
165		follow=True)
166
167		# setting task
168		self.my_task = my_task
169
170		# get submission, with the new data_source file
171		self.submission = Submission.objects.get(pk=1)
172
173
174		class InvalidReloadSubmissionViewTest(
175		InvalidFormMixinTestCase, OwnerMixinTestCase, TestBase):
176
177		# patch to simulate data load
178		@patch('submissions.views.ImportCryowebTask.delay')
179		def setUp(self, my_task):
180		# call base method
181		super().setUp()
182
183		self.response = self.client.post(self.url, {})
184		self.my_task = my_task
185
186		def test_task_called(self):
187		self.assertFalse(self.my_task.called)
188
189
190		class InvalidReplaceSubmissionViewTest(
191		InvalidFormMixinTestCase, OwnerMixinTestCase, TestBase):
192		"""Test reloading a new file with changing version or ds type"""
193
194		# patch to simulate data load
195		@patch('submissions.views.ImportCryowebTask.delay')
196		def setUp(self, my_task):
197		# call base method
198		super().setUp()
199
200		# this post request create a new data_source file
201		self.response = self.client.post(
202		self.url,
203		self.get_data(
204		version="collision"),
205		follow=True)
206
207		self.my_task = my_task
208
209		def test_task_called(self):
210		self.assertFalse(self.my_task.called)
211
212
213		class ReloadValidationTest(TestBase):
214		def common_check(self, response, my_task):
215		# check errors
216		form = response.context.get('form')
217		self.assertGreater(len(form.errors), 0)
218
219		# test task
220		self.assertFalse(my_task.called)
221
222		@patch('submissions.views.ImportCRBAnimTask.delay')
223		def test_crb_anim_wrong_encoding(self, my_task):
224		# submit a cryoweb like dictionary
225		response = self.client.post(
226		self.url,
227		self.get_data(ds_file="latin_type"))
228
229		# check errors
230		self.common_check(response, my_task)
231
232		@patch('submissions.views.ImportCRBAnimTask.delay')
233		def test_crb_anim_wrong_columns(self, my_task):
234		# submit a cryoweb like dictionary
235		response = self.client.post(
236		self.url,
237		self.get_data(ds_file="not_valid_crbanim"))
238
239		# check errors
240		self.common_check(response, my_task)
241
242		@patch('xlrd.book.Book.sheet_names', return_value=['animal', 'sample'])
243		@patch('submissions.views.ImportTemplateTask.delay')
244		def test_template_issues_in_sheets(self, my_task, my_excel):
245		# submit a template file
246		response = self.client.post(
247		self.url,
248		self.get_data(ds_file=TEMPLATE_TYPE))
249
250		# check errors
251		self.common_check(response, my_task)
252
253		self.assertTrue(my_excel.called)
254
255	View Code Duplication	@patch.dict(
		0 ignored issues – show Duplication introduced 2019-10-01 15:11 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
256		"excel.helpers.exceltemplate.TEMPLATE_COLUMNS",
257		{'breed': ["a column"]})
258		@patch('submissions.views.ImportTemplateTask.delay')
259		def test_template_issues_in_columns(self, my_task):
260		# submit a template file
261		response = self.client.post(
262		self.url,
263		self.get_data(ds_file=TEMPLATE_TYPE))
264
265		# check errors
266		self.common_check(response, my_task)
267
268
269		class CRBAnimReloadSubmissionViewTest(
270		SuccessfulReloadMixin, TestBase):
271
272		@patch('submissions.views.ImportCRBAnimTask.delay')
273		def setUp(self, my_task):
274		# call base method
275		super().setUp()
276
277		# get a submission object
278		self.submission = Submission.objects.get(pk=1)
279
280		# change template type
281		self.submission.datasource_type = CRB_ANIM_TYPE
282		self.submission.save()
283
284		# this post request create a new data_source file
285		self.response = self.client.post(
286		self.url,
287		self.get_data(ds_file=CRB_ANIM_TYPE),
288		follow=True)
289
290		# track task
291		self.my_task = my_task
292
293
294		class TemplateReloadSubmissionViewTest(
295		SuccessfulReloadMixin, TestBase):
296
297		@patch('submissions.views.ImportTemplateTask.delay')
298		def setUp(self, my_task):
299		# call base method
300		super().setUp()
301
302		# get a submission object
303		self.submission = Submission.objects.get(pk=1)
304
305		# change template type
306		self.submission.datasource_type = TEMPLATE_TYPE
307		self.submission.save()
308
309		# this post request create a new data_source file
310		self.response = self.client.post(
311		self.url,
312		self.get_data(ds_file=TEMPLATE_TYPE),
313		follow=True)
314
315		# track task
316		self.my_task = my_task
317

cnr-ibba / IMAGE-InjectTool

Push — devel ( ae9b96...8edacd )

InvalidReplaceSubmissionViewTest.test_task_called() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like