pytest-exasol-extension 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

exasol/pytest_extension/__init__.py

@@ -1,54 +1,15 @@
 from __future__ import annotations
 from typing import Any, Callable
-import json
 import random
 import string
+from urllib.parse import urlparse
 import pyexasol
 import pytest
 
 from exasol.pytest_backend import BACKEND_ONPREM, BACKEND_SAAS
-
-
-def _to_json_str(bucketfs_params: dict[str, Any], selected: list[str]) -> str:
-    filtered_kwargs = {k: v for k, v in bucketfs_params.items()
-                       if (k in selected) and (v is not None)}
-    return json.dumps(filtered_kwargs)
-
-
-def _create_bucketfs_connection(pyexasol_connection: pyexasol.ExaConnection,
-                                conn_name: str,
-                                conn_to: str,
-                                conn_user: str,
-                                conn_password: str) -> None:
-
-    query = (f"CREATE OR REPLACE  CONNECTION {conn_name} "
-             f"TO '{conn_to}' "
-             f"USER '{conn_user}' "
-             f"IDENTIFIED BY '{conn_password}'")
-    pyexasol_connection.execute(query)
-
-
-def _create_bucketfs_connection_onprem(pyexasol_connection: pyexasol.ExaConnection,
-                                       conn_name: str,
-                                       bucketfs_params: dict[str, Any]) -> None:
-    conn_to = _to_json_str(bucketfs_params, [
-        'backend', 'url', 'service_name', 'bucket_name', 'path', 'verify'])
-    conn_user = _to_json_str(bucketfs_params, ['username'])
-    conn_password = _to_json_str(bucketfs_params, ['password'])
-
-    _create_bucketfs_connection(pyexasol_connection, conn_name,
-                                conn_to, conn_user, conn_password)
-
-
-def _create_bucketfs_connection_saas(pyexasol_connection: pyexasol.ExaConnection,
-                                     conn_name: str,
-                                     bucketfs_params: dict[str, Any]) -> None:
-    conn_to = _to_json_str(bucketfs_params, ['backend', 'url', 'path'])
-    conn_user = _to_json_str(bucketfs_params, ['account_id', 'database_id'])
-    conn_password = _to_json_str(bucketfs_params, ['pat'])
-
-    _create_bucketfs_connection(pyexasol_connection, conn_name,
-                                conn_to, conn_user, conn_password)
+from exasol.python_extension_common.cli.std_options import StdParams
+from exasol.python_extension_common.connections.bucketfs_location import (
+    create_bucketfs_conn_object_onprem, create_bucketfs_conn_object_saas)
 
 
 @pytest.fixture(scope="session")
