Fix/test cleanup

test/integration/035_changing_relation_type_test/test_changing_relation_type.py

@@ -20,23 +20,23 @@ def swap_types_and_test(self):
         # between materializations that create tables and views.
 
         results = self.run_dbt(['run', '--vars', 'materialized: view'])
-        self.assertEquals(results[0].node['config']['materialized'], 'view')
+        self.assertEqual(results[0].node['config']['materialized'], 'view')
         self.assertEqual(len(results),  1)
 
         results = self.run_dbt(['run', '--vars', 'materialized: table'])
-        self.assertEquals(results[0].node['config']['materialized'], 'table')
+        self.assertEqual(results[0].node['config']['materialized'], 'table')
         self.assertEqual(len(results),  1)
 
         results = self.run_dbt(['run', '--vars', 'materialized: view'])
-        self.assertEquals(results[0].node['config']['materialized'], 'view')
+        self.assertEqual(results[0].node['config']['materialized'], 'view')
         self.assertEqual(len(results),  1)
 
         results = self.run_dbt(['run', '--vars', 'materialized: incremental'])
-        self.assertEquals(results[0].node['config']['materialized'], 'incremental')
+        self.assertEqual(results[0].node['config']['materialized'], 'incremental')
         self.assertEqual(len(results),  1)
 
         results = self.run_dbt(['run', '--vars', 'materialized: view'])
-        self.assertEquals(results[0].node['config']['materialized'], 'view')
+        self.assertEqual(results[0].node['config']['materialized'], 'view')
         self.assertEqual(len(results),  1)
 
     @use_profile("postgres")
@@ -59,37 +59,37 @@ def test__bigquery__switch_materialization(self):
         # and then remove these bq-specific tests
 
         results = self.run_dbt(['run', '--vars', 'materialized: view'])
-        self.assertEquals(results[0].node['config']['materialized'], 'view')
+        self.assertEqual(results[0].node['config']['materialized'], 'view')
         self.assertEqual(len(results),  1)
 
         results = self.run_dbt(['run', '--vars', 'materialized: table'])
-        self.assertEquals(results[0].node['config']['materialized'], 'table')
+        self.assertEqual(results[0].node['config']['materialized'], 'table')
         self.assertEqual(len(results),  1)
 
         results = self.run_dbt(['run', '--vars', 'materialized: view', "--full-refresh"])
-        self.assertEquals(results[0].node['config']['materialized'], 'view')
+        self.assertEqual(results[0].node['config']['materialized'], 'view')
         self.assertEqual(len(results),  1)
 
         results = self.run_dbt(['run', '--vars', 'materialized: incremental'])
-        self.assertEquals(results[0].node['config']['materialized'], 'incremental')
+        self.assertEqual(results[0].node['config']['materialized'], 'incremental')
         self.assertEqual(len(results),  1)
 
         results = self.run_dbt(['run', '--vars', 'materialized: view', "--full-refresh"])
-        self.assertEquals(results[0].node['config']['materialized'], 'view')
+        self.assertEqual(results[0].node['config']['materialized'], 'view')
         self.assertEqual(len(results),  1)
 
     @use_profile('presto')
     def test__presto__switch_materialization(self):
         # presto can't do incremental materializations so there's less to this
 
         results = self.run_dbt(['run', '--vars', 'materialized: view'])
-        self.assertEquals(results[0].node['config']['materialized'], 'view')
+        self.assertEqual(results[0].node['config']['materialized'], 'view')
         self.assertEqual(len(results),  1)
 
         results = self.run_dbt(['run', '--vars', 'materialized: table'])
-        self.assertEquals(results[0].node['config']['materialized'], 'table')
+        self.assertEqual(results[0].node['config']['materialized'], 'table')
         self.assertEqual(len(results),  1)
 
         results = self.run_dbt(['run', '--vars', 'materialized: view'])
-        self.assertEquals(results[0].node['config']['materialized'], 'view')
+        self.assertEqual(results[0].node['config']['materialized'], 'view')
         self.assertEqual(len(results),  1)

