Update release tooling; make test files unique

Author: kesmit13

RELEASE.md

@@ -2,48 +2,49 @@
 
 ## Bump the package version and build documentation
 
-Bump the version number in `setup.cfg` and `singlestoredb/__init__.py` using
-semantic versioning rules: minor bump for new features, patch bump for
-bug fixes. Add release notes to `docs/src/whatsnew.rst`. Run `make html` in
-`docs/src` to generate documentation.
-
-You will need `sphinx` and `sphinx_rtd_theme` installed for this step. You
-also need a SingleStoreDB server running at the given IP and port to run
-samples against.
-
-There is a utility to do this process for you, but you should check the
-`docs/src/whatsnew.rst` to verify the release summary. Use the following
-to run it:
+Run the following command:
 ```
 resources/bump_version.py < major | minor | patch >
 
 ```
 
-## Commit and push the changes
+This will bump the version number in `setup.cfg` and `singlestoredb/__init__.py`
+using semantic versioning rules: minor bump for new features, patch bump for
+bug fixes. It will genarete a list of changes since the last version and
+ask for confirmation of the release notes in `docs/src/whatsnew.rst`.
+It will then run `make html` in `docs/src` to generate documentation.
+You will need `sphinx` and `sphinx_rtd_theme` installed for this step.
+The documentation contains source which runs against a live server that is
+created using Docker.
 