@@ -105,10 +66,130 @@ def bucketfs_connection_factory(backend,
         else:
             bucketfs_params = backend_aware_bucketfs_params
         if backend == BACKEND_ONPREM:
-            _create_bucketfs_connection_onprem(pyexasol_connection, conn_name, bucketfs_params)
+            create_bucketfs_conn_object_onprem(pyexasol_connection, conn_name, bucketfs_params)
         elif backend == BACKEND_SAAS:
-            _create_bucketfs_connection_saas(pyexasol_connection, conn_name, bucketfs_params)
+            create_bucketfs_conn_object_saas(pyexasol_connection, conn_name, bucketfs_params)
         else:
             raise ValueError(f'Unsupported backend {backend}')
 
     return func
+
+
+@pytest.fixture(scope="session")
+def onprem_database_std_params(use_onprem,
+                               backend_aware_onprem_database,
+                               exasol_config) -> dict[str, Any]:
+    if use_onprem:
+        return {
+            StdParams.dsn.name: f'{exasol_config.host}:{exasol_config.port}',
+            StdParams.db_user.name: exasol_config.username,
+            StdParams.db_password.name: exasol_config.password,
+            StdParams.use_ssl_cert_validation.name: False
+        }
+    return {}
+
+
+@pytest.fixture(scope="session")
+def onprem_bucketfs_std_params(use_onprem,
+                               backend_aware_onprem_database,
+                               bucketfs_config) -> dict[str, Any]:
+    if use_onprem:
+        parsed_url = urlparse(bucketfs_config.url)
+        host, port = parsed_url.netloc.split(":")
+        return {
+            StdParams.bucketfs_host.name: host,
+            StdParams.bucketfs_port.name: port,
+            StdParams.bucketfs_use_https.name: parsed_url.scheme.lower() == 'https',
+            StdParams.bucketfs_user.name: bucketfs_config.username,
+            StdParams.bucketfs_password.name: bucketfs_config.password,
+            StdParams.bucketfs_name.name: 'bfsdefault',
+            StdParams.bucket.name: 'default',
+            StdParams.use_ssl_cert_validation.name: False
+        }
+    return {}
+
+
+@pytest.fixture(scope="session")
+def saas_std_params(use_saas,
+                    saas_host,
+                    saas_pat,
+                    saas_account_id,
+                    backend_aware_saas_database_id) -> dict[str, Any]:
+    if use_saas:
+        return {
+            StdParams.saas_url.name: saas_host,
+            StdParams.saas_account_id.name: saas_account_id,
+            StdParams.saas_database_id.name: backend_aware_saas_database_id,
+            StdParams.saas_token.name: saas_pat
+        }
+    return {}
+
+
+@pytest.fixture(scope="session")
+def database_std_params(backend,
+                        onprem_database_std_params,
+                        saas_std_params) -> dict[str, Any]:
+    """
+    This is a collection of StdParams parameters required to open a
+    database connection for either DockerDB or SaaS test database.
+    """
+    if backend == BACKEND_ONPREM:
+        return onprem_database_std_params
+    elif backend == BACKEND_SAAS:
+        return saas_std_params
+    else:
+        ValueError(f'Unknown backend {backend}')
+
+
+@pytest.fixture(scope="session")
+def bucketfs_std_params(backend,
+                        onprem_bucketfs_std_params,
+                        saas_std_params) -> dict[str, Any]:
+    """
+    This is a collection of StdParams parameters required to connect
+    to the BucketFS on either DockerDB or SaaS test database.
+    """
+    if backend == BACKEND_ONPREM:
+        return onprem_bucketfs_std_params
+    elif backend == BACKEND_SAAS:
+        return saas_std_params
+    else:
+        ValueError(f'Unknown backend {backend}')
+
+
+def _cli_params_to_args(cli_params) -> str:
+    def arg_string(k: str, v: Any):
+        # This should have been implemented as a method of StdParams.
+        k = k.replace("_", "-")
+        if isinstance(v, bool):
+            return f'--{k}' if v else f'--no-{k}'
+        return f'--{k} "{v}"'
+
+    return ' '.join(arg_string(k, v) for k, v in cli_params.items())
+
+
+@pytest.fixture(scope='session')
+def database_cli_args(database_std_params) -> str:
+    """
+    CLI argument string for testing a command that involves connecting to the database.
+    """
+    return _cli_params_to_args(database_std_params)
+
+
+@pytest.fixture(scope='session')
+def bucketfs_cli_args(bucketfs_std_params) -> str:
+    """
+    CLI argument string for testing a command that involves connecting to the BucketFS .
+    """
+    return _cli_params_to_args(bucketfs_std_params)
+
+
+@pytest.fixture(scope='session')
+def cli_args(database_std_params, bucketfs_std_params):
+    """
+    CLI argument string for testing a command that involves connecting to both
+    the database and the BucketFS.
+    """
+    std_params = dict(database_std_params)
+    std_params.update(bucketfs_std_params)
+    return _cli_params_to_args(std_params)

exasol/pytest_extension/version.py

@@ -5,6 +5,6 @@
 # Do not edit this file manually!
 # If you need to change the version, do so in the project.toml, e.g. by using `poetry version X.Y.Z`.
 MAJOR = 0
-MINOR = 1
-PATCH = 0
+MINOR = 2
+PATCH = 1
 VERSION = f"{MAJOR}.{MINOR}.{PATCH}"

pytest_exasol_extension-0.2.1.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.1
+Name: pytest-exasol-extension
+Version: 0.2.1
+Summary: 
+Author: Mikhail Beck
+Author-email: mikhail.beck@exasol.com
+Requires-Python: >=3.10,<4
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: exasol-python-extension-common (>=0.7.0,<1)
+Requires-Dist: pyexasol (>=0.26.0,<1)
+Requires-Dist: pytest (>=7,<9)
+Requires-Dist: pytest-exasol-backend (>=0.2.0)
+Description-Content-Type: text/markdown
+
+# pytest-exasol-extension Plugin
+
+The `pytest-exasol-extension` plugin provides pytest fixtures for preparing a database for the extension tests.
+The fixtures are backend agnostic. They run for the selected backends
+(see the documentation for the `pytest-exasol-backend` plugin).
+
+## Installation
+
+The pytest-exasol-extension plugin can be installed using pip:
+
+```shell
+pip install pytest-exasol-extension
+```
+
+## Usage in Tests
+
+Below is an example of a test that requires a database connection with an open test schema.
+
+```python
+import pytest
+
+@pytest.fixture(scope="session")
+def db_schema_name() -> str:
+    """Let's override a randomly generated db schema for the test, giving it a meaningful name."""
+    return 'MY_TEST_SCHEMA'
+
+def test_something(pyexasol_connection):
+    ...
+```
+
+Next, is an example of a test that needs to store a bucket-fs connection object in the database.
+
+```python
+def test_something_else(bucketfs_connection_factory):
+    bucketfs_connection_factory('my_connection_name,' 'some_path/in_the_bucket')
+    ...
+```
+
+The following fixtures are used to test various deployment scenarios where the connection parameters
+for the Database and the BucketFS are supplied in a command line. The first two fixtures provide dictionaries
+of standard cli parameters (`StdParams`) defined in the `exasol-python-extension-common`.
+
+    `database_std_params` - the Database connection parameters.
+    `bucketfs_std_params` - the BucketFs connection parameters.
+
+The next two fixtures - `database_cli_args` and `bucketfs_cli_args` - give the same parameters as the previous two
+but in the form of command line arguments. They are helpful for testing the CLI directly, for example using the
+click.CliRunner as in the samples below. There is also a fixture - `cli_args` - that combines these two argument
+strings.
+
+```python
+import click
+from click.testing import CliRunner
+from exasol.python_extension_common.cli.std_options import (StdParams, StdTags, select_std_options)
+from exasol.pytest_backend import (BACKEND_ONPREM, BACKEND_SAAS)
+
+def test_db_connection_cli(backend, database_cli_args):
+    if backend == BACKEND_ONPREM:
+        tags = StdTags.DB | StdTags.ONPREM
+    elif backend == BACKEND_SAAS:
+        tags = StdTags.DB | StdTags.SAAS
+    else:
+        ValueError(f'Unknown backend {backend}')
+
+    def test_something_with_db(**kwargs):
+        pass
+
+    opts = select_std_options(tags)
+    cmd = click.Command('whatever', params=opts, callback=test_something_with_db)
+    runner = CliRunner()
+    runner.invoke(cmd, args=database_cli_args, catch_exceptions=False, standalone_mode=False)
+
+def test_bucketfs_connection_cli(backend, bucketfs_cli_args):
+    if backend == BACKEND_ONPREM:
+        tags = StdTags.BFS | StdTags.ONPREM
+    elif backend == BACKEND_SAAS:
+        tags = StdTags.BFS | StdTags.SAAS
+    else:
+        ValueError(f'Unknown backend {backend}')
+
+    def test_something_with_bucketfs(**kwargs):
+        pass
+
+    opts = select_std_options(tags)
+    cmd = click.Command('whatever', params=opts, callback=test_something_with_bucketfs)
+    runner = CliRunner()
+    runner.invoke(cmd, args=bucketfs_cli_args, catch_exceptions=False, standalone_mode=False)
+```
+
+Note, that by default the tests will run twice - once for each backend.
+

pytest_exasol_extension-0.2.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+exasol/pytest_extension/__init__.py,sha256=ZBm0ym9pg8dAukT9xXE--bD2km_FQJWfFd0noOMKXgw,7196
+exasol/pytest_extension/version.py,sha256=XK25Ues5rzeUJrL8LCfXPzxcB5WKUS9Za-GhQ645dUU,404
+pytest_exasol_extension-0.2.1.dist-info/METADATA,sha256=6gu4gKa0zexn25SHHXDDvHqQ9asyO8Ryx3zzz4w86Nc,3856
+pytest_exasol_extension-0.2.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+pytest_exasol_extension-0.2.1.dist-info/entry_points.txt,sha256=7OAFswb2haZ4in-vuf3tRBHb0GAZSZZ2BJn-DStsfys,40
+pytest_exasol_extension-0.2.1.dist-info/RECORD,,

pytest_exasol_extension-0.1.0.dist-info/METADATA

@@ -1,56 +0,0 @@
-Metadata-Version: 2.1
-Name: pytest-exasol-extension
-Version: 0.1.0
-Summary: 
-Author: Mikhail Beck
-Author-email: mikhail.beck@exasol.com
-Requires-Python: >=3.10,<4
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: pyexasol (>=0.26.0,<1)
-Requires-Dist: pytest (>=7,<9)
-Requires-Dist: pytest-exasol-backend (>=0.2.0)
-Description-Content-Type: text/markdown
-
-# pytest-exasol-extension Plugin
-
-The `pytest-exasol-extension` plugin provides pytest fixtures for preparing a database for the extension tests.
-The fixtures are backend agnostic. They run for the selected backends
-(see the documentation for the `pytest-exasol-backend` plugin).
-
-## Installation
-
-The pytest-exasol-extension plugin can be installed using pip:
-
-```shell
-pip install pytest-exasol-extension
-```
-
-## Usage in Tests
-
-Below is an example of a test that requires a database connection with an open test schema.
-
-```python
-import pytest
-
-@pytest.fixture(scope="session")
-def db_schema_name() -> str:
-    """Let's override a randomly generated db schema for the test, giving it a meaningful name."""
-    return 'MY_TEST_SCHEMA'
-
-def test_something(pyexasol_connection):
-    ...
-```
-
-Next, is an example of a test that needs to store a bucket-fs connection object in the database.
-
-```python
-def test_something_else(bucketfs_connection_factory):
-    bucketfs_connection_factory('my_connection_name,' 'some_path/in_the_bucket')
-    ...
-```
-
-Note, that by default the tests will run twice - once for each backend.
-

pytest_exasol_extension-0.1.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-exasol/pytest_extension/__init__.py,sha256=sJjK3oIx9f1rJuVkl8fWocZPhr3fjekCTNxbGKAY0GM,4698
-exasol/pytest_extension/version.py,sha256=4nqSPlb5zgkyYIODu1QrqRckkyoRUBp7vS7rvymvQ0k,404
-pytest_exasol_extension-0.1.0.dist-info/METADATA,sha256=-yIvImipjQNYBO-bkyfQlkAGi1gVqlra0Qf6BPxm4a0,1643
-pytest_exasol_extension-0.1.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-pytest_exasol_extension-0.1.0.dist-info/entry_points.txt,sha256=7OAFswb2haZ4in-vuf3tRBHb0GAZSZZ2BJn-DStsfys,40
-pytest_exasol_extension-0.1.0.dist-info/RECORD,,