test/integration/037_external_reference_test/test_external_reference.py

@@ -35,9 +35,9 @@ def tearDown(self):
 
     @use_profile('postgres')
     def test__postgres__external_reference(self):
-        self.assertEquals(len(self.run_dbt()), 1)
+        self.assertEqual(len(self.run_dbt()), 1)
         # running it again should succeed
-        self.assertEquals(len(self.run_dbt()), 1)
+        self.assertEqual(len(self.run_dbt()), 1)
 
 
 # The opposite of the test above -- check that external relations that
@@ -61,7 +61,7 @@ def tearDown(self):
 
     @use_profile('postgres')
     def test__postgres__external_reference(self):
-        self.assertEquals(len(self.run_dbt()), 1)
+        self.assertEqual(len(self.run_dbt()), 1)
 
         # create a view outside of the dbt schema that depends on this model
         self.external_schema = self.unique_schema()+'zz'
@@ -74,5 +74,5 @@ def test__postgres__external_reference(self):
         )
 
         # running it again should succeed
-        self.assertEquals(len(self.run_dbt()), 1)
+        self.assertEqual(len(self.run_dbt()), 1)
 

test/integration/base.py

@@ -1035,7 +1035,7 @@ def _assertTableRowCountsEqual(self, relation_a, relation_b):
 
         res = self.run_sql(cmp_query, fetch='one')
 
