excel.tests.test_helpers

Complexity

Total Complexity

12

Size/Duplication

Total Lines	198
Duplicated Lines	45.45 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	ExcelTemplateTestCase.setUp()	0	9	1
A	ExcelTemplateTestCase.test_get_animal_records()	0	5	1
A	ExcelTemplateTestCase.test_check_accuracies()	0	7	1
A	ExcelTemplateTestCase.test_check_columns()	0	7	1
A	ExcelTemplateTestCase.test_check_species()	19	19	1
A	ExcelTemplateTestCase.test_check_sex()	0	16	1
A	ExcelTemplateTestCase.check_generator()	0	3	1
A	ExcelTemplateTestCase.test_get_breed_records()	0	5	1
A	ExcelTemplateTestCase.test_check_sheets()	0	6	1
A	ExcelTemplateTestCase.test_get_sample_records()	0	5	1
A	ExcelMixin.test_upload_template()	33	33	1
A	ExcelMixin.check_errors()	34	34	1

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Jul  2 10:58:42 2019

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

import types
from collections import defaultdict

from django.test import TestCase

from common.constants import ERROR, LOADED
from common.tests import WebSocketMixin
from image_app.models import (
    Submission, Animal, Sample, DictCountry, DictSpecie, DictSex, db_has_data)

from ..helpers import ExcelTemplate, upload_template
from .common import BaseExcelMixin


class ExcelTemplateTestCase(BaseExcelMixin, TestCase):
    """Test excel class upload"""

    def setUp(self):
        # calling my base class setup
        super().setUp()

        # crate a Excel Template object
        self.reader = ExcelTemplate()

        # get filenames for DataSourceMixinTestCase.dst_path
        self.reader.read_file(self.dst_path)

    def test_check_sheets(self):
        # test check sheets method
        status, not_found = self.reader.check_sheets()

        self.assertTrue(status)
        self.assertEqual(not_found, [])

    def test_check_columns(self):
        # test check sheets method
        status, not_found = self.reader.check_columns()

        self.assertTrue(status)
        self.assertIsInstance(not_found, defaultdict)
        self.assertEqual(len(not_found), 0)

    def check_generator(self, records, length):
        self.assertIsInstance(records, types.GeneratorType)
        self.assertEqual(len(list(records)), length)

    def test_get_breed_records(self):
        """get_breed_records returns an iterator"""

        breeds = self.reader.get_breed_records()
        self.check_generator(breeds, 2)

    def test_get_animal_records(self):
        """get_animal_records returns an iterator"""

        animals = self.reader.get_animal_records()
        self.check_generator(animals, 3)

    def test_get_sample_records(self):
        """get_sample_records returns an iterator"""

        samples = self.reader.get_sample_records()
        self.check_generator(samples, 3)

    # TODO: pretty similar to CRBanim - move to a common mixin
    def test_check_species(self):

This code seems to be duplicated in your project.

        """Test check species method"""

        # get a country
        country = DictCountry.objects.get(label="United Kingdom")

        check, not_found = self.reader.check_species(country)

        self.assertTrue(check)
        self.assertEqual(len(not_found), 0)

        # changing species set
        DictSpecie.objects.filter(label='Sus scrofa').delete()

        check, not_found = self.reader.check_species(country)

        # the read species are not included in fixtures
        self.assertFalse(check)
        self.assertGreater(len(not_found), 0)

    # TODO: identical to CRBanim - move to a common mixin
    def test_check_sex(self):
        """Test check sex method"""

        check, not_found = self.reader.check_sex()

        self.assertTrue(check)
        self.assertEqual(len(not_found), 0)

        # changing sex set
        DictSex.objects.filter(label='female').delete()

        check, not_found = self.reader.check_sex()

        # the read species are not included in fixtures
        self.assertFalse(check)
        self.assertGreater(len(not_found), 0)

    def test_check_accuracies(self):
        """Test check accuracies method"""

        check, not_found = self.reader.check_accuracies()

        self.assertTrue(check)
        self.assertEqual(len(not_found), 0)


class ExcelMixin(WebSocketMixin, BaseExcelMixin):

This code seems to be duplicated in your project.

    """Common tests for Excel classes"""

    def test_upload_template(self):
        """Testing uploading and importing data from excel template to UID"""

        # assert upload
        self.assertTrue(upload_template(self.submission))

        # reload submission
        self.submission.refresh_from_db()

        # assert submission messages
        self.assertEqual(
            self.submission.status,
            LOADED)

        self.assertIn(
            "Template import completed for submission",
            self.submission.message)

        # assert data into database
        self.assertTrue(db_has_data())
        self.assertTrue(Animal.objects.exists())
        self.assertTrue(Sample.objects.exists())

        # check async message called
        message = 'Loaded'
        notification_message = (
            'Template import completed for submission: 1')
        validation_message = {
            'animals': 3, 'samples': 3,
            'animal_unkn': 3, 'sample_unkn': 3,
            'animal_issues': 0, 'sample_issues': 0}

        self.check_message(message, notification_message, validation_message)

    def check_errors(self, my_check, message, notification_message):
        """Common stuff for error in excel template loading"""

        self.assertFalse(upload_template(self.submission))

        # reload submission
        self.submission.refresh_from_db()

        # test my mock method called
        self.assertTrue(my_check.called)

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

        self.assertEqual(
            self.submission.status,
            ERROR)

        # check for two distinct messages
        self.assertIn(
            message,
            self.submission.message)

        self.assertNotIn(
            "Template import completed for submission",
            self.submission.message)

        # assert data into database
        self.assertFalse(db_has_data())
        self.assertFalse(Animal.objects.exists())
        self.assertFalse(Sample.objects.exists())

        # check async message called
        self.check_message('Error', notification_message)


class UploadTemplateTestCase(ExcelMixin, TestCase):
    """Test uploading data for Template excel path"""

    pass