Beispiel #1
0
    def test__get_connection(self):
        connection = PostgresAdapter.get_connection(self.profile)
        duplicate = PostgresAdapter.get_connection(self.profile)

        self.assertEquals(connection.get('state'), 'open')
        self.assertNotEquals(connection.get('handle'), None)

        self.assertEquals(connection, duplicate)
Beispiel #2
0
    def setUp(self):
        flags.STRICT_MODE = False

        self.profile = {
            'dbname': 'postgres',
            'user': '******',
            'host': 'database',
            'pass': '******',
            'port': 5432,
            'schema': 'public'
        }

        self.project = {
            'name': 'X',
            'version': '0.1',
            'profile': 'test',
            'project-root': '/tmp/dbt/does-not-exist',
            'quoting': {
                'identifier': False,
                'schema': True,
            }
        }

        self.handle = mock.MagicMock(spec=psycopg2_extensions.connection)
        self.cursor = self.handle.cursor.return_value
        self.mock_execute = self.cursor.execute
        self.patcher = mock.patch('dbt.adapters.postgres.impl.psycopg2')
        self.psycopg2 = self.patcher.start()

        self.psycopg2.connect.return_value = self.handle
        conn = PostgresAdapter.get_connection(self.profile)
Beispiel #3
0
class TestConnectingPostgresAdapter(unittest.TestCase):
    def setUp(self):
        flags.STRICT_MODE = False

        profile_cfg = {
            'outputs': {
                'test': {
                    'type': 'postgres',
                    'dbname': 'postgres',
                    'user': '******',
                    'host': 'database',
                    'pass': '******',
                    'port': 5432,
                    'schema': 'public'
                }
            },
            'target': 'test'
        }
        project_cfg = {
            'name': 'X',
            'version': '0.1',
            'profile': 'test',
            'project-root': '/tmp/dbt/does-not-exist',
            'quoting': {
                'identifier': False,
                'schema': True,
            }
        }

        self.config = config_from_parts_or_dicts(project_cfg, profile_cfg)

        self.handle = mock.MagicMock(spec=psycopg2_extensions.connection)
        self.cursor = self.handle.cursor.return_value
        self.mock_execute = self.cursor.execute
        self.patcher = mock.patch('dbt.adapters.postgres.impl.psycopg2')
        self.psycopg2 = self.patcher.start()

        self.psycopg2.connect.return_value = self.handle
        self.adapter = PostgresAdapter(self.config)
        self.adapter.get_connection()

    def tearDown(self):
        # we want a unique self.handle every time.
        self.adapter.cleanup_connections()
        self.patcher.stop()

    def test_quoting_on_drop_schema(self):
        self.adapter.drop_schema(schema='test_schema')

        self.mock_execute.assert_has_calls(
            [mock.call('drop schema if exists "test_schema" cascade', None)])

    def test_quoting_on_drop(self):
        self.adapter.drop(schema='test_schema',
                          relation='test_table',
                          relation_type='table')
        self.mock_execute.assert_has_calls([
            mock.call('drop table if exists "test_schema".test_table cascade',
                      None)
        ])

    def test_quoting_on_truncate(self):
        self.adapter.truncate(schema='test_schema', table='test_table')
        self.mock_execute.assert_has_calls(
            [mock.call('truncate table "test_schema".test_table', None)])

    def test_quoting_on_rename(self):
        self.adapter.rename(schema='test_schema',
                            from_name='table_a',
                            to_name='table_b')
        self.mock_execute.assert_has_calls([
            mock.call('alter table "test_schema".table_a rename to table_b',
                      None)
        ])