chore: cleanup tests (#12)

* Cleaup tests

* Rename dir: e2e_query -> e2e

* Fix precommit

* Unused imports

* Update readme

Author: pitercl

.github/actions/run-tests/action.yml

@@ -34,6 +34,5 @@ runs:
       with:
         report_paths: "${{ inputs.working-directory }}/test-results/test-${{ inputs.report-suffix }}.xml"
         update_check: true
-        include_passed: true
         annotate_notice: true
         job_name: ${{ inputs.report-job }}

.github/scripts/rest.py

@@ -47,24 +47,20 @@ jobs:
 
       - name: Run tests
         env:
-          NEPTUNE_WORKSPACE: ${{ secrets.E2E_WORKSPACE }}
           NEPTUNE_E2E_WORKSPACE: ${{ secrets.E2E_WORKSPACE }}
           NEPTUNE_E2E_PROJECT: ${{ secrets[format('E2E_PROJECT{0}', matrix.env_suffix)] }}
-          NEPTUNE_API_TOKEN: ${{ secrets[format('E2E_API_TOKEN{0}', matrix.env_suffix)] }}
-          PROJECT_DIR: .
-          TESTS_DIR: tests/e2e_query
+          NEPTUNE_E2E_API_TOKEN: ${{ secrets[format('E2E_API_TOKEN{0}', matrix.env_suffix)] }}
           TEST_MARKERS: ${{ matrix.test_markers }}
           NEPTUNE_VERIFY_SSL: ${{ matrix.verify_ssl }}
         run: |
-          pytest --junitxml="test-results/test-e2e.xml" ${TEST_MARKERS:+-m "$TEST_MARKERS"} "$TESTS_DIR"
+          pytest --junitxml="test-results/test-e2e.xml" ${TEST_MARKERS:+-m "$TEST_MARKERS"} tests/e2e
 
       - name: Report
         uses: mikepenz/action-junit-report@v5
         if: always()
         with:
           report_paths: "./test-results/test-e2e*.xml"
           update_check: true
-          include_passed: true
           annotate_notice: true
           job_name: "e2e tests"
 

.github/workflows/tests-e2e.yml

@@ -1,4 +1,3 @@
-poetry.lock
 # Neptune data
 .neptune/
 **/.neptune/
@@ -128,3 +127,5 @@ stream.bin
 
 # mocks
 MagicMock/
+
+poetry.lock

.gitignore

@@ -22,6 +22,7 @@
     Iterable,
     Optional,
     TypeVar,
+    Union,
 )
 
 from neptune_api.client import AuthenticatedClient
@@ -40,7 +41,7 @@
 )
 from .attributes import fetch_attribute_definitions
 
-T = TypeVar("T", covariant=True)
+T = TypeVar("T", bound=Union[filters._Filter, filters._Attribute, None])
 
 
 @dataclass
@@ -84,10 +85,6 @@ class InferenceState(Generic[T]):
     attributes: list[AttributeInferenceState]
     result: T
 
-    @staticmethod
-    def empty() -> "InferenceState[None]":
-        return InferenceState(attributes=[], result=None)
-
     @staticmethod
     def from_attribute(attribute: filters._Attribute) -> "InferenceState[filters._Attribute]":
         attribute_copy = copy.deepcopy(attribute)
@@ -103,7 +100,7 @@ def from_attribute(attribute: filters._Attribute) -> "InferenceState[filters._At
         return InferenceState(attributes=attribute_states, result=attribute_copy)
 
     @staticmethod
-    def from_filter(filter_: filters._Filter) -> "InferenceState[filters._Filter]":
+    def from_filter(filter_: filters._Filter) -> "InferenceState[Optional[filters._Filter]]":
         def _walk_attributes(experiment_filter: filters._Filter) -> Iterable[filters._Attribute]:
             if isinstance(experiment_filter, filters._AttributeValuePredicate):
                 yield experiment_filter.attribute
@@ -169,7 +166,7 @@ def infer_attribute_types_in_filter(
     fetch_attribute_definitions_executor: Executor,
 ) -> InferenceState[Optional[filters._Filter]]:
     if filter_ is None:
-        return InferenceState.empty()
+        return InferenceState(attributes=[], result=None)
 
     state = InferenceState.from_filter(filter_)
     if state.is_complete():

poetry.lock

@@ -1,32 +1,26 @@
-# Important notes
+# Environment variables
 
-## Prepopulated test data
+* `NEPTUNE_E2E_API_TOKEN` - an API TOKEN to use in the e2e tests
+* `NEPTUNE_E2E_WORKSPACE` - a workspace that e2e tests can create projects in
+* `NEPTUNE_E2E_PROJECT` - a project to use for (some of) the e2e tests
+* `NEPTUNE_E2E_REUSE_PROJECT` - see below
+* `NEPTUNE_E2E_VERIFY_SSL` - whether to verify SSL certificates when running the e2e tests;
+   only required if the instance you're running the e2e tests against has an invalid cert
 
-A subset of the tests in the `e2e` directory are end-to-end tests that assume a
-specific data layout in a project.
+## Projects used and created in end-to-end tests
+Each e2e run uses 2 projects. You can control them with environment variables.
 
