diff --git a/tests/connectors/core/test_display.py b/tests/connectors/core/test_display.py index b21bab12b06214a0ff28e7ccd5f6cfec71e5ae42..6d2b1b682a0872a30537bef45bf290d9e22c2afe 100644 --- a/tests/connectors/core/test_display.py +++ b/tests/connectors/core/test_display.py @@ -191,7 +191,7 @@ class CoreDisplayTablesTestMixin: def test__display__show_tables(self): """""" - show_tables_query = '{0}{1}{2}'.format(OUTPUT_QUERY, self.show_tables_query, OUTPUT_RESET) + show_tables_query = '{0}{1}{2}'.format(OUTPUT_QUERY, self._show_tables_query, OUTPUT_RESET) # Since this directly tests display of tables, ensure we use a fresh database. db_name = '{0}d__tables__show'.format(self.test_db_name[0:-15]) @@ -207,7 +207,7 @@ class CoreDisplayTablesTestMixin: with self.subTest('Db name longer - Pt 1'): # Create table. - self.connector.tables.create('category', self.columns_query__basic, display_query=False) + self.connector.tables.create('category', self._columns_clause__basic, display_query=False) # Capture logging output. with self.assertLogs(None, 'INFO') as ilog: @@ -220,7 +220,7 @@ class CoreDisplayTablesTestMixin: with self.subTest('Db name longer - Pt 2'): # Create table. - self.connector.tables.create('priority', self.columns_query__basic, display_query=False) + self.connector.tables.create('priority', self._columns_clause__basic, display_query=False) # Capture logging output. with self.assertLogs(None, 'INFO') as ilog: @@ -233,7 +233,7 @@ class CoreDisplayTablesTestMixin: with self.subTest('Db name longer - Pt 3'): # Create table. - self.connector.tables.create('a', self.columns_query__basic, display_query=False) + self.connector.tables.create('a', self._columns_clause__basic, display_query=False) # Capture logging output. with self.assertLogs(None, 'INFO') as ilog: @@ -248,7 +248,7 @@ class CoreDisplayTablesTestMixin: # Create table. self.connector.tables.create( 'test___{0}___this_is_a_really_long_table_name__test_'.format(self.db_type.lower()), - self.columns_query__basic, + self._columns_clause__basic, display_query=False, ) @@ -265,7 +265,7 @@ class CoreDisplayTablesTestMixin: # Create table. self.connector.tables.create( 'test___{0}___this_is_a_really_long_table_name__test__'.format(self.db_type.lower()), - self.columns_query__basic, + self._columns_clause__basic, display_query=False, ) @@ -280,7 +280,7 @@ class CoreDisplayTablesTestMixin: with self.subTest('Table name longer - Pt 2'): # Create table. - self.connector.tables.create('zzz', self.columns_query__basic, display_query=False) + self.connector.tables.create('zzz', self._columns_clause__basic, display_query=False) # Capture logging output. with self.assertLogs(None, 'INFO') as ilog: @@ -295,7 +295,7 @@ class CoreDisplayTablesTestMixin: # Create table. self.connector.tables.create( 'test___{0}___this_is_a_really_long_table_name__testing__'.format(self.db_type.lower()), - self.columns_query__basic, + self._columns_clause__basic, display_query=False, ) @@ -310,7 +310,7 @@ class CoreDisplayTablesTestMixin: def test__display__describe_tables(self): """""" - describe_table_query = '{0}{1}{2}'.format(OUTPUT_QUERY, self.describe_table_query, OUTPUT_RESET) + describe_table_query = '{0}{1}{2}'.format(OUTPUT_QUERY, self._describe_table_query, OUTPUT_RESET) # Since this directly tests display of tables, ensure we use a fresh database. db_name = '{0}d__tables__desc'.format(self.test_db_name[0:-15]) @@ -318,7 +318,7 @@ class CoreDisplayTablesTestMixin: self.connector.database.use(db_name, display_query=False) # Create initial table to describe. - self.connector.tables.create('category', self.columns_query__minimal, display_query=False) + self.connector.tables.create('category', self._columns_clause__minimal, display_query=False) with self.subTest('With only id'): # Capture logging output. @@ -376,7 +376,7 @@ class CoreDisplayRecordsMixin: """""" select_from_query = '{0}SELECT * FROM category;{1}'.format(OUTPUT_QUERY, OUTPUT_RESET) - self.connector.tables.create('category', self.columns_query__basic, display_query=False) + self.connector.tables.create('category', self._columns_clause__basic, display_query=False) with self.subTest('With no records present'): # Capture logging output. diff --git a/tests/connectors/core/test_records.py b/tests/connectors/core/test_records.py index 599fde84c5158ff19babacf4e01d1009ae0c9b9b..180c82e7fcdd8489f5678240837e2efb630948da 100644 --- a/tests/connectors/core/test_records.py +++ b/tests/connectors/core/test_records.py @@ -27,8 +27,8 @@ class CoreRecordsTestMixin: """ cls.test_db_name_start = cls.test_db_name_start.format(cls.db_type) - cls._columns_query__basic = None - cls._columns_query__datetime = None + cls._columns_clause__basic = None + cls._columns_clause__datetime = None cls.error_handler__table_already_exists = None @@ -50,7 +50,7 @@ class CoreRecordsTestMixin: # Verify table exists. try: - self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__basic)) + self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic)) except self.error_handler__table_already_exists: # Table already exists, as we want. pass @@ -128,7 +128,7 @@ class CoreRecordsTestMixin: # Verify table exists. try: - self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__basic)) + self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic)) except self.error_handler__table_already_exists: # Table already exists, as we want. pass @@ -216,7 +216,7 @@ class CoreRecordsTestMixin: # Verify table exists. try: - self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__basic)) + self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic)) except self.error_handler__table_already_exists: # Table already exists, as we want. pass @@ -253,7 +253,7 @@ class CoreRecordsTestMixin: # Verify table exists. try: - self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_query__datetime)) + self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_clause__datetime)) except self.error_handler__table_already_exists: # Table already exists, as we want. pass @@ -315,7 +315,7 @@ class CoreRecordsTestMixin: # Verify table exists. try: - self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__basic)) + self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic)) except self.error_handler__table_already_exists: # Table already exists, as we want. pass @@ -415,7 +415,7 @@ class CoreRecordsTestMixin: # Verify table exists. try: - self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__datetime)) + self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__datetime)) except self.error_handler__table_already_exists: # Table already exists, as we want. pass @@ -566,7 +566,7 @@ class CoreRecordsTestMixin: # Verify table exists. try: - self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__basic)) + self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic)) except self.error_handler__table_already_exists: # Table already exists, as we want. pass diff --git a/tests/connectors/core/test_tables.py b/tests/connectors/core/test_tables.py index 87e2ff1f112ccd1573ede67216dfae28071e2bdd..40157c0d859cd2b44045610c12b6a620699dd48c 100644 --- a/tests/connectors/core/test_tables.py +++ b/tests/connectors/core/test_tables.py @@ -51,7 +51,7 @@ class CoreTablesTestMixin: self.assertNotIn(table_name, results) # Attempt to generate table. - self.connector.tables.create(table_name, self._basic_table_columns) + self.connector.tables.create(table_name, self._columns_clause__minimal) # Check that expected table now exists in database. results = self.connector.tables.show() @@ -85,7 +85,7 @@ class CoreTablesTestMixin: self.assertNotIn(table_name, results) # Attempt to generate table. - self.connector.tables.create(table_name, self._basic_table_columns) + self.connector.tables.create(table_name, self._columns_clause__minimal) # Check that expected table now exists in database. results = self.connector.tables.show() @@ -107,7 +107,7 @@ class CoreTablesTestMixin: with self.subTest('SHOW query when table exists'): # Verify table exists. try: - self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query)) + self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic)) except self.error_handler__table_already_exists: # Table already exists, as we want. pass @@ -152,7 +152,7 @@ class CoreTablesTestMixin: self.assertNotIn(table_name, results) # Run test query. - self.connector.tables.create(table_name, self._columns_query) + self.connector.tables.create(table_name, self._columns_clause__basic) # Check tables after test query. Verify expected table returned. results = self.connector.tables.show() @@ -167,7 +167,7 @@ class CoreTablesTestMixin: # Verify table exists. try: - self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query)) + self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic)) except self.error_handler__table_already_exists: # Table already exists, as we want. pass @@ -179,7 +179,7 @@ class CoreTablesTestMixin: # Run test query. with self.assertRaises(ValueError): - self.connector.tables.create(table_name, self._columns_query) + self.connector.tables.create(table_name, self._columns_clause__basic) # def test__modify_table__success(self): # """ @@ -192,7 +192,7 @@ class CoreTablesTestMixin: # # # Verify table exists. # try: - # self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query)) + # self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, _columns_clause__basic)) # except self.error_handler__table_already_exists: # # Table already exists, as we want. # pass @@ -279,7 +279,7 @@ class CoreTablesTestMixin: # Verify table exists. try: - self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query)) + self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic)) except self.error_handler__table_already_exists: # Table already exists, as we want. pass @@ -300,7 +300,7 @@ class CoreTablesTestMixin: # Verify table exists. # try: - self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query)) + self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic)) # Check tables prior to test query. Verify expected table returned. results = self.connector.tables.show() diff --git a/tests/connectors/mysql/constants.py b/tests/connectors/mysql/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..deac2545d3af09f4d10be86950ca53732a9489b7 --- /dev/null +++ b/tests/connectors/mysql/constants.py @@ -0,0 +1,41 @@ +""" +Various testing constants for MySQL. +""" + + +SHOW_TABLES_QUERY = """ +SHOW TABLES; +""".strip() + + +DESCRIBE_TABLE_QUERY = """ +DESCRIBE category; +""".strip() + + +COLUMNS_CLAUSE__MINIMAL = """ +( + id INT NOT NULL AUTO_INCREMENT, + PRIMARY KEY ( id ) +) +""".strip() + + +COLUMNS_CLAUSE__BASIC = """ +( + id INT NOT NULL AUTO_INCREMENT, + name VARCHAR(100), + description VARCHAR(100), + PRIMARY KEY ( id ) +) +""".strip() + + +COLUMNS_CLAUSE__DATETIME = """ +( + id INT NOT NULL AUTO_INCREMENT, + test_datetime DATETIME, + test_date DATE, + PRIMARY KEY ( id ) +) +""".strip() diff --git a/tests/connectors/mysql/test_display.py b/tests/connectors/mysql/test_display.py index 00ff0eca8ee947bea5d0a9489655b8014f9842eb..b2ed3518c6fcaf182e2d6f83ce3ef518731124da 100644 --- a/tests/connectors/mysql/test_display.py +++ b/tests/connectors/mysql/test_display.py @@ -5,6 +5,12 @@ Tests for "display" logic of "MySQL" DB Connector class. # System Imports. # Internal Imports. +from .constants import ( + DESCRIBE_TABLE_QUERY, + SHOW_TABLES_QUERY, + COLUMNS_CLAUSE__BASIC, + COLUMNS_CLAUSE__MINIMAL, +) from .test_core import TestMysqlDatabaseParent from .expected_display_output import ExpectedOutput from tests.connectors.core.test_display import ( @@ -14,27 +20,6 @@ from tests.connectors.core.test_display import ( ) -SHOW_TABLES_QUERY = """ -SHOW TABLES; -""".strip() -DESCRIBE_TABLE_QUERY = """DESCRIBE category;""" -COLUMNS_QUERY__MINIMAL = """ -( - id INT NOT NULL AUTO_INCREMENT, - PRIMARY KEY ( id ) -) -""".strip() -COLUMNS_QUERY__BASIC = """ -( - id INT NOT NULL AUTO_INCREMENT, - name VARCHAR(100), - description VARCHAR(100), - PRIMARY KEY ( id ) -) -""".strip() - - - class TestMysqlDisplayCore(TestMysqlDatabaseParent, CoreDisplayBaseTestMixin): """ Tests "MySQL" DB Connector class display logic. @@ -64,7 +49,7 @@ class TestMysqlDisplayCore(TestMysqlDatabaseParent, CoreDisplayBaseTestMixin): # Define expected output to compare against. cls.expected_output = ExpectedOutput - cls.show_tables_query = SHOW_TABLES_QUERY + cls._show_tables_query = SHOW_TABLES_QUERY class TestMysqlDisplayTables(TestMysqlDatabaseParent, CoreDisplayTablesTestMixin): @@ -96,10 +81,10 @@ class TestMysqlDisplayTables(TestMysqlDatabaseParent, CoreDisplayTablesTestMixin # Define expected output to compare against. cls.expected_output = ExpectedOutput - cls.show_tables_query = SHOW_TABLES_QUERY - cls.describe_table_query = DESCRIBE_TABLE_QUERY - cls.columns_query__minimal = COLUMNS_QUERY__MINIMAL - cls.columns_query__basic = COLUMNS_QUERY__BASIC + cls._show_tables_query = SHOW_TABLES_QUERY + cls._describe_table_query = DESCRIBE_TABLE_QUERY + cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL + cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC class TestMysqlDisplayRecords(TestMysqlDatabaseParent, CoreDisplayRecordsMixin): @@ -131,6 +116,6 @@ class TestMysqlDisplayRecords(TestMysqlDatabaseParent, CoreDisplayRecordsMixin): # Define expected output to compare against. cls.expected_output = ExpectedOutput - cls.show_tables_query = SHOW_TABLES_QUERY - cls.columns_query__minimal = COLUMNS_QUERY__MINIMAL - cls.columns_query__basic = COLUMNS_QUERY__BASIC + cls._show_tables_query = SHOW_TABLES_QUERY + cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL + cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC diff --git a/tests/connectors/mysql/test_records.py b/tests/connectors/mysql/test_records.py index bf849386f6d68bc1b3f1aa129d2ae39e0545747a..df595f2e9c36b4bdb8488f3677d6ef5a5ab3d005 100644 --- a/tests/connectors/mysql/test_records.py +++ b/tests/connectors/mysql/test_records.py @@ -6,6 +6,7 @@ Tests for "records" logic of "MySQL" DB Connector class. import textwrap # Internal Imports. +from .constants import COLUMNS_CLAUSE__BASIC, COLUMNS_CLAUSE__DATETIME from .test_core import TestMysqlDatabaseParent from tests.connectors.core.test_records import CoreRecordsTestMixin @@ -36,26 +37,8 @@ class TestMysqlRecords(TestMysqlDatabaseParent, CoreRecordsTestMixin): cls.connector.tables.drop(result) # Define default table columns. - cls._columns_query__basic = textwrap.dedent( - """ - ( - id INT NOT NULL AUTO_INCREMENT, - name VARCHAR(100), - description VARCHAR(100), - PRIMARY KEY ( id ) - ) - """ - ).strip() - cls._columns_query__datetime = textwrap.dedent( - """ - ( - id INT NOT NULL AUTO_INCREMENT, - test_datetime DATETIME, - test_date DATE, - PRIMARY KEY ( id ) - ) - """ - ).strip() + cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC + cls._columns_clause__datetime = COLUMNS_CLAUSE__DATETIME cls.error_handler__table_already_exists = cls.db_error_handler.OperationalError @@ -72,7 +55,7 @@ class TestMysqlRecords(TestMysqlDatabaseParent, CoreRecordsTestMixin): with self.subTest('Verify handling when database already exists'): # Make sure we're using a table name that is not already created. table_name = 'test_table' - self.connector.tables.create(table_name, self._columns_query__basic) + self.connector.tables.create(table_name, self._columns_clause__basic) results = self.connector.tables.show() if table_name not in results: @@ -80,4 +63,4 @@ class TestMysqlRecords(TestMysqlDatabaseParent, CoreRecordsTestMixin): # Check that we use the correct handler. with self.assertRaises(self.error_handler__table_already_exists): - self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_query__basic)) + self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_clause__basic)) diff --git a/tests/connectors/mysql/test_tables.py b/tests/connectors/mysql/test_tables.py index 49c0677c7d987d55170df818cb42f0f124d0aaa4..b97da30e14307f610500f082adea4bdbf4895af9 100644 --- a/tests/connectors/mysql/test_tables.py +++ b/tests/connectors/mysql/test_tables.py @@ -6,6 +6,10 @@ Tests for "tables" logic of "MySQL" DB Connector class. import textwrap # Internal Imports. +from .constants import ( + COLUMNS_CLAUSE__MINIMAL, + COLUMNS_CLAUSE__BASIC, +) from .test_core import TestMysqlDatabaseParent from tests.connectors.core.test_tables import CoreTablesTestMixin @@ -36,24 +40,8 @@ class TestMysqlTables(TestMysqlDatabaseParent, CoreTablesTestMixin): cls.connector.tables.drop(result) # Define database-specific query values. - cls._basic_table_columns = textwrap.dedent( - """ - ( - id INT(11) NOT NULL AUTO_INCREMENT, - PRIMARY KEY (id) - ) - """ - ).strip() - cls._columns_query = textwrap.dedent( - """ - ( - id INT NOT NULL AUTO_INCREMENT, - name VARCHAR(100), - description VARCHAR(100), - PRIMARY KEY ( id ) - ) - """ - ).strip() + cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL + cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC cls.error_handler__table_does_not_exist = cls.db_error_handler.OperationalError cls.error_handler__table_already_exists = cls.db_error_handler.OperationalError @@ -82,7 +70,7 @@ class TestMysqlTables(TestMysqlDatabaseParent, CoreTablesTestMixin): with self.subTest('Verify handling when database already exists'): # Make sure we're using a table name that is not already created. table_name = 'test_table' - self.connector.tables.create(table_name, self._basic_table_columns) + self.connector.tables.create(table_name, self._columns_clause__minimal) results = self.connector.tables.show() if table_name not in results: @@ -90,4 +78,4 @@ class TestMysqlTables(TestMysqlDatabaseParent, CoreTablesTestMixin): # Check that we use the correct handler. with self.assertRaises(self.error_handler__table_already_exists): - self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._basic_table_columns)) + self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_clause__minimal)) diff --git a/tests/connectors/postgresql/constants.py b/tests/connectors/postgresql/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..90c0cf9837a964440c553e568ae53775716ceaec --- /dev/null +++ b/tests/connectors/postgresql/constants.py @@ -0,0 +1,40 @@ +""" +Various testing constants for PostgreSQL. +""" + + +SHOW_TABLES_QUERY = """ +SELECT table_name FROM information_schema.tables +WHERE table_schema = 'public'; +""".strip() + + +DESCRIBE_TABLE_QUERY = """ +SELECT * FROM information_schema.columns +WHERE (table_schema = 'public' AND table_name = 'category'); +""".strip() + + +COLUMNS_CLAUSE__MINIMAL = """ +( + id serial PRIMARY KEY +) +""".strip() + + +COLUMNS_CLAUSE__BASIC = """ +( + id serial PRIMARY KEY, + name VARCHAR(100), + description VARCHAR(100) +) +""".strip() + + +COLUMNS_CLAUSE__DATETIME = """ +( + id serial PRIMARY KEY, + test_datetime TIMESTAMP, + test_date DATE +) +""".strip() diff --git a/tests/connectors/postgresql/test_display.py b/tests/connectors/postgresql/test_display.py index 040ca3665717a9b2d89d4fecd64902ffc7b6e517..550fc9776ba0e64c339c64bb14dc94b104afd05c 100644 --- a/tests/connectors/postgresql/test_display.py +++ b/tests/connectors/postgresql/test_display.py @@ -5,6 +5,12 @@ Tests for "display" logic of "PostgreSQL" DB Connector class. # System Imports. # Internal Imports. +from .constants import ( + DESCRIBE_TABLE_QUERY, + SHOW_TABLES_QUERY, + COLUMNS_CLAUSE__BASIC, + COLUMNS_CLAUSE__MINIMAL, +) from .expected_display_output import ExpectedOutput from .test_core import TestPostgresqlDatabaseParent from tests.connectors.core.test_display import ( @@ -14,28 +20,6 @@ from tests.connectors.core.test_display import ( ) -SHOW_TABLES_QUERY = """ -SELECT table_name FROM information_schema.tables -WHERE table_schema = 'public'; -""".strip() -DESCRIBE_TABLE_QUERY = """ -SELECT * FROM information_schema.columns -WHERE (table_schema = 'public' AND table_name = 'category'); -""".strip() -COLUMNS_QUERY__MINIMAL = """ -( - id serial PRIMARY KEY -) -""".strip() -COLUMNS_QUERY__BASIC = """ -( - id serial PRIMARY KEY, - name VARCHAR(100), - description VARCHAR(100) -) -""".strip() - - class TestPostgresqlDisplay(TestPostgresqlDatabaseParent, CoreDisplayBaseTestMixin): """ Tests "PostgreSQL" DB Connector class display logic. @@ -63,7 +47,7 @@ class TestPostgresqlDisplay(TestPostgresqlDatabaseParent, CoreDisplayBaseTestMix # Define expected output to compare against. cls.expected_output = ExpectedOutput - cls.show_tables_query = SHOW_TABLES_QUERY + cls._show_tables_query = SHOW_TABLES_QUERY class TestPostgresqlDisplayTables(TestPostgresqlDatabaseParent, CoreDisplayTablesTestMixin): @@ -95,10 +79,10 @@ class TestPostgresqlDisplayTables(TestPostgresqlDatabaseParent, CoreDisplayTable # Define expected output to compare against. cls.expected_output = ExpectedOutput - cls.show_tables_query = SHOW_TABLES_QUERY - cls.describe_table_query = DESCRIBE_TABLE_QUERY - cls.columns_query__minimal = COLUMNS_QUERY__MINIMAL - cls.columns_query__basic = COLUMNS_QUERY__BASIC + cls._show_tables_query = SHOW_TABLES_QUERY + cls._describe_table_query = DESCRIBE_TABLE_QUERY + cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL + cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC class TestPostgreSQLDisplayRecords(TestPostgresqlDatabaseParent, CoreDisplayRecordsMixin): @@ -130,6 +114,6 @@ class TestPostgreSQLDisplayRecords(TestPostgresqlDatabaseParent, CoreDisplayReco # Define expected output to compare against. cls.expected_output = ExpectedOutput - cls.show_tables_query = SHOW_TABLES_QUERY - cls.columns_query__minimal = COLUMNS_QUERY__MINIMAL - cls.columns_query__basic = COLUMNS_QUERY__BASIC + cls._show_tables_query = SHOW_TABLES_QUERY + cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL + cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC diff --git a/tests/connectors/postgresql/test_records.py b/tests/connectors/postgresql/test_records.py index d5ce428d06071bcd616d11d727e27a38efd21fcf..3b4e43c6fab62ca39451dd0b65514edfda0415dc 100644 --- a/tests/connectors/postgresql/test_records.py +++ b/tests/connectors/postgresql/test_records.py @@ -6,6 +6,7 @@ Tests for "records" logic of "PostgreSQL" DB Connector class. import textwrap # Internal Imports. +from .constants import COLUMNS_CLAUSE__BASIC, COLUMNS_CLAUSE__DATETIME from .test_core import TestPostgresqlDatabaseParent from tests.connectors.core.test_records import CoreRecordsTestMixin @@ -36,24 +37,8 @@ class TestPostgresqlRecords(TestPostgresqlDatabaseParent, CoreRecordsTestMixin): cls.connector.tables.drop(result) # Define default table columns. - cls._columns_query__basic = textwrap.dedent( - """ - ( - id serial PRIMARY KEY, - name VARCHAR(100), - description VARCHAR(100) - ) - """ - ).strip() - cls._columns_query__datetime = textwrap.dedent( - """ - ( - id serial PRIMARY KEY, - test_datetime TIMESTAMP, - test_date DATE - ) - """ - ).strip() + cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC + cls._columns_clause__datetime = COLUMNS_CLAUSE__DATETIME cls.error_handler__table_already_exists = cls.db_error_handler.errors.DuplicateTable @@ -70,7 +55,7 @@ class TestPostgresqlRecords(TestPostgresqlDatabaseParent, CoreRecordsTestMixin): with self.subTest('Verify handling when database already exists'): # Make sure we're using a table name that is not already created. table_name = 'test_table' - self.connector.tables.create(table_name, self._columns_query__basic) + self.connector.tables.create(table_name, self._columns_clause__basic) results = self.connector.tables.show() if table_name not in results: @@ -78,4 +63,4 @@ class TestPostgresqlRecords(TestPostgresqlDatabaseParent, CoreRecordsTestMixin): # Check that we use the correct handler. with self.assertRaises(self.error_handler__table_already_exists): - self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_query__basic)) + self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_clause__basic)) diff --git a/tests/connectors/postgresql/test_tables.py b/tests/connectors/postgresql/test_tables.py index b26b26d0b7bc4651f6396f173e06b60a88a563b0..2ff6c36f407e235d8efa393435776abbe6ad4306 100644 --- a/tests/connectors/postgresql/test_tables.py +++ b/tests/connectors/postgresql/test_tables.py @@ -3,9 +3,9 @@ Tests for "tables" logic of "PostgreSQL" DB Connector class. """ # System Imports. -import textwrap # Internal Imports. +from .constants import COLUMNS_CLAUSE__MINIMAL, COLUMNS_CLAUSE__BASIC from .test_core import TestPostgresqlDatabaseParent from tests.connectors.core.test_tables import CoreTablesTestMixin @@ -36,22 +36,8 @@ class TestPostgresqlTables(TestPostgresqlDatabaseParent, CoreTablesTestMixin): cls.connector.tables.drop(result) # Define database-specific query values. - cls._basic_table_columns = textwrap.dedent( - """ - ( - id serial PRIMARY KEY - ) - """ - ).strip() - cls._columns_query = textwrap.dedent( - """ - ( - id serial PRIMARY KEY, - name VARCHAR(100), - description VARCHAR(100) - ) - """ - ).strip() + cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL + cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC cls.error_handler__table_does_not_exist = cls.db_error_handler.errors.UndefinedTable cls.error_handler__table_already_exists = cls.db_error_handler.errors.DuplicateTable @@ -80,7 +66,7 @@ class TestPostgresqlTables(TestPostgresqlDatabaseParent, CoreTablesTestMixin): with self.subTest('Verify handling when database already exists'): # Make sure we're using a table name that is not already created. table_name = 'test_table' - self.connector.tables.create(table_name, self._basic_table_columns) + self.connector.tables.create(table_name, self._columns_clause__minimal) results = self.connector.tables.show() if table_name not in results: @@ -88,4 +74,4 @@ class TestPostgresqlTables(TestPostgresqlDatabaseParent, CoreTablesTestMixin): # Check that we use the correct handler. with self.assertRaises(self.error_handler__table_already_exists): - self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._basic_table_columns)) + self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_clause__minimal))