def runTest(self):
""" When there are no permissions on the column, it returns an empty result """
with test_utils.Database(self.server) as (connection, database_name):
test_utils.create_table(self.server, database_name, "test_table")
cursor = connection.cursor()
cursor.execute(
"SELECT pg_class.oid as table_id, "
"pg_attribute.attnum as column_id "
"FROM pg_class join pg_attribute on attrelid=pg_class.oid "
"where pg_class.relname='test_table'"
" and pg_attribute.attname = 'some_column'")
table_id, column_id = cursor.fetchone()
if connection.server_version < 90100:
self.versions_to_test = ['default']
else:
self.versions_to_test = ['9.1_plus']
for version in self.versions_to_test:
template_file = os.path.join(os.path.dirname(__file__), "..",
version, "acl.sql")
template = file_as_template(template_file)
public_schema_id = 2200
sql = template.render(scid=public_schema_id,
tid=table_id,
clid=column_id)
cursor = connection.cursor()
cursor.execute(sql)
fetch_result = cursor.fetchall()
self.assertEqual(0, len(fetch_result))
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 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 runTest(self):
""" When there are no triggers, it returns an empty result """
with test_utils.Database(self.server) as (connection, database_name):
test_utils.create_table(self.server, database_name, "test_table")
cursor = connection.cursor()
cursor.execute("SELECT pg_class.oid AS table_id "
"FROM pg_class "
"WHERE pg_class.relname='test_table'")
table_id = cursor.fetchone()[0]
if connection.server_version < 90100:
self.versions_to_test = ['default']
else:
self.versions_to_test = ['9.1_plus']
for version in self.versions_to_test:
template_file = os.path.join(os.path.dirname(__file__), "..", version, "nodes.sql")
template = file_as_template(template_file)
sql = template.render(tid=table_id)
cursor = connection.cursor()
cursor.execute(sql)
fetch_result = cursor.fetchall()
self.assertEqual(0, len(fetch_result))
def runTest(self):
""" This tests that column properties are returned"""
with test_utils.Database(self.server) as (connection, database_name):
test_utils.create_table(self.server, database_name, "test_table")
cursor = connection.cursor()
cursor.execute("SELECT oid FROM pg_class where relname='test_table'")
table_id = cursor.fetchone()[0]
if connection.server_version < 90100:
self.versions_to_test = ['default']
else:
self.versions_to_test = ['9.1_plus']
for version in self.versions_to_test:
template_file = os.path.join(os.path.dirname(__file__), "..", version, "properties.sql")
template = file_as_template(template_file)
public_schema_id = 2200
sql = template.render(scid=public_schema_id,
tid=table_id
)
cursor = connection.cursor()
cursor.execute(sql)
fetch_result = cursor.fetchall()
first_row = {}
for index, description in enumerate(cursor.description):
first_row[description.name] = fetch_result[0][index]
self.assertEqual('some_column', first_row['name'])
self.assertEqual('character varying', first_row['cltype'])
self.assertEqual(2, len(fetch_result))
def before(self):
with test_utils.Database(self.server) as (connection, _):
if connection.server_version < 90100:
self.skipTest("Functions tree node is not present in pgAdmin below PG v9.1")
# Some test function is needed for debugger
test_utils.create_debug_function(self.server, "postgres",
"a_test_function")
def before(self):
with test_utils.Database(self.server) as (connection, _):
if connection.server_version < 90100:
self.skipTest(
"Membership is not present in Postgres below PG v9.1")
# Some test function is needed for debugger
test_utils.create_role(self.server, "postgres", "test_role")
test_utils.create_role(self.server, "postgres", "<h1>test</h1>")
def setUp(self):
with test_utils.Database(self.server) as (connection, database_name):
cursor = connection.cursor()
try:
cursor.execute("CREATE ROLE testpgadmin LOGIN PASSWORD '%s'" %
self.server['db_password'])
except Exception as exception:
print(exception)
connection.commit()
self.server_with_modified_user = self.server.copy()
self.server_with_modified_user['username'] = "******"
def before(self):
with test_utils.Database(self.server) as (connection, _):
if connection.server_version < 90100:
self.skipTest(
"Membership is not present in Postgres below PG v9.1")
# create role
self.role = "test_role" + str(random.randint(10000, 65535))
# Some test function is needed for debugger
test_utils.create_role(self.server, "postgres", self.role)
test_utils.create_role(self.server, "postgres", "<h1>test</h1>")
self.wait = WebDriverWait(self.page.driver, 20)
def before(self):
with test_utils.Database(self.server) as (connection, _):
if connection.server_version < 90100:
self.skipTest(
"Functions tree node is not present in pgAdmin below "
"PG v9.1")
# Some test function is needed for debugger
test_utils.create_debug_function(self.server, "postgres",
"a_test_function")
if test_utils.does_function_exist(self.server, 'postgres',
'a_test_function') != 'True':
raise Exception("The required function is not found")
def runTest(self):
""" This tests that all applicable sql template versions can fetch some ddl """
with test_utils.Database(self.server) as (connection, database_name):
test_utils.create_table(self.server, database_name, "test_table")
cursor = connection.cursor()
cursor.execute(u"""
SELECT
db.oid as did, datlastsysoid
FROM
pg_database db
WHERE db.datname = '{0}'""".format(database_name))
database_id, last_system_oid = cursor.fetchone()
cursor = connection.cursor()
cursor.execute(
"SELECT oid FROM pg_class where relname='test_table'")
table_id = cursor.fetchone()[0]
if connection.server_version < 90100:
self.versions_to_test = ['default']
else:
self.versions_to_test = ['9.1_plus']
for version in self.versions_to_test:
template_file = os.path.join(os.path.dirname(__file__), "..",
version, "properties.sql")
template = file_as_template(template_file)
public_schema_id = 2200
sql = template.render(scid=public_schema_id,
did=database_id,
datlastsysoid=last_system_oid,
tid=table_id)
cursor = connection.cursor()
cursor.execute(sql)
fetch_result = cursor.fetchone()
first_row = {}
for index, description in enumerate(cursor.description):
first_row[description.name] = fetch_result[index]
self.assertEqual('test_table', first_row['name'])
# triggercount is sometimes returned as a string for some reason
self.assertEqual(0, long(first_row['triggercount']))
self.assertEqual(None, first_row['typname'])
self.assertEqual([], first_row['coll_inherits'])
def before(self):
with test_utils.Database(self.server) as (connection, _):
if connection.server_version < 90100:
self.skipTest(
"Functions tree node is not present in pgAdmin below "
"PG v9.1")
# Some test function is needed for debugger
self.function_name = "a_test_function" + \
str(random.randint(10000, 65535))
test_utils.create_debug_function(self.server, self.test_db,
self.function_name)
if test_utils.does_function_exist(self.server, self.test_db,
self.function_name) != 'True':
raise RuntimeError("The required function is not found")
def runTest(self):
if hasattr(self, "ignore_test"):
return
supported_modes = ['require', 'verify-ca', 'verify-full']
if self.server['sslmode'] in supported_modes:
with test_utils.Database(self.server) as (connection,
database_name):
cursor = connection.cursor()
cursor.execute("CREATE EXTENSION sslinfo")
connection.commit()
cursor.execute("SELECT ssl_is_used()")
is_ssl_used = cursor.fetchone()[0]
self.assertEquals(True, is_ssl_used)
else:
self.skipTest("Cannot run SSL connection check test "
"with '{0}' sslmode".format(self.server['sslmode']))
def runTest(self):
if hasattr(self, "ignore_test"):
return
with test_utils.Database(self.server) as (connection, database_name):
test_utils.create_table(self.server_with_modified_user,
database_name, "test_new_role_table")
cursor = connection.cursor()
cursor.execute("SELECT pg_class.oid AS table_id "
"FROM pg_class "
"WHERE pg_class.relname='test_new_role_table'")
self.table_id = cursor.fetchone()[0]
sql = self.generate_sql(connection.server_version)
cursor.execute(sql)
fetch_result = cursor.fetchall()
self.assertions(fetch_result, cursor.description)
def runTest(self):
if hasattr(self, "ignore_test"):
return
with test_utils.Database(self.server) as (connection, database_name):
test_utils.create_table(self.server, database_name, "test_table")
self.database_name = database_name
cursor = connection.cursor()
self.test_setup(connection, cursor)
sql = self.generate_sql(connection.server_version)
cursor = connection.cursor()
cursor.execute(sql)
fetch_result = cursor.fetchall()
self.assertions(fetch_result, cursor.description)
def runTest(self):
""" This tests that all applicable sql template versions can fetch table names """
with test_utils.Database(self.server) as (connection, database_name):
test_utils.create_table(self.server, database_name, "test_table")
if connection.server_version < 91000:
self.versions_to_test = ['default']
else:
self.versions_to_test = ['default', '9.1_plus']
for version in self.versions_to_test:
template_file = os.path.join(os.path.dirname(__file__), "..",
version, "nodes.sql")
file_content = open(template_file, 'r').read()
env = Environment(loader=SimpleTemplateLoader(file_content))
template = env.get_template("")
public_schema_id = 2200
sql = template.render(scid=public_schema_id)
cursor = connection.cursor()
cursor.execute(sql)
fetch_result = cursor.fetchall()
first_row = {}
for index, description in enumerate(cursor.description):
first_row[description.name] = fetch_result[0][index]
oid = first_row['oid']
name = first_row['name']
triggercount = first_row['triggercount']
has_enable_triggers = first_row['has_enable_triggers']
self.assertIsNotNone(long(oid))
self.assertEqual('test_table', name)
# triggercount is sometimes returned as a string for some reason
self.assertEqual(0, long(triggercount))
self.assertIsNotNone(long(has_enable_triggers))
def runTest(self):
""" This tests that when there are permissions set up on the table, acl query returns the permissions"""
with test_utils.Database(self.server) as (connection, database_name):
test_utils.create_table(self.server, database_name, "test_table")
cursor = connection.cursor()
cursor.execute("GRANT SELECT ON test_table TO PUBLIC")
cursor = connection.cursor()
cursor.execute("SELECT oid FROM pg_class WHERE relname='test_table'")
table_id = cursor.fetchone()[0]
if connection.server_version < 90100:
self.versions_to_test = ['default']
else:
self.versions_to_test = ['9.1_plus']
for version in self.versions_to_test:
template_file = os.path.join(os.path.dirname(__file__), "..", version, "acl.sql")
template = file_as_template(template_file)
public_schema_id = 2200
sql = template.render(scid=public_schema_id,
tid=table_id)
cursor = connection.cursor()
cursor.execute(sql)
fetch_result = cursor.fetchall()
public_acls = list(filter(lambda acl: acl[1] == 'PUBLIC', fetch_result))
self.assertEqual(len(public_acls), 1)
new_acl_map = dict(zip(map(lambda column: column.name, cursor.description), public_acls[0]))
self.assertEqual('PUBLIC', new_acl_map['grantee'])
self.assertEqual(self.server['username'], new_acl_map['grantor'])
self.assertEqual('relacl', new_acl_map['deftype'])
self.assertEqual(['r'], new_acl_map['privileges'])
self.assertEqual([False], new_acl_map['grantable'])
def runTest(self):
if hasattr(self, "ignore_test"):
return
with test_utils.Database(self.server) as (connection, database_name):
test_utils.create_table(self.server, database_name, "test_table")
self.database_name = database_name
if connection.server_version < 90100:
self.versions_to_test = ['default']
else:
self.versions_to_test = ['9.1_plus']
cursor = connection.cursor()
self.test_setup(connection, cursor)
for version in self.versions_to_test:
sql = self.generate_sql(version)
cursor = connection.cursor()
cursor.execute(sql)
fetch_result = cursor.fetchall()
self.assertions(fetch_result, cursor.description)
def tearDown(self):
with test_utils.Database(self.server) as (connection, database_name):
cursor = connection.cursor()
cursor.execute("DROP ROLE testpgadmin")
connection.commit()