-After verifying the release summary in the documentation, commit the changes:
-```
-# Make sure newly generated docs get added
-git add docs
 
-# Commit changes
-git commit -am "Prepare for vX.X.X release".
+## Commit and push the changes
 
-git push
+After verifying the release summary in the documentation, commit the changes.
+All modified files should be staged by `bump_version.py` already.
+```
+git commit -m "Prepare for vX.X.X release" && git push
 
 ```
 
-## Run smoke tests
+## Final testing
+
+The coverage tests will be triggered by the push, but it will likely only
+be a subset since Management API tests only get executed if the Management API
+source files are changed. You should run the full set of [
+Coverage tests at](https://github.com/singlestore-labs/singlestoredb-python/actions/workflows/coverage.yml)
+and then run the Smoke tests which verify the code works at all of the advertised Python versions:
+[Smoke test](https://github.com/singlestore-labs/singlestoredb-python/actions/workflows/smoke-test.yml).
 
-The coverage tests will be triggered by the push, but you should also run
-[Smoke test](https://github.com/singlestore-labs/singlestoredb-python/actions/workflows/smoke-test.yml)
-workflow manually which does basic tests on all supported versions of Python.
 
 ## Create the release on Github
 
-Once all workflows are clean, create a new Github release with the name
-"SingleStoreDB vX.X.X" at <https://github.com/singlestore-labs/singlestoredb-python/releases>
-and set the generated tag to the matching version
-number. Add the release notes from the `whatsnew.rst` file to the release
-notes. Creating the release will run the [Publish packages](https://github.com/singlestore-labs/singlestoredb-python/actions/workflows/publish.yml)
-workflow which builds the packages and pubsishes them to PyPI.
+To create the release, run:
+```
+resources/create_release.py
+
+```
+
+This will generate a tag and start the release process in the
+[Publish packages](https://github.com/singlestore-labs/singlestoredb-python/actions/workflows/publish.yml)
+Github workflow.

resources/bump_version.py

@@ -424,7 +424,11 @@ def main() -> None:
     print('=' * 50, file=sys.stderr)
     print(f'🎉 Version bump completed successfully in {total_elapsed:.1f}s!', file=sys.stderr)
     print(f'📝 Version: {current_version} → {new_version}', file=sys.stderr)
-    print('📄 Next step: git commit -m "Bump version to {}"'.format(new_version), file=sys.stderr)
+    print('🚀 Next steps:', file=sys.stderr)
+    print('    📄 git commit -m "Prepare for v{} release" && git push'.format(new_version), file=sys.stderr)
+    print('    📄 Run Coverage tests <https://github.com/singlestore-labs/singlestoredb-python/actions/workflows/coverage.yml>', file=sys.stderr)
+    print('    📄 Run Smoke test <https://github.com/singlestore-labs/singlestoredb-python/actions/workflows/smoke-test.yml>', file=sys.stderr)
+    print('    📄 Run resources/create_release.py', file=sys.stderr)
 
 
 if __name__ == '__main__':

singlestoredb/pytest.py

@@ -2,8 +2,10 @@
 """Pytest plugin"""
 import logging
 import os
+import socket
 import subprocess
 import time
+import uuid
 from enum import Enum
 from typing import Iterator
 from typing import Optional
@@ -28,6 +30,14 @@
 TEARDOWN_WAIT_SECONDS = 2
 
 
+def _find_free_port() -> int:
+    """Find a free port by binding to port 0 and getting the assigned port."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(('', 0))
+        s.listen(1)
+        return s.getsockname()[1]
+
+
 class ExecutionMode(Enum):
     SEQUENTIAL = 1
     LEADER = 2
@@ -79,7 +89,11 @@ class _TestContainerManager():
     """Manages the setup and teardown of a SingleStoreDB Dev Container"""
 
     def __init__(self) -> None:
-        self.container_name = 'singlestoredb-test-container'
+        # Generate unique container name using UUID and worker ID
+        worker = os.environ.get('PYTEST_XDIST_WORKER', 'master')
+        unique_id = uuid.uuid4().hex[:8]
+        self.container_name = f'singlestoredb-test-{worker}-{unique_id}'
+
         self.dev_image_name = 'ghcr.io/singlestore-labs/singlestoredb-dev'
 
         assert 'SINGLESTORE_LICENSE' in os.environ, 'SINGLESTORE_LICENSE not set'
@@ -91,14 +105,69 @@ def __init__(self) -> None:
             'SINGLESTORE_SET_GLOBAL_DEFAULT_PARTITIONS_PER_LEAF': '1',
         }
 
-        self.ports = ['3306', '8080', '9000']
+        # Use dynamic port allocation to avoid conflicts
+        self.mysql_port = _find_free_port()
+        self.http_port = _find_free_port()
+        self.studio_port = _find_free_port()
+        self.ports = [
+            (self.mysql_port, '3306'),    # External port -> Internal port
+            (self.http_port, '8080'),
+            (self.studio_port, '9000'),
+        ]
+
+        self.url = f'root:{self.root_password}@127.0.0.1:{self.mysql_port}'
+
+    def _container_exists(self) -> bool:
+        """Check if a container with this name already exists."""
+        try:
+            result = subprocess.run(
+                [
+                    'docker', 'ps', '-a', '--filter',
+                    f'name={self.container_name}',
+                    '--format', '{{.Names}}',
+                ],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            return self.container_name in result.stdout
+        except subprocess.CalledProcessError:
+            return False
+
+    def _cleanup_existing_container(self) -> None:
+        """Stop and remove any existing container with the same name."""
+        if not self._container_exists():
+            return
 
-        self.url = f'root:{self.root_password}@127.0.0.1:3306'
+        logger.info(f'Found existing container {self.container_name}, cleaning up')
+        try:
+            # Try to stop the container (ignore if it's already stopped)
+            subprocess.run(
+                ['docker', 'stop', self.container_name],
+                capture_output=True,
+                check=False,
+            )
+            # Remove the container
+            subprocess.run(
+                ['docker', 'rm', self.container_name],
+                capture_output=True,
+                check=True,
+            )
+            logger.debug(f'Cleaned up existing container {self.container_name}')
+        except subprocess.CalledProcessError as e:
+            logger.warning(f'Failed to cleanup existing container: {e}')
+            # Continue anyway - the unique name should prevent most conflicts
 
     def start(self) -> None:
+        # Clean up any existing container with the same name
+        self._cleanup_existing_container()
+
         command = ' '.join(self._start_command())
 
-        logger.info(f'Starting container {self.container_name}')
+        logger.info(
+            f'Starting container {self.container_name} on ports {self.mysql_port}, '
+            f'{self.http_port}, {self.studio_port}',
+        )
         try:
             license = os.environ['SINGLESTORE_LICENSE']
             env = {
@@ -108,8 +177,8 @@ def start(self) -> None:
         except Exception as e:
             logger.exception(e)
             raise RuntimeError(
-                'Failed to start container. '
-                'Is one already running?',
+                f'Failed to start container {self.container_name}. '
+                f'Command: {command}',
             ) from e
         logger.debug('Container started')
 
@@ -123,9 +192,9 @@ def _start_command(self) -> Iterator[str]:
             else:
                 yield f'{key}={value}'
 
-        for port in self.ports:
+        for external_port, internal_port in self.ports:
             yield '-p'
-            yield f'{port}:{port}'
+            yield f'{external_port}:{internal_port}'
 
         yield self.dev_image_name