-This data is populated using the `populate_projects.py` script, which
-has comments explaining the layout.
+- The first project is specified explicitly.\
+If the data required by a test doesn't exist in this project, it's populated during the test run.\
+Example: `NEPTUNE_E2E_PROJECT="neptune/e2e-tests"`
 
-The script *must* be run only **once** on a fresh project to set up the
-necessary data for the tests to run successfully.
 
-The tests that rely on this data are:
+- The second project's name is generated depending on the `NEPTUNE_E2E_REUSE_PROJECT` env.\
+The project is created / expected in the workspace under the `NEPTUNE_E2E_WORKSPACE` env.
 
-* `test_dataframe_values.py`
-* `test_run_filtering.py`
-* `test_run_list.py`
+  - If `NEPTUNE_E2E_REUSE_PROJECT=false` (the default), the project name is .e.g. `pye2e-runs-<datetime>-v1`.\
+  The project is always created and populated with data.
 
-## Environment variables
-
-* `NEPTUNE_API_TOKEN` - API token to use
-* `NEPTUNE_E2E_PROJECT_PREPOPULATED` - project name to use for tests that require a project
-  with fixed data populated by `populate_projects.py` and **do not** populate the
-  project during execution. The test runner script creates a temporary project for
-  that purpose. If not set, `NEPTUNE_PROJECT` is used.
-* `NEPTUNE_E2E_PROJECT` - project name to use for tests that create Runs during
-  execution. This can be an existing project in which it's fine to create multiple
-  Runs with different data. If not set, `NEPTUNE_PROJECT` is used.
-* `NEPTUNE_E2E_CUSTOM_RUN_ID` (optional) - if set, it should be `sys/custom_run_id`
-  of an existing Run. This avoids creating a new Run for tests that log data,
-  if this is for some reason required.
+  - If `NEPTUNE_E2E_REUSE_PROJECT=true`, the project name is `pye2e-runs-<hash>-v1`.\
+  The name contains a hash of the data the tests need in this project.\
+  If the project doesn't exist, it's created and populated.

src/neptune_query/internal/composition/type_inference.py

@@ -18,28 +18,42 @@
     get_config_and_token_urls,
 )
 from neptune_query.internal.composition import concurrency
-from neptune_query.internal.context import set_project
+from neptune_query.internal.context import (
+    set_api_token,
+    set_project,
+)
 from neptune_query.internal.filters import _Filter
 from neptune_query.internal.identifiers import RunIdentifier
 from neptune_query.internal.retrieval.search import fetch_experiment_sys_attrs
-from tests.e2e_query.data import (
+from tests.e2e.data import (
     FILE_SERIES_STEPS,
     NOW,
     PATH,
     TEST_DATA,
 )
 
-API_TOKEN_ENV_NAME: str = "NEPTUNE_API_TOKEN"
-
 
 @dataclass
 class Project:
     project_identifier: str
 
 
 @pytest.fixture(scope="session")
-def client() -> AuthenticatedClient:
-    api_token = os.getenv(API_TOKEN_ENV_NAME)
+def api_token() -> str:
+    api_token = os.getenv("NEPTUNE_E2E_API_TOKEN")
+    if api_token is None:
+        raise RuntimeError("NEPTUNE_E2E_API_TOKEN environment variable is not set")
+    return api_token
+
+
+@pytest.fixture(autouse=True)
+def set_api_token_auto(api_token) -> None:
+    """Set the API token for the session."""
+    set_api_token(api_token)
+
+
+@pytest.fixture(scope="session")
+def client(api_token) -> AuthenticatedClient:
     credentials = Credentials.from_api_key(api_key=api_token)
     config, token_urls = get_config_and_token_urls(credentials=credentials, proxies=None)
     client = create_auth_api_client(
@@ -60,25 +74,15 @@ def executor() -> Executor:
 
 
 @pytest.fixture(scope="module")
-def project(request):
-    # Assume the project name and API token are set in the environment using the standard
-    # NEPTUNE_PROJECT and NEPTUNE_API_TOKEN variables.
-    #
-    # We also allow overriding the project name per module by setting the
-    # module-level `NEPTUNE_PROJECT` variable.
-    project_identifier = getattr(request.module, "NEPTUNE_PROJECT", None)
+def project():
+    project_identifier = os.getenv("NEPTUNE_E2E_PROJECT")
     if project_identifier is None:
-        project_identifier = os.getenv("NEPTUNE_PROJECT")
-        if project_identifier is None:
-            raise ValueError(
-                "Project identifier not provided. Set NEPTUNE_PROJECT environment variable or "
-                "define it in the module using `NEPTUNE_PROJECT = 'your_project_name'`."
-            )
+        raise RuntimeError("NEPTUNE_E2E_PROJECT environment variable is not set")
     return Project(project_identifier=project_identifier)
 
 
 @pytest.fixture(scope="module")
-def run_with_attributes(project, client):
+def run_with_attributes(project, api_token, client):
     runs = {}
     for experiment in TEST_DATA.experiments:
         project_id = project.project_identifier
@@ -94,6 +98,7 @@ def run_with_attributes(project, client):
             continue
 
         run = Run(
+            api_token=api_token,
             project=project_id,
             run_id=experiment.run_id,
             experiment_name=experiment.name,