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.connections.psycopg2')
self.psycopg2 = self.patcher.start()
self.psycopg2.connect.return_value = self.handle
self.adapter = PostgresAdapter(self.config)
inject_adapter('postgres', self.adapter)
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(database='postgres', 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):
relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='test_table',
type='table',
quote_policy=self.adapter.config.quoting,
)
self.adapter.drop_relation(relation)
self.mock_execute.assert_has_calls([
mock.call('drop table if exists "postgres"."test_schema".test_table cascade', None)
])
def test_quoting_on_truncate(self):
relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='test_table',
type='table',
quote_policy=self.adapter.config.quoting,
)
self.adapter.truncate_relation(relation)
self.mock_execute.assert_has_calls([
mock.call('truncate table "postgres"."test_schema".test_table', None)
])
def test_quoting_on_rename(self):
from_relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='table_a',
type='table',
quote_policy=self.adapter.config.quoting,
)
to_relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='table_b',
type='table',
quote_policy=self.adapter.config.quoting,
)
self.adapter.rename_relation(
from_relation=from_relation,
to_relation=to_relation
)
self.mock_execute.assert_has_calls([
mock.call('alter table "postgres"."test_schema".table_a rename to table_b', None)
])
class TestConnectingPostgresAdapter(unittest.TestCase):
def setUp(self):
flags.STRICT_MODE = False
self.target_dict = {
'type': 'postgres',
'dbname': 'postgres',
'user': '******',
'host': 'thishostshouldnotexist',
'pass': '******',
'port': 5432,
'schema': 'public'
}
profile_cfg = {
'outputs': {
'test': self.target_dict,
},
'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.connections.psycopg2')
self.psycopg2 = self.patcher.start()
self.psycopg2.connect.return_value = self.handle
self.adapter = PostgresAdapter(self.config)
self.adapter.connections.query_header = MacroQueryStringSetter(
self.config, mock.MagicMock(macros={}))
self.qh_patch = mock.patch.object(
self.adapter.connections.query_header, 'add')
self.mock_query_header_add = self.qh_patch.start()
self.mock_query_header_add.side_effect = lambda q: '/* dbt */\n{}'.format(
q)
self.adapter.acquire_connection()
inject_adapter(self.adapter)
self.load_patch = mock.patch('dbt.parser.manifest.make_parse_result')
self.mock_parse_result = self.load_patch.start()
self.mock_parse_result.return_value = ParseResult.rpc()
def tearDown(self):
# we want a unique self.handle every time.
self.adapter.cleanup_connections()
self.qh_patch.stop()
self.patcher.stop()
self.load_patch.stop()
def test_quoting_on_drop_schema(self):
relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
quote_policy=self.adapter.config.quoting,
)
self.adapter.drop_schema(relation)
self.mock_execute.assert_has_calls([
mock.call('/* dbt */\ndrop schema if exists "test_schema" cascade',
None)
])
def test_quoting_on_drop(self):
relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='test_table',
type='table',
quote_policy=self.adapter.config.quoting,
)
self.adapter.drop_relation(relation)
self.mock_execute.assert_has_calls([
mock.call(
'/* dbt */\ndrop table if exists "postgres"."test_schema".test_table cascade',
None)
])
def test_quoting_on_truncate(self):
relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='test_table',
type='table',
quote_policy=self.adapter.config.quoting,
)
self.adapter.truncate_relation(relation)
self.mock_execute.assert_has_calls([
mock.call(
'/* dbt */\ntruncate table "postgres"."test_schema".test_table',
None)
])
def test_quoting_on_rename(self):
from_relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='table_a',
type='table',
quote_policy=self.adapter.config.quoting,
)
to_relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='table_b',
type='table',
quote_policy=self.adapter.config.quoting,
)
self.adapter.rename_relation(from_relation=from_relation,
to_relation=to_relation)
self.mock_execute.assert_has_calls([
mock.call(
'/* dbt */\nalter table "postgres"."test_schema".table_a rename to table_b',
None)
])
def test_debug_connection_ok(self):
DebugTask.validate_connection(self.target_dict)
self.mock_execute.assert_has_calls(
[mock.call('/* dbt */\nselect 1 as id', None)])
def test_debug_connection_fail_nopass(self):
del self.target_dict['pass']
with self.assertRaises(DbtConfigError):
DebugTask.validate_connection(self.target_dict)
def test_connection_fail_select(self):
self.mock_execute.side_effect = DatabaseError()
with self.assertRaises(DbtConfigError):
DebugTask.validate_connection(self.target_dict)
self.mock_execute.assert_has_calls(
[mock.call('/* dbt */\nselect 1 as id', None)])
def test_dbname_verification_is_case_insensitive(self):
# Override adapter settings from setUp()
self.target_dict['dbname'] = 'Postgres'
profile_cfg = {
'outputs': {
'test': self.target_dict,
},
'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.adapter.cleanup_connections()
self._adapter = PostgresAdapter(self.config)
self.adapter.verify_database('postgres')
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)
])
class TestConnectingPostgresAdapter(unittest.TestCase):
def setUp(self):
flags.STRICT_MODE = False
profile_cfg = {
'outputs': {
'test': {
'type': 'postgres',
'dbname': 'postgres',
'user': '******',
'host': 'thishostshouldnotexist',
'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.connections.psycopg2')
self.psycopg2 = self.patcher.start()
# there must be a better way to do this...
self.psycopg2.DatabaseError = DatabaseError
self.psycopg2.Error = Error
self.psycopg2.connect.return_value = self.handle
self.adapter = PostgresAdapter(self.config)
self.adapter.acquire_connection()
inject_adapter(self.adapter)
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(database='postgres', 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):
relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='test_table',
type='table',
quote_policy=self.adapter.config.quoting,
)
self.adapter.drop_relation(relation)
self.mock_execute.assert_has_calls([
mock.call(
'drop table if exists "postgres"."test_schema".test_table cascade',
None)
])
def test_quoting_on_truncate(self):
relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='test_table',
type='table',
quote_policy=self.adapter.config.quoting,
)
self.adapter.truncate_relation(relation)
self.mock_execute.assert_has_calls([
mock.call('truncate table "postgres"."test_schema".test_table',
None)
])
def test_quoting_on_rename(self):
from_relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='table_a',
type='table',
quote_policy=self.adapter.config.quoting,
)
to_relation = self.adapter.Relation.create(
database='postgres',
schema='test_schema',
identifier='table_b',
type='table',
quote_policy=self.adapter.config.quoting,
)
self.adapter.rename_relation(from_relation=from_relation,
to_relation=to_relation)
self.mock_execute.assert_has_calls([
mock.call(
'alter table "postgres"."test_schema".table_a rename to table_b',
None)
])
def tearDown(self):
# we want a unique self.handle every time.
PostgresAdapter.cleanup_connections()
self.patcher.stop()