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 tearDown(self):
connection = utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
utils.drop_database(connection, self.db_name)
def before(self):
if self.server['default_binary_paths'] is None:
self.skipTest(
"default_binary_paths is not set for the server {0}".format(
self.server['name']))
if '<' in self.table_name and os.name == 'nt':
self.skipTest("HTML tags '<' and '>' in object name does not "
"work for windows so skipping the test case")
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'])
self.table_name = self.table_name + str(random.randint(100, 1000))
self.database_name = \
self.database_name + str(random.randint(100, 1000))
test_utils.drop_database(connection, self.database_name)
test_utils.create_database(self.server, self.database_name)
test_utils.create_table(self.server, self.database_name,
self.table_name)
test_gui_helper.close_bgprocess_popup(self)
self.page.add_server(self.server)
self.wait = WebDriverWait(self.page.driver, 20)
def before(self):
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']
)
self.timezone = int(test_utils.get_timezone_without_dst(connection))
if abs(self.timezone) % 3600 > 0:
hh_mm = '%H:%M'
else:
hh_mm = '%H'
self.timezone_hh_mm = time.strftime(
hh_mm, time.gmtime(abs(self.timezone)))
if self.timezone < 0:
self.timezone_hh_mm = '-{}'.format(self.timezone_hh_mm)
else:
self.timezone_hh_mm = '+{}'.format(self.timezone_hh_mm)
test_utils.drop_database(connection, "acceptance_test_db")
test_utils.create_database(self.server, "acceptance_test_db")
self.database_version = connection.server_version
# For this test case we need to set "Insert bracket pairs?"
# SQL Editor preference to 'false' to avoid codemirror
# to add matching closing bracket by it self.
self._update_preferences()
def before(self):
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'])
self.timezone = int(test_utils.get_timezone_without_dst(connection))
if abs(self.timezone) % 3600 > 0:
hh_mm = '%H:%M'
else:
hh_mm = '%H'
self.timezone_hh_mm = time.strftime(hh_mm,
time.gmtime(abs(self.timezone)))
if self.timezone < 0:
self.timezone_hh_mm = '-{}'.format(self.timezone_hh_mm)
else:
self.timezone_hh_mm = '+{}'.format(self.timezone_hh_mm)
test_utils.drop_database(connection, "acceptance_test_db")
test_utils.create_database(self.server, "acceptance_test_db")
self.database_version = connection.server_version
# For this test case we need to set "Insert bracket pairs?"
# SQL Editor preference to 'false' to avoid codemirror
# to add matching closing bracket by it self.
self._update_preferences()
def before(self):
if self.server['default_binary_paths'] is None:
self.skipTest(
"default_binary_paths is not set for the server {0}".format(
self.server['name']
)
)
if '<' in self.database_name and os.name == 'nt':
self.skipTest(
"HTML tags '<' and '>' in object name does not "
"work for windows so skipping the test case"
)
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, self.database_name)
self._update_preferences()
db_id = test_utils.create_database(self.server, self.database_name)
if not db_id:
self.assertTrue(False, "Database {} is not "
"created".format(self.database_name))
test_gui_helper.close_bgprocess_popup(self)
self.page.add_server(self.server)
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(
"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 tearDown(self):
"""This function drop the added database"""
connection = utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
utils.drop_database(connection, self.db_name)
def tearDown(self):
main_conn = 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(main_conn, self.encode_db_name)
def after(self):
self.page.remove_server(self.server)
connection = test_utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
test_utils.drop_database(connection, "acceptance_test_db")
def before(self):
connection = test_utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
test_utils.drop_database(connection, "acceptance_test_db")
test_utils.create_database(self.server, "acceptance_test_db")
def tearDown(self):
"""This function drop the added database"""
connection = utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'],
self.server['sslmode'])
utils.drop_database(connection, self.db_name)
def tearDown(self):
main_conn = 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(main_conn, self.encode_db_name)
def tearDown(self):
connection = utils.get_db_connection(
self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'],
self.server['sslmode']
)
utils.drop_database(connection, self.params['database'])
def after(self):
test_gui_helper.close_bgprocess_popup(self)
self.page.remove_server(self.server)
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, self.database_name)
def after(self):
self.page.close_query_tool()
self.page.remove_server(self.server)
connection = test_utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
test_utils.drop_database(connection, "acceptance_test_db")
def tearDown(self):
"""
This function delete the database from server added in SQLite.
"""
connection = utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
utils.drop_database(connection, self.db_name)
def tearDown(self):
"""
This function delete the database from server added in SQLite.
"""
connection = utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
utils.drop_database(connection, self.db_name)
def after(self):
test_gui_helper.close_bgprocess_popup(self)
self.page.remove_server(self.server)
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, self.database_name)
def before(self):
connection = test_utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
test_utils.drop_database(connection, "acceptance_test_db")
test_utils.create_database(self.server, "acceptance_test_db")
self.page.wait_for_spinner_to_disappear()
self._connects_to_server()
self._locate_database_tree_node()
self.page.open_query_tool()
def after(self):
try:
self.page.remove_server(self.server)
except Exception:
print("PGUtilitiesBackupFeatureTest - "
"Exception occurred in after method")
finally:
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, self.database_name)
def before(self):
connection = test_utils.get_db_connection(
self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port']
)
test_utils.drop_database(connection, "acceptance_test_db")
test_utils.create_database(self.server, "acceptance_test_db")
test_utils.create_table(
self.server, "acceptance_test_db", "test_table")
self.page.add_server(self.server)
def before(self):
connection = test_utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
test_utils.drop_database(connection, "acceptance_test_db")
test_utils.create_database(self.server, "acceptance_test_db")
self.page.add_server(self.server)
self.wait = WebDriverWait(self.page.driver, 10)
self.XSS_FILE = '/tmp/<img src=x onmouseover=alert("1")>.sql'
# Remove any previous file
if os.path.isfile(self.XSS_FILE):
os.remove(self.XSS_FILE)
def before(self):
connection = test_utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
test_utils.drop_database(connection, "acceptance_test_db")
test_utils.create_database(self.server, "acceptance_test_db")
test_utils.create_table(self.server, "acceptance_test_db", "<h1>X")
# This is needed to test dependents tab (eg: BackGrid)
test_utils.create_constraint(self.server, "acceptance_test_db",
"<h1>X", "unique",
"<h1 onmouseover='console.log(2);'>Y")
def after(self):
try:
test_gui_helper.close_bgprocess_popup(self)
test_utils.delete_table(self.server, self.database_name,
self.table_name)
self.page.remove_server(self.server)
except Exception:
print("PGUtilitiesMaintenanceFeatureTest - "
"Exception occurred in after method")
finally:
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, self.database_name)
def before(self):
connection = test_utils.get_db_connection(
self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port']
)
test_utils.drop_database(connection, "acceptance_test_db")
test_utils.create_database(self.server, "acceptance_test_db")
self.page.add_server(self.server)
self.wait = WebDriverWait(self.page.driver, 10)
self.XSS_FILE = '/tmp/<img src=x onmouseover=alert("1")>.sql'
# Remove any previous file
if os.path.isfile(self.XSS_FILE):
os.remove(self.XSS_FILE)
def before(self):
if self.server['default_binary_paths'] is None:
self.skipTest(
"default_binary_paths is not set for the server {0}".format(
self.server['name']))
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, "pg_utility_test_db")
test_utils.create_database(self.server, "pg_utility_test_db")
self.page.add_server(self.server)
self.wait = WebDriverWait(self.page.driver, 20)
def before(self):
if self.server['default_binary_paths'] is None:
self.skipTest(
"default_binary_paths is not set for the server {0}".format(
self.server['name']))
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, self.database_name)
test_utils.create_database(self.server, self.database_name)
test_utils.create_table(self.server, self.database_name,
self.table_name)
self.page.add_server(self.server)
self.wait = WebDriverWait(self.page.driver, 20)
test_gui_helper.close_bgprocess_popup(self)
def before(self):
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")
test_utils.create_table(
self.server, "acceptance_test_db", "<h1>X"
)
# This is needed to test dependents tab (eg: BackGrid)
test_utils.create_constraint(
self.server, "acceptance_test_db",
"<h1>X",
"unique", "<h1 onmouseover='console.log(2);'>Y"
)
def before(self):
if self.server['default_binary_paths'] is None:
self.skipTest(
"default_binary_paths is not set for the server {0}".format(
self.server['name']
)
)
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, self.database_name)
test_utils.create_database(self.server, self.database_name)
test_utils.create_table(self.server, self.database_name,
self.table_name)
self.page.add_server(self.server)
self.wait = WebDriverWait(self.page.driver, 20)
# Create test database with random number to avoid conflict in
# parallel execution on different platforms. This database will be
# used across all feature tests.
test_db_name = "acceptance_test_db" + \
str(random.randint(10000, 65535))
connection = test_utils.get_db_connection(
server['db'], server['username'], server['db_password'],
server['host'], server['port'], server['sslmode'])
# Add the server version in server information
server_information['server_version'] = connection.server_version
server_information['type'] = server['type']
# Drop the database if already exists.
test_utils.drop_database(connection, test_db_name)
# Create database
test_utils.create_database(server, test_db_name)
# Configure preferences for the test cases
test_utils.configure_preferences(
default_binary_path=server['default_binary_paths'])
suite = get_suite(test_module_list, server, test_client,
server_information, test_db_name)
tests = unittest.TextTestRunner(stream=sys.stderr,
descriptions=True,
verbosity=2).run(suite)
ran_tests, failed_cases, skipped_cases, passed_cases = \
get_tests_result(tests)
test_result[server['name']] = [
def execute_test(test_module_list_passed, server_passed, driver_passed):
"""
Function executes actually test
:param test_module_list_passed:
:param server_passed:
:param driver_passed:
:return:
"""
try:
print("\n=============Running the test cases for '%s' ============="
% server_passed['name'], file=sys.stderr)
# Create test server
server_information = \
test_utils.create_parent_server_node(server_passed)
# Create test database with random number to avoid conflict in
# parallel execution on different platforms. This database will be
# used across all feature tests.
test_db_name = "acceptance_test_db" + \
str(random.randint(10000, 65535))
connection = test_utils.get_db_connection(
server_passed['db'],
server_passed['username'],
server_passed['db_password'],
server_passed['host'],
server_passed['port'],
server_passed['sslmode']
)
# Add the server version in server information
server_information['server_version'] = connection.server_version
server_information['type'] = server_passed['type']
# Drop the database if already exists.
test_utils.drop_database(connection, test_db_name)
# Create database
test_utils.create_database(server_passed, test_db_name)
# Configure preferences for the test cases
test_utils.configure_preferences(
default_binary_path=server_passed['default_binary_paths'])
# Get unit test suit
suite = get_suite(test_module_list_passed,
server_passed,
test_client,
server_information, test_db_name, driver_passed)
# Run unit test suit created
tests = unittest.TextTestRunner(stream=sys.stderr,
descriptions=True,
verbosity=2).run(suite)
# processing results
ran_tests, failed_cases, skipped_cases, passed_cases = \
get_tests_result(tests)
# This is required when some tests are running parallel
# & some sequential in case of parallel ui tests
if threading.current_thread().getName() == "sequential_tests":
try:
if test_result[server_passed['name']][0] is not None:
ran_tests = test_result[server_passed['name']][0] + \
ran_tests
failed_cases.update(test_result[server_passed['name']][1])
skipped_cases.update(test_result[server_passed['name']][2])
passed_cases.update(test_result[server_passed['name']][3])
test_result[server_passed['name']] = [ran_tests, failed_cases,
skipped_cases,
passed_cases]
except KeyError:
pass
# Add final results server wise in test_result dict
test_result[server_passed['name']] = [ran_tests, failed_cases,
skipped_cases, passed_cases]
# Set empty list for 'passed' parameter for each testRun.
# So that it will not append same test case name
# unittest.result.TestResult.passed = []
# Drop the testing database created initially
if connection:
test_utils.drop_database(connection, test_db_name)
connection.close()
# Delete test server
# test_utils.delete_test_server(test_client)
test_utils.delete_server(test_client, server_information)
except Exception as exc:
traceback.print_exc(file=sys.stderr)
print(str(exc))
print("Exception in {0} {1}".format(
threading.current_thread().ident,
threading.currentThread().getName()))
finally:
# Delete web-driver instance
thread_name = "parallel_tests" + server_passed['name']
if threading.currentThread().getName() == thread_name:
test_utils.quit_webdriver(driver_passed)
time.sleep(20)
# Print info about completed tests
print(
"\n=============Completed the test cases for '%s'============="
% server_passed['name'], file=sys.stderr)
# Create test database with random number to avoid conflict in
# parallel execution on different platforms. This database will be
# used across all feature tests.
test_db_name = "acceptance_test_db" + \
str(random.randint(10000, 65535))
connection = test_utils.get_db_connection(
server['db'],
server['username'],
server['db_password'],
server['host'],
server['port'],
server['sslmode']
)
# Drop the database if already exists.
test_utils.drop_database(connection, test_db_name)
# Create database
test_utils.create_database(server, test_db_name)
if server['default_binary_paths'] is not None:
test_utils.set_preference(server['default_binary_paths'])
suite = get_suite(test_module_list,
server,
test_client,
server_information, test_db_name)
tests = unit_test.TextTestRunner(stream=sys.stderr,
descriptions=True,
verbosity=2).run(suite)
ran_tests, failed_cases, skipped_cases, passed_cases = \
