def before(self):
with test_utils.Database(self.server) as (connection, _):
if connection.server_version < 90100:
self.skipTest(
"COLLATE is not present in PG versions below v9.1"
)
connection = test_utils.get_db_connection(
self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'],
self.server['sslmode']
)
test_utils.drop_database(connection, "acceptance_test_db")
test_utils.create_database(self.server, "acceptance_test_db")
# Create pre-requisite table
for k, v in {1: 'id', 2: '"ID"'}.items():
test_utils.create_table_with_query(
self.server,
"acceptance_test_db",
CheckForViewDataTest.defaults_query.format(k, v))
# Initialize an instance of WebDriverWait with timeout of 3 seconds
self.wait = WebDriverWait(self.driver, 3)
def before(self):
with test_utils.Database(self.server) as (connection, _):
if connection.server_version < 90100:
self.skipTest(
"COLLATE is not present in PG versions below v9.1"
)
connection = test_utils.get_db_connection(
self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'],
self.server['sslmode']
)
test_utils.drop_database(connection, "acceptance_test_db")
test_utils.create_database(self.server, "acceptance_test_db")
# Create pre-requisite table
for k, v in {1: 'id', 2: '"ID"'}.items():
test_utils.create_table_with_query(
self.server,
"acceptance_test_db",
CheckForViewDataTest.defaults_query.format(k, v))
# Initialize an instance of WebDriverWait with timeout of 3 seconds
self.wait = WebDriverWait(self.driver, 3)
def before(self):
with test_utils.Database(self.server) as (connection, _):
if connection.server_version < 90100:
self.skipTest(
"COLLATE is not present in PG versions below v9.1"
)
# Create pre-requisite table
for k, v in {1: 'id', 2: '"ID"'}.items():
test_utils.create_table_with_query(
self.server,
self.test_db,
CheckForViewDataTest.defaults_query.format(k, v))
test_utils.create_table_with_query(
self.server,
self.test_db,
CheckForViewDataTest.non_int_pkey_table
)
# Initialize an instance of WebDriverWait with timeout of 3 seconds
self.wait = WebDriverWait(self.driver, 3)
# close the db connection
connection.close()
def _create_test_table(self):
test_table_name = "test_for_updatable_resultset" + \
str(random.randint(1000, 9999))
create_sql = """
DROP TABLE IF EXISTS "%s";
CREATE TABLE "%s"(
pk_col INT PRIMARY KEY,
normal_col VARCHAR);
INSERT INTO "%s" VALUES
(1, 'one'),
(2, 'two');
""" % (test_table_name, test_table_name, test_table_name)
self.select_sql = "SELECT * FROM %s" % test_table_name
utils.create_table_with_query(self.server, self.db_name, create_sql)
def before(self):
self.test_table_name = "test_table" + str(random.randint(1000, 3000))
test_utils.create_table(self.server, self.test_db,
self.test_table_name)
self.test_editable_table_name = "test_editable_table" + \
str(random.randint(1000, 3000))
create_sql = '''
CREATE TABLE "%s" (
pk_column NUMERIC PRIMARY KEY,
normal_column NUMERIC
);
''' % self.test_editable_table_name
test_utils.create_table_with_query(self.server, self.test_db,
create_sql)
self.page.add_server(self.server)
def runTest(self):
self.table = "test_table_%s" % (str(uuid.uuid4())[1:8])
self.table_sql = self.table_sql.replace('<TABLE_NAME>', self.table)
# Create table
test_utils.create_table_with_query(self.server,
self.db_name,
self.table_sql)
# Fetch Table OID
pg_cursor = self.connection.cursor()
pg_cursor.execute("""Select oid FROM pg_catalog.pg_class WHERE
relname = '%s' AND relkind IN ('r','s','t')""" % self.table)
result = pg_cursor.fetchall()
table_id = result[0][0]
# Initialize query tool
self.trans_id = str(secrets.choice(range(1, 9999999)))
url = '/sqleditor/initialize/viewdata/{0}/3/table/{1}/{2}/{3}/{4}' \
.format(self.trans_id, test_utils.SERVER_GROUP, self.server_id,
self.db_id, table_id)
if hasattr(self, 'mock_data'):
with patch(
self.mock_data['function_to_be_mocked'],
return_value=self.mock_data['return_value']
):
response = self.tester.post(url)
else:
response = self.tester.post(url)
self.assertEqual(response.status_code, 200)
url = "/sqleditor/view_data/start/{0}".format(self.trans_id)
response = self.tester.get(url)
self.assertEqual(response.status_code, 200)
# Check the query result
url = '/sqleditor/poll/{0}'.format(self.trans_id)
response = self.tester.get(url)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.data.decode('utf-8'))
self.assertEqual(response_data['data']['result'], self.result_data)
self.assertEqual(response_data['data']['rows_fetched_to'],
self.rows_fetched_to)
def _create_test_table(self, table_has_oids=False):
create_sql = """
DROP TABLE IF EXISTS {0};
CREATE TABLE {0}(
pk_col1 SERIAL,
pk_col2 SERIAL,
normal_col1 VARCHAR,
normal_col2 VARCHAR,
PRIMARY KEY(pk_col1, pk_col2)
)
""".format(self.test_table_name)
if table_has_oids:
create_sql += ' WITH OIDS;'
else:
create_sql += ';'
utils.create_table_with_query(self.server, self.db_name, create_sql)
def setUp(self):
self.encode_db_name = 'test_encoding_' + self.db_encoding
self.encode_sid = self.server_information['server_id']
server_con = server_utils.connect_server(self, self.encode_sid)
if hasattr(self, 'skip_on_database'):
if 'data' in server_con and 'type' in server_con['data']:
if server_con['data']['type'] in self.skip_on_database:
self.skipTest('cannot run in: %s' %
server_con['data']['type'])
self.encode_did = test_utils.create_database(
self.server, self.encode_db_name,
(self.db_encoding, self.lc_collate))
test_utils.create_table_with_query(
self.server, self.encode_db_name, """CREATE TABLE {0}(
name character varying(200) COLLATE pg_catalog."default")
""".format(self.table_name))
def before(self):
with test_utils.Database(self.server) as (connection, _):
if connection.server_version < 90100:
self.skipTest(
"COLLATE is not present in PG versions below v9.1"
)
# Create pre-requisite table
for k, v in {1: 'id', 2: '"ID"'}.items():
test_utils.create_table_with_query(
self.server,
self.test_db,
CheckForViewDataTest.defaults_query.format(k, v))
# Initialize an instance of WebDriverWait with timeout of 3 seconds
self.wait = WebDriverWait(self.driver, 3)
# close the db connection
connection.close()
def _create_test_table(self):
self.test_table_name = "test_for_save_data" + \
str(random.randint(1000, 9999))
create_sql = """
DROP TABLE IF EXISTS "%s";
CREATE TABLE "%s"(
pk_col INT PRIMARY KEY,
normal_col character varying(5),
char_col character(4),
bit_col bit(5));
INSERT INTO "%s" VALUES
(1, 'one', 'ch1', '00000'),
(2, 'two', 'ch2', '11111');
""" % (self.test_table_name, self.test_table_name,
self.test_table_name)
self.select_sql = 'SELECT * FROM %s;' % self.test_table_name
utils.create_table_with_query(self.server, self.db_name, create_sql)
def before(self):
self.test_table_name = "test_table" + str(random.randint(1000, 3000))
test_utils.create_table(self.server, self.test_db,
self.test_table_name)
self.test_editable_table_name = "test_editable_table" + \
str(random.randint(1000, 3000))
create_sql = '''
CREATE TABLE "%s" (
pk_column NUMERIC PRIMARY KEY,
normal_column NUMERIC
);
''' % self.test_editable_table_name
test_utils.create_table_with_query(self.server, self.test_db,
create_sql)
self.page.add_server(self.server)
driver_version = test_utils.get_driver_version()
self.driver_version = float('.'.join(driver_version.split('.')[:2]))
def setUp(self):
self.encode_db_name = 'test_encoding_' + self.db_encoding
self.encode_sid = self.server_information['server_id']
server_con = server_utils.connect_server(self, self.encode_sid)
if hasattr(self, 'skip_on_database'):
if 'data' in server_con and 'type' in server_con['data']:
if server_con['data']['type'] in self.skip_on_database:
self.skipTest('cannot run in: %s' %
server_con['data']['type'])
self.encode_did = test_utils.create_database(
self.server, self.encode_db_name,
(self.db_encoding, self.lc_collate))
test_utils.create_table_with_query(
self.server,
self.encode_db_name,
"""CREATE TABLE {0}(
name character varying(200) COLLATE pg_catalog."default")
""".format(self.table_name))
def _create_test_table(self, table_has_oids=False):
self.test_table_name = "test_for_updatable_resultset" + \
str(random.randint(1000, 9999))
create_sql = """
DROP TABLE IF EXISTS "%s";
CREATE TABLE "%s"(
pk_col1 SERIAL,
pk_col2 SERIAL,
normal_col1 VARCHAR,
normal_col2 VARCHAR,
PRIMARY KEY(pk_col1, pk_col2)
)
""" % (self.test_table_name, self.test_table_name)
if table_has_oids:
create_sql += ' WITH OIDS;'
else:
create_sql += ';'
utils.create_table_with_query(self.server, self.db_name, create_sql)
def runTest(self):
self.table = "test_table_%s" % (str(uuid.uuid4())[1:8])
self.table_sql = self.table_sql.replace('<TABLE_NAME>', self.table)
# Create table
test_utils.create_table_with_query(self.server, self.db_name,
self.table_sql)
# Fetch Table OID
pg_cursor = self.connection.cursor()
pg_cursor.execute("""Select oid FROM pg_class WHERE
relname = '%s' AND relkind IN ('r','s','t')""" % self.table)
result = pg_cursor.fetchall()
table_id = result[0][0]
# Initialize query tool
url = '/datagrid/initialize/datagrid/3/table/{0}/{1}/{2}/{3}'.format(
test_utils.SERVER_GROUP, self.server_id, self.db_id, table_id)
response = self.tester.post(url)
self.assertEquals(response.status_code, 200)
response_data = json.loads(response.data.decode('utf-8'))
self.trans_id = response_data['data']['gridTransId']
url = "/sqleditor/view_data/start/{0}".format(self.trans_id)
response = self.tester.get(url)
self.assertEquals(response.status_code, 200)
# Check the query result
url = '/sqleditor/poll/{0}'.format(self.trans_id)
response = self.tester.get(url)
self.assertEquals(response.status_code, 200)
response_data = json.loads(response.data.decode('utf-8'))
self.assertEquals(response_data['data']['result'], self.result_data)
self.assertEquals(response_data['data']['rows_fetched_to'],
self.rows_fetched_to)
def before(self):
self.test_table_name = "test_table" + str(
secrets.choice(range(1000, 3000)))
self.invalid_table_name = \
"table_that_doesnt_exist_" + str(secrets.choice(range(1000, 3000)))
test_utils.create_table(self.server, self.test_db,
self.test_table_name)
self.test_editable_table_name = "test_editable_table" + \
str(secrets.choice(range(1000, 3000)))
create_sql = '''
CREATE TABLE "%s" (
pk_column NUMERIC PRIMARY KEY,
normal_column NUMERIC
);
''' % self.test_editable_table_name
test_utils.create_table_with_query(self.server, self.test_db,
create_sql)
self.page.add_server(self.server)
driver_version = test_utils.get_driver_version()
self.driver_version = float('.'.join(driver_version.split('.')[:2]))
self.wait = WebDriverWait(self.page.driver, 10)
