Add tests for enum comparisons

Besides the test changes themselves,

- Update mysql-connector-python to 2.1.6 that's currently available
  from Oracle.
- Suppress "not-callable" errors from pylint.
- Fix flake8 indentation errors.

Author: Dave Charness

test/endtoend/models_left.py

@@ -1,11 +1,18 @@
 # -*- coding: utf-8 -*-
-from sqlalchemy import Column, ForeignKey, Integer, String, Unicode
+import enum
+
+from sqlalchemy import Column, Enum, ForeignKey, Integer, String, Unicode
 from sqlalchemy.ext.declarative import declarative_base
 
 
 Base = declarative_base()
 
 
+class Polarity(enum.Enum):
+    NEGATIVE = 'NEGATIVE'
+    POSITIVE = 'POSITIVE'
+
+
 class Employee(Base):
     __tablename__ = "employees"
 
@@ -14,6 +21,8 @@ class Employee(Base):
     age = Column(Integer, nullable=False, default=21)
     ssn = Column(Unicode(30), nullable=False)
     number_of_pets = Column(Integer, default=1, nullable=False)
+    polarity = Column(Enum(Polarity, native_enum=True))
+    spin = Column(Enum('spin_down', 'spin_up', native_enum=False))
 
     company_id = Column(
         Integer,

test/endtoend/models_right.py

@@ -1,11 +1,18 @@
 # -*- coding: utf-8 -*-
-from sqlalchemy import Column, ForeignKey, Integer, String, Unicode
+import enum
+
+from sqlalchemy import Column, Enum, ForeignKey, Integer, String, Unicode
 from sqlalchemy.ext.declarative import declarative_base
 
 
 Base = declarative_base()
 
 
+class Polarity(enum.Enum):
+    NEG = 'NEG'
+    POS = 'POS'
+
+
 class Employee(Base):
     __tablename__ = "employees"
 
@@ -14,6 +21,8 @@ class Employee(Base):
     age = Column(Integer, nullable=False, default=21)
     ssn = Column(Unicode(30), nullable=False)
     number_of_pets = Column(Integer, default=1, nullable=False)
+    polarity = Column(Enum(Polarity, native_enum=True))
+    spin = Column(Enum('down', 'up', native_enum=False))
 
     company_id = Column(
         Integer,

test/endtoend/test_example.py

@@ -108,6 +108,39 @@ def test_errors_dict_catches_all_differences(uri_left, uri_right):
                 }
             },
             'employees': {
+                'columns': {
+                    'diff': [
+                        {
+                            'key': 'polarity',
+                            'left': {
+                                'default': None,
+                                'name': 'polarity',
+                                'nullable': True,
+                                'type': "ENUM('NEGATIVE','POSITIVE')"},
+                            'right': {
+                                'default': None,
+                                'name': 'polarity',
+                                'nullable': True,
+                                'type': "ENUM('NEG','POS')"
+                            }
+                        },
+                        {
+                            'key': 'spin',
+                            'left': {
+                                'default': None,
+                                'name': 'spin',
+                                'nullable': True,
+                                'type': 'VARCHAR(9)'
+                            },
+                            'right': {
+                                'default': None,
+                                'name': 'spin',
+                                'nullable': True,
+                                'type': 'VARCHAR(4)'
+                            }
+                        }
+                    ]
+                },
                 'foreign_keys': {
                     'left_only': [
                         {
@@ -215,6 +248,8 @@ def test_errors_dict_catches_all_differences(uri_left, uri_right):
                 }
             }
         },
+        'enums': {
+        },
         'uris': {
             'left': uri_left,
             'right': uri_right,
@@ -299,6 +334,8 @@ def test_ignores(uri_left, uri_right):
         'phone_numbers',
         'companies.col.name',
         'companies.idx.name',
+        'employees.col.polarity',
+        'employees.col.spin',
         'employees.fk.fk_employees_companies',
         'employees.fk.fk_emp_comp',
         'employees.idx.ix_employees_name',
@@ -330,6 +367,8 @@ def test_ignores_alternative_sep(uri_left, uri_right):
         'phone_numbers',
         'companies#col#name',
         'companies#idx#name',
+        'employees#col#polarity',
+        'employees#col#spin',
         'employees#fk#fk_employees_companies',
         'employees#fk#fk_emp_comp',
         'employees#idx#ix_employees_name',

test/unit/test_comparer.py

@@ -93,9 +93,15 @@ def _get_tables_info_mock(self):
             )
             yield m
 
+    @pytest.yield_fixture
+    def _get_enums_data_mock(self):
+        with patch('sqlalchemydiff.comparer._get_enums_data') as m:
+            m.return_value = []
+            yield m
+
     def test_compare_calls_chain(
             self, _get_tables_info_mock, _get_tables_data_mock,
-            _compile_errors_mock):
+            _get_enums_data_mock, _compile_errors_mock):
         """By inspecting `info` and `errors` at the end, we automatically
         check that the whole process works as expected.  What this test
         leaves out is the verifications about inspectors.
@@ -134,6 +140,12 @@ def test_compare_calls_chain(
                     'data': 'some-data-B',
                 },
             },
+            'enums': {
+                'left_only': [],
+                'right_only': [],
+                'common': [],
+                'diff': [],
+            },
         }
 
         expected_errors = expected_info.copy()
@@ -144,7 +156,8 @@ def test_compare_calls_chain(
 
     def test__get_tables_info_called_with_correct_inspectors(
             self, _get_inspectors_mock, _get_tables_info_mock,
-            _get_tables_data_mock, _compile_errors_mock):
+            _get_tables_data_mock, _get_enums_data_mock,
+            _compile_errors_mock):
         left_inspector, right_inspector = _get_inspectors_mock.return_value
 
         compare("left_uri", "right_uri", ignores=['ignore_me'])
@@ -219,6 +232,11 @@ def _get_columns_info_mock(self):
         with patch('sqlalchemydiff.comparer._get_columns_info') as m:
             yield m
 
+    @pytest.yield_fixture
+    def _get_constraints_info_mock(self):
+        with patch('sqlalchemydiff.comparer._get_constraints_info') as m:
+            yield m
+
     # TESTS
 
     def test__get_inspectors(self):
@@ -302,6 +320,7 @@ def test__get_info_dict(self):
                 'common': ['C'],
             },
             'tables_data': {},
+            'enums': {},
         }
 
         assert expected_info == info
@@ -616,7 +635,8 @@ def test_process_type(self):
 
     def test__get_table_data(
             self, _get_foreign_keys_info_mock, _get_primary_keys_info_mock,
-            _get_indexes_info_mock, _get_columns_info_mock):
+            _get_indexes_info_mock, _get_columns_info_mock,
+            _get_constraints_info_mock):
         left_inspector, right_inspector = Mock(), Mock()
 
         _get_foreign_keys_info_mock.return_value = {
@@ -631,6 +651,9 @@ def test__get_table_data(
         _get_columns_info_mock.return_value = {
             'left_only': 13, 'right_only': 14, 'common': 15, 'diff': 16
         }
+        _get_constraints_info_mock.return_value = {
+            'left_only': 17, 'right_only': 18, 'common': 19, 'diff': 20
+        }
 
         result = _get_table_data(
             left_inspector, right_inspector, 'table_A', Mock()
@@ -661,6 +684,12 @@ def test__get_table_data(
                 'common': 15,
                 'diff': 16,
             },
+            'constraints': {
+                'left_only': 17,
+                'right_only': 18,
+                'common': 19,
+                'diff': 20,
+            },
         }
 
         assert expected_result == result
@@ -704,6 +733,12 @@ def test__compile_errors_with_errors(self):
                         'right_only': 14,
                         'common': 15,
                         'diff': 16,
+                    },
+                    'constraints': {
+                        'left_only': 17,
+                        'right_only': 18,
+                        'common': 19,
+                        'diff': 20,
                     }
                 },
 
@@ -731,8 +766,20 @@ def test__compile_errors_with_errors(self):
                         'right_only': 14,
                         'common': 15,
                         'diff': 16,
+                    },
+                    'constraints': {
+                        'left_only': 17,
+                        'right_only': 18,
+                        'common': 19,
+                        'diff': 20,
                     }
                 }
+            },
+            'enums': {
+                'left_only': 21,
+                'right_only': 22,
+                'common': 23,
+                'diff': 24,
             }
         }
 
@@ -766,6 +813,11 @@ def test__compile_errors_with_errors(self):
                         'left_only': 13,
                         'right_only': 14,
                         'diff': 16,
+                    },
+                    'constraints': {
+                        'left_only': 17,
+                        'right_only': 18,
+                        'diff': 20,
                     }
                 },
 
@@ -789,8 +841,18 @@ def test__compile_errors_with_errors(self):
                         'left_only': 13,
                         'right_only': 14,
                         'diff': 16,
+                    },
+                    'constraints': {
+                        'left_only': 17,
+                        'right_only': 18,
+                        'diff': 20,
                     }
                 }
+            },
+            'enums': {
+                'left_only': 21,
+                'right_only': 22,
+                'diff': 24,
             }
         }
 
@@ -837,7 +899,19 @@ def test__compile_errors_without_errors(self):
                         'common': 4,
                         'diff': [],
                     },
+                    'constraints': {
+                        'left_only': [],
+                        'right_only': [],
+                        'common': 5,
+                        'diff': [],
+                    },
                 }
+            },
+            'enums': {
+                'left_only': [],
+                'right_only': [],
+                'common': 6,
+                'diff': [],
             }
         }
 

test/unit/test_util.py

@@ -210,12 +210,13 @@ def test_identifier_incorrect(self):
             IgnoreManager(ignore_data)
 
         assert (
-            "unknown is invalid. It must be in ['pk', 'fk', 'idx', 'col']",
+            "unknown is invalid. It must be in "
+            "['pk', 'fk', 'idx', 'col', 'cons', 'enum']",
         ) == err.value.args
 
     @pytest.mark.parametrize('clause', [
-            'too.few',
-            'too.many.definitely.for-sure',
+        'too.few',
+        'too.many.definitely.for-sure',
     ])
     def test_incorrect_clause(self, clause):
         ignore_data = [clause]
@@ -229,8 +230,8 @@ def test_incorrect_clause(self, clause):
         ) == err.value.args
 
     @pytest.mark.parametrize('clause', [
-            '.pk.b',
-            'a.pk.',
+        '.pk.b',
+        'a.pk.',
     ])
     def test_incorrect_empty_clause(self, clause):
         ignore_data = [clause]