-        self.assertEquals(int(res[0]), 0, "Row count of table {} doesn't match row count of table {}. ({} rows different)".format(
+        self.assertEqual(int(res[0]), 0, "Row count of table {} doesn't match row count of table {}. ({} rows different)".format(
                 relation_a.identifier,
                 relation_b.identifier,
                 res[0]
@@ -1045,7 +1045,7 @@ def _assertTableRowCountsEqual(self, relation_a, relation_b):
     def assertTableDoesNotExist(self, table, schema=None):
         columns = self.get_table_columns(table, schema)
 
-        self.assertEquals(
+        self.assertEqual(
             len(columns),
             0
         )

test/unit/test_bigquery_adapter.py

@@ -79,7 +79,7 @@ def test_acquire_connection_oauth_validations(self, mock_open_connection):
         adapter = self.get_adapter('oauth')
         try:
             connection = adapter.acquire_connection('dummy')
-            self.assertEquals(connection.get('type'), 'bigquery')
+            self.assertEqual(connection.get('type'), 'bigquery')
 
         except dbt.exceptions.ValidationException as e:
             self.fail('got ValidationException: {}'.format(str(e)))
@@ -94,7 +94,7 @@ def test_acquire_connection_service_account_validations(self, mock_open_connecti
         adapter = self.get_adapter('service_account')
         try:
             connection = adapter.acquire_connection('dummy')
-            self.assertEquals(connection.get('type'), 'bigquery')
+            self.assertEqual(connection.get('type'), 'bigquery')
 
         except dbt.exceptions.ValidationException as e:
             self.fail('got ValidationException: {}'.format(str(e)))

test/unit/test_context.py

@@ -4,7 +4,7 @@
 from dbt.contracts.graph.parsed import ParsedNode
 from dbt.context import parser, runtime
 import dbt.exceptions
-from test.unit.mock_adapter import adapter_factory
+from .mock_adapter import adapter_factory
 
 
 

test/unit/test_graph_selection.py

@@ -55,7 +55,7 @@ def run_specs_and_assert(self, graph, include, exclude, expected):
             exclude
         )
 
-        self.assertEquals(selected, expected)
+        self.assertEqual(selected, expected)
 
 
     def test__single_node_selection_in_package(self):
@@ -177,7 +177,7 @@ def test__package_name_getter(self):
         found = graph_selector.get_package_names(self.package_graph)
 
         expected = set(['X', 'Y'])
-        self.assertEquals(found, expected)
+        self.assertEqual(found, expected)
 
     def assert_is_selected_node(self, node, spec, should_work):
         self.assertEqual(

test/unit/test_postgres_adapter.py

@@ -58,15 +58,15 @@ def test_acquire_connection_validations(self, psycopg2):
         except BaseException as e:
             self.fail('acquiring connection failed with unknown exception: {}'
                       .format(str(e)))
-        self.assertEquals(connection.type, 'postgres')
+        self.assertEqual(connection.type, 'postgres')
         psycopg2.connect.assert_called_once()
 
     @mock.patch('dbt.adapters.postgres.connections.psycopg2')
     def test_acquire_connection(self, psycopg2):
         connection = self.adapter.acquire_connection('dummy')
 
-        self.assertEquals(connection.state, 'open')
-        self.assertNotEquals(connection.handle, None)
+        self.assertEqual(connection.state, 'open')
+        self.assertNotEqual(connection.handle, None)
         psycopg2.connect.assert_called_once()
 
     def test_cancel_open_connections_empty(self):

test/unit/test_redshift_adapter.py

@@ -61,13 +61,13 @@ def adapter(self):
 
     def test_implicit_database_conn(self):
         creds = RedshiftAdapter.ConnectionManager.get_credentials(self.config.credentials)
-        self.assertEquals(creds, self.config.credentials)
+        self.assertEqual(creds, self.config.credentials)
 
     def test_explicit_database_conn(self):
         self.config.method = 'database'
 
         creds = RedshiftAdapter.ConnectionManager.get_credentials(self.config.credentials)
-        self.assertEquals(creds, self.config.credentials)
+        self.assertEqual(creds, self.config.credentials)
 
     def test_explicit_iam_conn(self):
         self.config.credentials = self.config.credentials.incorporate(
@@ -80,7 +80,7 @@ def test_explicit_iam_conn(self):
             creds = RedshiftAdapter.ConnectionManager.get_credentials(self.config.credentials)
 
         expected_creds = self.config.credentials.incorporate(password='tmp_password')
-        self.assertEquals(creds, expected_creds)
+        self.assertEqual(creds, expected_creds)
 
     def test_invalid_auth_method(self):
         # we have to set method this way, otherwise it won't validate

test/unit/test_utils.py

@@ -18,7 +18,7 @@ def test__simple_cases(self):
 
         for case in cases:
             actual = dbt.utils.deep_merge(*case['args'])
-            self.assertEquals(
+            self.assertEqual(
                 case['expected'], actual,
                 'failed on {} (actual {}, expected {})'.format(
                     case['description'], actual, case['expected']))
@@ -38,7 +38,7 @@ def test__simple_cases(self):
 
         for case in cases:
             actual = dbt.utils.deep_merge(*case['args'])
-            self.assertEquals(
+            self.assertEqual(
                 case['expected'], actual,
                 'failed on {} (actual {}, expected {})'.format(
                     case['description'], actual, case['expected']))
@@ -88,10 +88,10 @@ def test__simple_cases(self):
             ],
         }
         actual = dbt.utils.deep_map(self.intify_all, self.input_value)
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
         actual = dbt.utils.deep_map(self.intify_all, expected)
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
 
     @staticmethod
@@ -121,20 +121,20 @@ def test__keypath(self):
             ],
         }
         actual = dbt.utils.deep_map(self.special_keypath, self.input_value)
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
         actual = dbt.utils.deep_map(self.special_keypath, expected)
-        self.assertEquals(actual, expected)
+        self.assertEqual(actual, expected)
 
     def test__noop(self):
         actual = dbt.utils.deep_map(lambda x, _: x, self.input_value)
-        self.assertEquals(actual, self.input_value)
+        self.assertEqual(actual, self.input_value)
 
     def test_trivial(self):
         cases = [[], {}, 1, 'abc', None, True]
         for case in cases:
             result = dbt.utils.deep_map(lambda x, _: x, case)
-            self.assertEquals(result, case)
+            self.assertEqual(result, case)
 
         with self.assertRaises(dbt.exceptions.DbtConfigError):
             dbt.utils.deep_map(lambda x, _: x, {'foo': object()})