def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.start_page: StartPage = request.getfixturevalue('start_page')
self.registration_page: RegistrationPage = request.getfixturevalue('registration_page')
self.cabinet_page: CabinetPage = request.getfixturevalue('cabinet_page')
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.basepage: BasePage = request.getfixturevalue('base_page')
self.homepage: HomePage = request.getfixturevalue('home_page')
self.segmentpage: SegmentPage = request.getfixturevalue('segment_page')
self.createcompanypage: CreateCompanyPage = request.getfixturevalue('create_company_page')
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.base_page: BasePage = request.getfixturevalue('base_page')
self.main_page: MainPage = request.getfixturevalue('main_page')
self.segment_page: SegmentPage = request.getfixturevalue(
'segment_page')
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.base_page: BasePage = request.getfixturevalue('base_page')
self.login_page: LoginPage = request.getfixturevalue('login_page')
self.reg_page: RegPage = request.getfixturevalue('reg_page')
self.main_page: MainPage = request.getfixturevalue('main_page')
def setup(self, driver, request: FixtureRequest):
self.driver = driver
self.auth_page: AuthPage = request.getfixturevalue('auth_page')
self.company_page: CompanyPage = request.getfixturevalue(
'company_page')
self.segment_page: SegmentPage = request.getfixturevalue(
'segment_page')
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.base_page: BasePage = request.getfixturevalue('base_page')
self.authorization_page: AuthorizationPage = request.getfixturevalue(
'authorization_page')(login="******",
passwd="Barsa2016")
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.base_page: BasePage = request.getfixturevalue('base_page')
self.main_page: MainPage = request.getfixturevalue('main_page')
self.search_page: SearchPage = request.getfixturevalue('search_page')
self.euro_python_events_page: EuroPythonEventsPage = request.getfixturevalue('euro_python_events_page')
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.main_page = request.getfixturevalue('main_page')
self.dashboard = request.getfixturevalue('dashboard_page')
self.campaign = request.getfixturevalue('campaign_page')
self.audience = request.getfixturevalue('audience_page')
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.base_page: BasePage = request.getfixturevalue('base_page')
self.main_page: MainPage = request.getfixturevalue('main_page')
self.account_page: AccountPage = request.getfixturevalue(
'account_page')(email="*****@*****.**", password="******")
def setup(self,driver,config,request:FixtureRequest):
self.driver = driver
self.config = config
self.base_page: BasePage = request.getfixturevalue('base_page')
self.cabinet_page: CabinetPage = request.getfixturevalue('cabinet_page')
self.audience_page : AudiencePage = request.getfixturevalue('audience_page')
self.campaign_page : CampaignPage = request.getfixturevalue('campaign_page')
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.base_page: BasePage = request.getfixturevalue('base_page')
self.modal_login: ModalLogin = request.getfixturevalue('modal_login')
self.main_page: MainPage = request.getfixturevalue('main_page')
self.create_campaign_page: CreateCampaignPage = request.getfixturevalue(
'create_campaign_page')
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.main_page: MainPage = request.getfixturevalue('main_page')
self.cabinet_page: CabinetPage = request.getfixturevalue(
'cabinet_page')
self.campaign_page: CampaignPage = request.getfixturevalue(
'campaign_page')
self.segment_page: SegmentPage = request.getfixturevalue(
'segment_page')
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.base_page: BasePage = request.getfixturevalue('base_page')
self.login_page: LoginPage = request.getfixturevalue('login_page')
self.creator_page: CreatingCampaign = request.getfixturevalue(
'creator_page')
self.newsegment_page: NewSegment = request.getfixturevalue(
'segment_page_new')
self.segment_page: SegmentPage = request.getfixturevalue(
'segment_page_table')
def client(request: FixtureRequest) -> testing.FlaskClient:
if request.config.getoption("-m") == "production":
# Run production tests against the production service.
requests_client = RequestsClient(PROD_SERVER_URL)
yield requests_client
else:
# setup database
db_session = request.getfixturevalue("db_session")
app: Flask = request.getfixturevalue("app")
# create a new app context to clear flask.g after requests finished
with app.app_context():
with app.test_client() as client:
yield client
def get_fixtures(func: Callable, request: FixtureRequest) -> Dict[str, Any]:
"""Load fixtures, needed for the test function."""
sig = signature(func)
return {
name: request.getfixturevalue(name)
for name in sig.parameters if name != "case"
}
def get_schema(
*,
request: FixtureRequest,
name: str,
base_url: Union[Optional[str], NotSet] = None,
method: Optional[Filter] = None,
endpoint: Optional[Filter] = None,
tag: Optional[Filter] = None,
operation_id: Optional[Filter] = None,
app: Any = None,
test_function: GenericTest,
hooks: HookDispatcher,
validate_schema: Union[bool, NotSet] = NOT_SET,
skip_deprecated_operations: Union[bool, NotSet] = NOT_SET,
data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
code_sample_style: CodeSampleStyle,
) -> BaseSchema:
"""Loads a schema from the fixture."""
schema = request.getfixturevalue(name)
if not isinstance(schema, BaseSchema):
raise ValueError(f"The given schema must be an instance of BaseSchema, got: {type(schema)}")
return schema.clone(
base_url=base_url,
method=method,
endpoint=endpoint,
tag=tag,
operation_id=operation_id,
app=app,
test_function=test_function,
hooks=schema.hooks.merge(hooks),
validate_schema=validate_schema,
skip_deprecated_operations=skip_deprecated_operations,
data_generation_methods=data_generation_methods,
code_sample_style=code_sample_style,
)
def postgresql_factory(request: FixtureRequest):
"""Fixture factory for PostgreSQL.
:param FixtureRequest request: fixture request object
:rtype: psycopg2.connection
:returns: postgresql client
"""
config = factories.get_config(request)
proc_fixture = request.getfixturevalue(process_fixture_name)
pg_host = proc_fixture.host
pg_port = proc_fixture.port
pg_user = proc_fixture.user
pg_options = proc_fixture.options
pg_db = db_name or config["dbname"]
with SWHDatabaseJanitor(
pg_user,
pg_host,
pg_port,
pg_db,
proc_fixture.version,
dump_files=dump_files,
no_truncate_tables=no_truncate_tables,
):
connection = psycopg2.connect(
dbname=pg_db,
user=pg_user,
host=pg_host,
port=pg_port,
options=pg_options,
)
yield connection
connection.close()
def get_schema(
*,
request: FixtureRequest,
name: str,
method: Optional[Filter] = None,
endpoint: Optional[Filter] = None,
tag: Optional[Filter] = None,
operation_id: Optional[Filter] = None,
test_function: GenericTest,
hooks: HookDispatcher,
validate_schema: Union[bool, NotSet] = NOT_SET,
skip_deprecated_endpoints: Union[bool, NotSet] = NOT_SET,
data_generation_methods: Union[Iterable[DataGenerationMethod],
NotSet] = NOT_SET,
) -> BaseSchema:
"""Loads a schema from the fixture."""
schema = request.getfixturevalue(name)
if not isinstance(schema, BaseSchema):
raise ValueError(
f"The given schema must be an instance of BaseSchema, got: {type(schema)}"
)
return schema.clone(
method=method,
endpoint=endpoint,
tag=tag,
operation_id=operation_id,
test_function=test_function,
hooks=hooks,
validate_schema=validate_schema,
skip_deprecated_endpoints=skip_deprecated_endpoints,
data_generation_methods=data_generation_methods,
)
def get_schema(
*,
request: FixtureRequest,
name: str,
method: Optional[Filter] = None,
endpoint: Optional[Filter] = None,
tag: Optional[Filter] = None,
operation_id: Optional[Filter] = None,
test_function: GenericTest,
hooks: HookDispatcher,
validate_schema: Union[bool, NotSet] = NOT_SET,
) -> BaseSchema:
"""Loads a schema from the fixture."""
# pylint: disable=too-many-arguments
schema = request.getfixturevalue(name)
if not isinstance(schema, BaseSchema):
raise ValueError(f"The given schema must be an instance of BaseSchema, got: {type(schema)}")
return schema.clone(
method=method,
endpoint=endpoint,
tag=tag,
operation_id=operation_id,
test_function=test_function,
hooks=hooks,
validate_schema=validate_schema,
)
def selenium(request: FixtureRequest) -> webdriver.Remote:
if request.config.getoption('--local-chrome'):
driver = initialize_local_chrome()
request.addfinalizer(lambda: deinitialize_selenium(driver))
return driver
driver = request.getfixturevalue('selenium') # type: webdriver.Remote
yield driver
# https://github.com/SeleniumHQ/docker-selenium/issues/87#issuecomment-286231268
driver.close()
def selenium(request: FixtureRequest) -> webdriver.Remote:
if request.config.getoption('--local-chrome'):
driver = initialize_local_chrome()
request.addfinalizer(lambda: deinitialize_selenium(driver))
return driver
driver = request.getfixturevalue('selenium') # type: webdriver.Remote
yield driver
# https://github.com/SeleniumHQ/docker-selenium/issues/87#issuecomment-286231268
driver.close()
def new_cluster_configuration(self, request: FixtureRequest):
# Overriding the default BaseTest.new_cluster_configuration fixture to set custom configs.
config = ClusterConfig()
for fixture_name in ["openshift_version", "network_type", "is_static_ip"]:
with suppress(FixtureLookupError):
setattr(config, fixture_name, request.getfixturevalue(fixture_name))
return config
def get_schema(
request: FixtureRequest, name: str, method: Optional[Filter] = None, endpoint: Optional[Filter] = None
) -> BaseSchema:
"""Loads a schema from the fixture."""
schema = request.getfixturevalue(name)
if not isinstance(schema, BaseSchema):
raise ValueError(f"The given schema must be an instance of BaseSchema, got: {type(schema)}")
if method is NOT_SET:
method = schema.method
if endpoint is NOT_SET:
endpoint = schema.endpoint
return schema.__class__(schema.raw_schema, method=method, endpoint=endpoint)
def new_cluster_configuration(self, request: FixtureRequest):
# Overriding the default BaseTest.new_cluster_configuration fixture to set custom configs.
config = ClusterConfig()
for fixture_name in ["openshift_version", "network_type", "is_static_ip", "olm_operators"]:
with suppress(FixtureLookupError):
if hasattr(config, fixture_name):
config.set_value(fixture_name, request.getfixturevalue(fixture_name))
else:
raise AttributeError(f"No attribute name {fixture_name} in ClusterConfig object type")
config.trigger(get_default_triggers())
return config
def test_classification(
dataset: str, model: str,
outputs_to_probabilities: Optional[Callable[[Any], np.ndarray]],
sparse_labels: bool, request: FixtureRequest):
"""
Test training dynamic gathering on different classification schemes, multi-class, binary, from logits and sparse
labels
"""
# Retrieve values
dataset = request.getfixturevalue(dataset) # tf.data.Dataset
model = request.getfixturevalue(model) # tf.keras.Model
# Batch dataset
dataset = dataset.batch(10)
# Create callback
datamap = tvl.learning.DataMapCallback(
dataset,
outputs_to_probabilities=outputs_to_probabilities,
sparse_labels=sparse_labels)
# Train
N_EPOCHS = 5
model.fit(dataset, epochs=N_EPOCHS, callbacks=[datamap])
# Assert shape of gathered gold labeles probabilities are (n_samples, n_epochs)
assert datamap.gold_labels_probabilities.shape == (100, N_EPOCHS)
# Assert all probabilities are bound between 0 and 1
assert datamap.gold_labels_probabilities.min() >= 0
assert datamap.gold_labels_probabilities.max() <= 1
# Assert training dynamics shapes
assert datamap.confidence.shape == datamap.variability.shape == datamap.correctness.shape == (
100, )
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.base_page: BasePage = request.getfixturevalue('base_page')
self.login_page: LoginPage = request.getfixturevalue('login_page')
self.auth_problem_page: AuthProblemPage = request.getfixturevalue('auth_problem_page')
self.main_page: MainPage = request.getfixturevalue('main_page')
self.create_company_page: CreateCompanyPage = request.getfixturevalue('create_company_page')
self.segments_page: SegmentsPage = request.getfixturevalue('segments_page')
def postgresql_factory(request: FixtureRequest) -> Iterator[connection]:
"""
Fixture factory for PostgreSQL.
:param request: fixture request object
:returns: postgresql client
"""
check_for_psycopg2()
proc_fixture: Union[PostgreSQLExecutor, NoopExecutor] = request.getfixturevalue(
process_fixture_name
)
pg_host = proc_fixture.host
pg_port = proc_fixture.port
pg_user = proc_fixture.user
pg_password = proc_fixture.password
pg_options = proc_fixture.options
pg_db = dbname or proc_fixture.dbname
pg_load = load or []
assert pg_db is not None
with SWHDatabaseJanitor(
pg_user,
pg_host,
pg_port,
pg_db,
proc_fixture.version,
pg_password,
isolation_level=isolation_level,
dump_files=dump_files,
no_truncate_tables=no_truncate_tables,
no_db_drop=no_db_drop,
) as janitor:
db_connection: connection = psycopg2.connect(
dbname=pg_db,
user=pg_user,
password=pg_password,
host=pg_host,
port=pg_port,
options=pg_options,
)
for load_element in pg_load:
janitor.load(load_element)
try:
yield db_connection
finally:
db_connection.close()
def batch_source(local_staging_path: str, pytestconfig,
request: FixtureRequest):
if pytestconfig.getoption("env") == "gcloud":
bq_project = pytestconfig.getoption("bq_project")
bq_dataset = request.getfixturevalue("bq_dataset")
return BigQuerySource(
event_timestamp_column="event_timestamp",
created_timestamp_column="created_timestamp",
table_ref=
f"{bq_project}:{bq_dataset}.source_{datetime.now():%Y%m%d%H%M%s}",
)
else:
return FileSource(
event_timestamp_column="event_timestamp",
created_timestamp_column="created_timestamp",
file_format=ParquetFormat(),
file_url=os.path.join(local_staging_path, "transactions"),
)
def _push_request_context(request: FixtureRequest):
"""During tests execution request context has been pushed, e.g. `url_for`,
`session`, etc. can be used in tests as is::
def test_app(app, client):
assert client.get(url_for('myview')).status_code == 200
"""
if "app" not in request.fixturenames:
return
app = request.getfixturevalue("app")
ctx = app.test_request_context()
ctx.push()
def teardown():
ctx.pop()
request.addfinalizer(teardown)
def setup(self, driver, config, request: FixtureRequest):
self.driver = driver
self.config = config
self.base_page: BasePage = request.getfixturevalue('base_page')
self.login_page: LoginPage = request.getfixturevalue('login_page')
self.login_error_page: LoginErrorPage = request.getfixturevalue(
'login_error_page'
)
self.main_page: MainPage = request.getfixturevalue('main_page')
self.dashboard_page: DashboardPage = request.getfixturevalue(
'dashboard_page'
)
self.create_campaign_page: CreateCampaignPage = request.getfixturevalue(
'create_campaign_page'
)
self.segment_page: SegmentPage = request.getfixturevalue(
'segment_page'
)
self.create_segment_page: CreateSegmentPage = request.getfixturevalue(
'create_segment_page'
)
def postgresql_factory(request: FixtureRequest) -> connection:
"""
Fixture factory for PostgreSQL.
:param FixtureRequest request: fixture request object
:returns: postgresql client
"""
config = get_config(request)
if not psycopg2:
raise ImportError(
'No module named psycopg2. Please install either '
'psycopg2 or psycopg2-binary package for CPython '
'or psycopg2cffi for Pypy.')
proc_fixture: Union[PostgreSQLExecutor,
NoopExecutor] = request.getfixturevalue(
process_fixture_name)
pg_host = proc_fixture.host
pg_port = proc_fixture.port
pg_user = proc_fixture.user
pg_password = proc_fixture.password
pg_options = proc_fixture.options
pg_db = db_name or config['dbname']
pg_load = load or config['load']
with DatabaseJanitor(pg_user, pg_host, pg_port, pg_db,
proc_fixture.version, pg_password,
isolation_level):
db_connection: connection = psycopg2.connect(dbname=pg_db,
user=pg_user,
password=pg_password,
host=pg_host,
port=pg_port,
options=pg_options)
if pg_load:
for filename in pg_load:
with open(filename, 'r') as _fd:
with db_connection.cursor() as cur:
cur.execute(_fd.read())
yield db_connection
db_connection.close()
