Refactor tests

jarbas/core/tests/__init__.py

@@ -1,9 +1,76 @@
+from io import StringIO
 from datetime import date
 from random import randrange
 
+from unittest.mock import Mock, call
+
 from django.utils import timezone
+from django.test import TestCase as DjangoTestCase
+
+from jarbas.core.models import Reimbursement, Tweet
+
+
+class TestCase(DjangoTestCase):
+
+    def serializer(self, command, input, expected):
+        serialized = command.serialize(input)
+        self.assertEqual(serialized, expected)
+
+    def main(self, command, update, schedule_update, costum_method):
+        costum_method.return_value = (range(21), range(21, 43))
+        command.main()
+        update.assert_has_calls([call()] * 2)
+        schedule_update.assert_has_calls(call(i) for i in range(42))
+
+    def schedule_update_non_existing_record(self, command, content, get):
+        get.side_effect = Reimbursement.DoesNotExist
+        command.queue = []
+        command.schedule_update(content)
+        get.assert_called_once_with(document_id=42)
+        self.assertEqual([], command.queue)
+
+    def update(self, command, fields, print_, bulk_update):
+        command.count = 40
+        command.queue = list(range(2))
+        command.update()
+        bulk_update.assert_called_with([0, 1], update_fields=fields)
+        print_.assert_called_with('42 reimbursements updated.', end='\r')
+        self.assertEqual(42, command.count)
+
+    def handler_with_options(self, command, print_, exits, main, costum_command):
+        command.handle(dataset=self.file_name, batch_size=42)
+        main.assert_called_once_with()
+        print_.assert_called_once_with('0 reimbursements updated.')
+        self.assertEqual(command.path, self.file_name)
+        self.assertEqual(command.batch_size, 42)
+
+    def handler_without_options(self, command, print_, exits, main, costum_command):
+        command.handle(dataset=self.file_name, batch_size=4096)
+        main.assert_called_once_with()
+        print_.assert_called_once_with('0 reimbursements updated.')
+        self.assertEqual(command.path, self.file_name)
+        self.assertEqual(command.batch_size, 4096)
+
+    def handler_with_non_existing_file(self, command, exists, update, costum_command):
+        exists.return_value = False
+        with self.assertRaises(FileNotFoundError):
+            command.handle(dataset='suspicions.xz', batch_size=4096)
+        update.assert_not_called()
+
+    def new_command(self, command, costum_command, serialize, rows, lzma, print_):
+        serialize.return_value = '.'
+        lzma.return_value = StringIO()
+        rows.return_value = range(42)
+        command.batch_size = 10
+        command.path = self.file_name
+        expected = [['.'] * 10, ['.'] * 10, ['.'] * 10, ['.'] * 10, ['.'] * 2]
+        self.assertEqual(expected, list(costum_command))
+        self.assertEqual(42, serialize.call_count)
 
