File size: 7,269 Bytes
ae01f49 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 | #############################################################
#
# pgAdmin 4 - PostgreSQL Tools
#
# Copyright (C) 2013 - 2024, The pgAdmin Development Team
# This software is released under the PostgreSQL Licence
#
##############################################################
import sys
import traceback
from abc import ABCMeta, abstractmethod
from importlib import import_module
from werkzeug.utils import find_modules
from pgadmin.utils import server_utils
from pgadmin.utils.constants import PSYCOPG3
from .. import socketio
import unittest
import config
class TestsGeneratorRegistry(ABCMeta):
"""
class TestsGeneratorRegistry()
Every module will be registered automatically by its module name.
Class-level Methods:
----------- -------
* __init__(...)
- This is used to register test modules. You don't need to
call this function explicitly. This will be automatically executed,
whenever we create a class and inherit from BaseTestGenerator -
it will register it as an available module in TestsGeneratorRegistry.
By setting the __metaclass__ for BaseTestGenerator to
TestsGeneratorRegistry it will create new instance of this
TestsGeneratorRegistry per class.
* load_generators():
- This function will load all the modules from __init__()
present in registry.
"""
registry = dict()
def __init__(self, name, bases, d):
# Register this type of module, based on the module name
# Avoid registering the BaseDriver itself
if name != 'BaseTestGenerator' and name != 'BaseFeatureTest':
# Store/append test classes in 'registry' if test modules has
# multiple classes
if d['__module__'] in TestsGeneratorRegistry.registry:
TestsGeneratorRegistry.registry[d['__module__']].append(self)
else:
TestsGeneratorRegistry.registry[d['__module__']] = [self]
ABCMeta.__init__(self, name, bases, d)
@classmethod
def load_generators(cls, pkg_args, pkg_root, exclude_pkgs, for_modules=[],
is_resql_only=False):
cls.registry = dict()
all_modules = []
try:
for module_name in find_modules(pkg_root, False, True):
all_modules.append(module_name)
except Exception:
pass
if 'resql' not in exclude_pkgs:
# Append reverse engineered test case module
all_modules.append('regression.re_sql.tests.test_resql')
if (pkg_args is None or pkg_args == "all") and \
'feature_tests' not in exclude_pkgs:
# Append feature tests module
all_modules += find_modules(
'regression.feature_tests', False, True)
# If specific modules are to be tested, exclude others
# for modules are handled differently for resql
if not is_resql_only and len(for_modules) > 0:
all_modules = [module_name
for module_name in all_modules
for fmod in for_modules
if module_name.endswith(fmod)]
# Set the module list and exclude packages in the BaseTestGenerator
# for Reverse Engineer SQL test cases.
BaseTestGenerator.setReSQLModuleList(all_modules)
BaseTestGenerator.setExcludePkgs(exclude_pkgs)
# Check if only reverse engineered sql test cases to run
# if yes then import only that module
if is_resql_only:
BaseTestGenerator.setForModules(for_modules)
# In case of RESQL only clear the registry of modules, as
# RESQL test cases should be run.
cls.registry = dict()
try:
import_module('regression.re_sql.tests.test_resql')
except ImportError:
traceback.print_exc(file=sys.stderr)
else:
# Check for SERVER mode
TestsGeneratorRegistry._exclude_packages(all_modules,
exclude_pkgs)
@staticmethod
def _exclude_packages(all_modules, exclude_pkgs):
"""
This function check for server mode test cases.
:param all_modules: all modules.
:param exclude_pkgs: exclude package list.
"""
for module_name in all_modules:
try:
if "tests." in str(module_name) and not any(
str(module_name).startswith(
'pgadmin.' + str(exclude_pkg)
) for exclude_pkg in exclude_pkgs
):
import_module(module_name)
except ImportError:
traceback.print_exc(file=sys.stderr)
class BaseTestGenerator(unittest.TestCase, metaclass=TestsGeneratorRegistry):
# Defining abstract method which will override by individual testcase.
def setUp(self):
super().setUp()
self.server_id = self.server_information["server_id"]
server_con = server_utils.connect_server(self, self.server_id)
if hasattr(self, 'skip_on_database') and \
'data' in server_con and 'type' in server_con['data'] and \
server_con['data']['type'] in self.skip_on_database:
self.skipTest('cannot run in: %s' % server_con['data']['type'])
if hasattr(self, 'mock_data') and 'function_name' in self.mock_data:
self.mock_data['function_name'] =\
self.mock_data['function_name'].replace(
PSYCOPG3, config.PG_DEFAULT_DRIVER)
def setTestServer(self, server):
self.server = server
@abstractmethod
def runTest(self):
pass
# Initializing app.
def setApp(self, app):
self.app = app
# Initializing test_client.
@classmethod
def setTestClient(cls, test_client):
cls.tester = test_client
def setDriver(self, driver):
self.driver = driver
def setParallelUI_tests(self, parallel_ui_tests):
self.parallel_ui_tests = parallel_ui_tests
def setServerInformation(self, server_information):
self.server_information = server_information
def setTestDatabaseName(self, database_name):
self.test_db = database_name
@classmethod
def setReSQLModuleList(cls, module_list):
cls.re_sql_module_list = module_list
@classmethod
def setExcludePkgs(cls, exclude_pkgs):
cls.exclude_pkgs = exclude_pkgs
@classmethod
def setForModules(cls, for_modules):
cls.for_modules = for_modules
class BaseSocketTestGenerator(BaseTestGenerator):
SOCKET_NAMESPACE = ""
def setUp(self):
super().setUp()
self.tester.get("/")
self.socket_client = socketio.test_client(
self.app, namespace=self.SOCKET_NAMESPACE,
flask_test_client=self.tester)
self.assertTrue(self.socket_client.is_connected(self.SOCKET_NAMESPACE))
def runTest(self):
super().runTest()
def tearDown(self):
super().tearDown()
self.socket_client.disconnect(namespace=self.SOCKET_NAMESPACE)
self.assertFalse(
self.socket_client.is_connected(self.SOCKET_NAMESPACE))
|