-from jarbas.core.models import Tweet
+    def add_arguments(self, command):
+        mock = Mock()
+        command.add_arguments(mock)
+        self.assertEqual(2, mock.add_argument.call_count)
 
 
 suspicions = {

jarbas/core/tests/test_companies_command.py

@@ -2,17 +2,16 @@
 from io import StringIO
 from unittest.mock import patch
 
-from django.test import TestCase
-
 from jarbas.core.management.commands.companies import Command
 from jarbas.core.models import Activity, Company
-from jarbas.core.tests import sample_company_data
+from jarbas.core.tests import TestCase, sample_company_data
 
 
 class TestCommand(TestCase):
 
     def setUp(self):
         self.command = Command()
+        self.file_name = 'companies.xz'
 
 
 class TestSerializer(TestCommand):
@@ -23,7 +22,7 @@ def test_to_email(self):
         self.assertEqual(self.command.to_email('[email protected]'), expected)
 
     def test_serializer(self):
-        company = {
+        input = {
             'email': 'ahoy',
             'opening': '31/12/1969',
             'situation_date': '31/12/1969',
@@ -39,7 +38,7 @@ def test_serializer(self):
             'latitude': 3.1415,
             'longitude': -42.0
         }
-        self.assertEqual(self.command.serialize(company), expected)
+        self.serializer(self.command, input, expected)
 
 
 class TestCreate(TestCommand):
@@ -83,25 +82,25 @@ def test_save_companies(self, create, print_count, serialize, save_activities, r
 class TestConventionMethods(TestCommand):
 
     @patch('jarbas.core.management.commands.companies.print')
-    @patch('jarbas.core.management.commands.companies.LoadCommand.drop_all')
+    @patch('jarbas.core.management.commands.companies.Command.drop_all')
     @patch('jarbas.core.management.commands.companies.Command.save_companies')
     @patch('jarbas.core.management.commands.companies.Command.print_count')
-    def test_handler_without_options(self, print_count, save_companies, drop_all, print_):
+    def test_handler_with_options(self, print_count, save_companies, drop_all, print_):
         print_count.return_value = 0
-        self.command.handle(dataset='companies.xz')
+        self.command.handle(dataset=self.file_name, drop=True)
         print_.assert_called_with('Starting with 0 companies')
+        self.assertEqual(2, drop_all.call_count)
         self.assertEqual(1, save_companies.call_count)
-        self.assertEqual(1, print_count.call_count)
-        self.assertEqual('companies.xz', self.command.path)
-        drop_all.assert_not_called()
 
     @patch('jarbas.core.management.commands.companies.print')
-    @patch('jarbas.core.management.commands.companies.Command.drop_all')
+    @patch('jarbas.core.management.commands.companies.LoadCommand.drop_all')
     @patch('jarbas.core.management.commands.companies.Command.save_companies')
     @patch('jarbas.core.management.commands.companies.Command.print_count')
-    def test_handler_with_options(self, print_count, save_companies, drop_all, print_):
+    def test_handler_without_options(self, print_count, save_companies, drop_all, print_):
         print_count.return_value = 0
-        self.command.handle(dataset='companies.xz', drop=True)
+        self.command.handle(dataset=self.file_name)
         print_.assert_called_with('Starting with 0 companies')
-        self.assertEqual(2, drop_all.call_count)
         self.assertEqual(1, save_companies.call_count)
+        self.assertEqual(1, print_count.call_count)
+        self.assertEqual(self.file_name, self.command.path)
+        drop_all.assert_not_called()

jarbas/core/tests/test_company_model.py

@@ -1,4 +1,5 @@
 from django.test import TestCase
+
 from jarbas.core.models import Activity, Company
 from jarbas.core.tests import sample_activity_data, sample_company_data
 

jarbas/core/tests/test_load_command.py

@@ -1,68 +1,65 @@
 from datetime import date
 from unittest.mock import Mock, patch
 
-from django.test import TestCase
-
 from jarbas.core.management.commands import LoadCommand
 from jarbas.core.models import Activity
-from jarbas.core.tests import sample_activity_data
+from jarbas.core.tests import TestCase, sample_activity_data
 
 
-class TestStaticMethods(TestCase):
+class TestCommand(TestCase):
 
     def setUp(self):
-        self.cmd = LoadCommand()
+        self.command = LoadCommand()
+
+class TestStaticMethods(TestCommand):
 
     def test_get_model_name(self):
-        self.assertEqual('Activity', self.cmd.get_model_name(Activity))
+        self.assertEqual('Activity', self.command.get_model_name(Activity))
 
     def test_to_date(self):
         expected = date(1991, 7, 22)
-        self.assertEqual(self.cmd.to_date('22/7/91'), expected)
-        self.assertEqual(self.cmd.to_date('1991-07-22 03:15:00+0300'), expected)
-        self.assertEqual(self.cmd.to_date('22/13/91'), None)
-        self.assertEqual(self.cmd.to_date('aa/7/91'), None)
-        self.assertEqual(self.cmd.to_date('22/07/16'), date(2016, 7, 22))
+        self.assertEqual(self.command.to_date('22/7/91'), expected)
+        self.assertEqual(self.command.to_date('1991-07-22 03:15:00+0300'), expected)
+        self.assertEqual(self.command.to_date('22/13/91'), None)
+        self.assertEqual(self.command.to_date('aa/7/91'), None)
+        self.assertEqual(self.command.to_date('22/07/16'), date(2016, 7, 22))
 
     def test_to_number(self):
-        self.assertIsNone(self.cmd.to_number(''))
-        self.assertIsNone(self.cmd.to_number('NaN'))
-        self.assertIsNone(self.cmd.to_number('nan'))
-        self.assertEqual(1.0, self.cmd.to_number('1'))
-        self.assertEqual(1.2, self.cmd.to_number('1.2'))
-        self.assertEqual(1, self.cmd.to_number('1', int))
-        self.assertEqual(1, self.cmd.to_number('1.0', int))
+        self.assertIsNone(self.command.to_number(''))
+        self.assertIsNone(self.command.to_number('NaN'))
+        self.assertIsNone(self.command.to_number('nan'))
+        self.assertEqual(1.0, self.command.to_number('1'))
+        self.assertEqual(1.2, self.command.to_number('1.2'))
+        self.assertEqual(1, self.command.to_number('1', int))
+        self.assertEqual(1, self.command.to_number('1.0', int))
 
 
-class TestPrintCount(TestCase):
-
-    def setUp(self):
-        self.cmd = LoadCommand()
+class TestPrintCount(TestCommand):
 
     @patch('jarbas.core.management.commands.print')
     def test_print_no_records(self, mock_print):
-        self.cmd.print_count(Activity)
+        self.command.print_count(Activity)
         arg = 'Current count: 0 Activitys                                    '
         kwargs = {'end': '\r'}
         mock_print.assert_called_with(arg, **kwargs)
 
     @patch('jarbas.core.management.commands.print')
     def test_print_with_records(self, mock_print):
         Activity.objects.create(**sample_activity_data)
-        self.cmd.print_count(Activity)
+        self.command.print_count(Activity)
         arg = 'Current count: 1 Activitys                                    '
         kwargs = {'end': '\r'}
         mock_print.assert_called_with(arg, **kwargs)
 
     @patch('jarbas.core.management.commands.print')
     def test_print_with_permanent_keyword_arg(self, mock_print):
-        self.cmd.print_count(Activity, permanent=True)
+        self.command.print_count(Activity, permanent=True)
         arg = 'Current count: 0 Activitys                                    '
         kwargs = {'end': '\n'}
         mock_print.assert_called_with(arg, **kwargs)
 
 
-class TestDropAll(TestCase):
+class TestDropAll(TestCommand):
 
     @patch('jarbas.core.management.commands.print')
     def test_drop_all(self, mock_print):
@@ -73,12 +70,10 @@ def test_drop_all(self, mock_print):
         self.assertEqual(0, Activity.objects.count())
 
 
-class TestAddArguments(TestCase):
+class TestAddArguments(TestCommand):
 
     def test_add_arguments(self):
-        mock = Mock()
-        LoadCommand().add_arguments(mock)
-        self.assertEqual(2, mock.add_argument.call_count)
+        self.add_arguments(self.command)
 
     def test_add_arguments_without_drop_all(self):
         mock = Mock()