adding docker image and gh action for tests and docker image

Author: edulix

.github/workflows/test.yml

@@ -41,5 +41,8 @@ jobs:
     - name: Install project
       run: poetry install --no-interaction
 
-    - name: Run tests
-      run: poetry run pytest tests/
+    - name: Run tests (excluding Docker tests)
+      run: poetry run pytest tests/ --ignore=tests/test_docker.py
+
+    - name: Run Docker tests
+      run: poetry run pytest tests/test_docker.py -v

docs/development.md

@@ -0,0 +1,177 @@
+# Development Guide
+
+This guide covers development workflows, testing, Docker image management, and CI/CD for the `release-tool` project.
+
+## Table of Contents
+- [Testing](#testing)
+- [GitHub Actions](#github-actions)
+- [Docker Image & Registry](#docker-image--registry)
+- [Local Development](#local-development)
+
+## Testing
+
+### Running Tests
+
+The project uses pytest for testing. All tests can be run using Poetry:
+
+```bash
+# Run all tests
+poetry run pytest
+
+# Run with verbose output
+poetry run pytest -v
+
+# Run specific test file
+poetry run pytest tests/test_models.py -v
+
+# Run with coverage report
+poetry run pytest --cov=release_tool --cov-report=html
+```
+
+### Test Categories
+
+#### Unit Tests
+Standard unit tests covering:
+- Models and data structures (`test_models.py`)
+- Configuration management (`test_config.py`)
+- Database operations (`test_db.py`)
+- Git operations (`test_git_ops.py`)
+- Policies and business logic (`test_policies.py`)
+- Template rendering (`test_output_template.py`, `test_default_template.py`)
+- Ticket management (`test_query_tickets.py`, `test_partial_tickets.py`)
+- Publishing and syncing (`test_publish.py`, `test_sync.py`)
+
+```bash
+# Run all unit tests except Docker tests
+poetry run pytest tests/ --ignore=tests/test_docker.py
+```
+
+#### Docker Tests
+Docker integration tests verify:
+- Docker image builds successfully from the Dockerfile
+- `release-tool` executable is available in the image
+- `release-tool -h` returns a successful exit code
+- Docker image runs `release-tool` as its default command
+
+```bash
+# Run Docker tests (requires Docker to be running)
+poetry run pytest tests/test_docker.py -v
+```
+
+**Note**: Docker tests take longer (~20-30 seconds) as they build the actual Docker image.
+
+## GitHub Actions
+
+The project uses GitHub Actions for continuous integration and delivery. All workflows are defined in `.github/workflows/`.
+
+### Test Workflow
+
+File: `.github/workflows/test.yml`
+
+**Triggers**:
+- Push to `main` branch
+- Pull requests to `main` branch
+
+**What it does**:
+1. Sets up a test matrix for Python 3.10, 3.11, and 3.12
+2. Installs Poetry and project dependencies
+3. Runs all unit tests (excluding Docker tests)
+4. Runs Docker tests separately
+
+**Running locally with act**:
+
+[act](https://github.com/nektos/act) allows you to test GitHub Actions workflows locally:
+
+```bash
+# Install act (macOS)
+brew install act
+
+# List available workflows
+act -l
+
+# Run the test workflow
+act -j test --container-architecture linux/amd64
+
+# Run with a specific runner image
+act -j test --container-architecture linux/amd64 -P ubuntu-latest=catthehacker/ubuntu:act-latest
+
+# Run and show verbose output
+act -j test --container-architecture linux/amd64 -v
+```
+
+**Note**: On Apple M-series chips, use `--container-architecture linux/amd64` to avoid compatibility issues.
+
+### Docker Publish Workflow
+
+File: `.github/workflows/docker-publish.yml`
+
+**Triggers**:
+- Push to `main` branch → updates `latest` and `main` tags
+- Push of version tags (`v*`) → creates versioned image tags (e.g., `v1.0.0`)
+- Pull requests → builds image for validation only (doesn't push)
+
+**What it does**:
+1. Builds the Docker image from the Dockerfile
+2. Tags the image appropriately based on the trigger
+3. Pushes to GitHub Container Registry (GHCR)
+
+**Testing locally**:
+
+```bash
+# Test the Docker publish workflow locally (builds but doesn't push)
+act -j build-and-push --container-architecture linux/amd64
+```
+
+## Docker Image & Registry
+
+The `release-tool` is available as a Docker image stored in the GitHub Container Registry (GHCR). This allows other tools (like `release-bot`) or CI pipelines to use the tool without installing Python dependencies manually.
+
+## Public Registry Access
+
+The Docker image is published to:
+`ghcr.io/sequentech/release-tool`
+
+### Enabling Public Access
+
+To ensure the image is publicly pullable (so `release-bot` or other users can use it without authentication):
+
+1. **Ensure the repository is public**: Go to the repository settings and verify that the repository visibility is set to "Public".
+2. **Configure organization package settings**: In the organization settings (Settings -> Packages), ensure that packages are configured to inherit the repository's visibility. This allows packages from public repositories to be automatically public.
+3. **Verify package visibility**: Navigate to the repository's **Packages** section (right sidebar on the main page), click on the `release-tool` package, and confirm it shows as "Public".
+
+### Configuration
+The workflow uses the standard `GITHUB_TOKEN` to authenticate with GHCR. No additional secrets are required for the repository itself, provided "Read and write permissions" are enabled for workflows in the repository settings (Settings -> Actions -> General -> Workflow permissions).
+
+## Local Development
+
+### Building the Docker Image Locally
+You can build the image locally for testing purposes:
+
+```bash
+docker build -t release-tool:local .
+```
+
+### VS Code Task
+For convenience, a VS Code task is included. Open the Command Palette (`Cmd+Shift+P`) and run **Tasks: Run Build Task** (or select "Docker: Build Image") to build the image directly from the editor.
+
+## Usage
+
+### Pulling the image
+```bash
+docker pull ghcr.io/sequentech/release-tool:latest
+```
+
+### Running the tool
+```bash
+docker run --rm -v $(pwd):/workspace -w /workspace ghcr.io/sequentech/release-tool release-tool --help
+```
+
+### Extending the image (e.g., for Release Bot)
+```dockerfile
+FROM ghcr.io/sequentech/release-tool:latest
+
+# Add your wrapper scripts
+COPY main.py /app/
+
+ENTRYPOINT ["python", "/app/main.py"]
+```

docs/docker.md

@@ -0,0 +1,101 @@
+"""Tests for Docker image build and functionality."""
+
+import subprocess
+import pytest
+
+
+@pytest.fixture(scope="module")
+def docker_image_name():
+    """Return the Docker image name to use for tests."""
+    return "release-tool-test"
+
+
+@pytest.fixture(scope="module")
+def build_docker_image(docker_image_name):
+    """Build the Docker image before running tests."""
+    # Build the Docker image
+    result = subprocess.run(
+        ["docker", "build", "-t", docker_image_name, "."],
+        capture_output=True,
+        text=True,
+    )
+    
+    if result.returncode != 0:
+        pytest.fail(f"Failed to build Docker image: {result.stderr}")
+    
+    yield docker_image_name
+    
+    # Cleanup: Remove the Docker image after tests
+    subprocess.run(
+        ["docker", "rmi", "-f", docker_image_name],
+        capture_output=True,
+    )
+
+
+def test_docker_image_builds_successfully(docker_image_name):
+    """Test that the Docker image can be built successfully from the Dockerfile."""
+    # Build the Docker image
+    result = subprocess.run(
+        ["docker", "build", "-t", docker_image_name, "."],
+        capture_output=True,
+        text=True,
+    )
+    
+    assert result.returncode == 0, f"Docker build failed: {result.stderr}"
+    # Modern Docker output may show success in stdout or stderr
+    output = result.stdout + result.stderr
+    assert (
+        "Successfully built" in output
+        or "Successfully tagged" in output
+        or f"naming to docker.io/library/{docker_image_name}" in output
+    )
+
+
+def test_release_tool_executable_available(build_docker_image):
+    """Test that the release-tool executable is available in the Docker image."""
+    # Check if release-tool command exists in the image
+    result = subprocess.run(
+        ["docker", "run", "--rm", build_docker_image, "which", "release-tool"],
+        capture_output=True,
+        text=True,
+    )
+    
+    assert result.returncode == 0, "release-tool executable not found in PATH"
+    assert "release-tool" in result.stdout
+
+
+def test_release_tool_help_returns_success(build_docker_image):
+    """Test that running release-tool -h inside the Docker container returns a successful exit code."""
+    # Run release-tool -h in the container
+    result = subprocess.run(
+        ["docker", "run", "--rm", build_docker_image, "release-tool", "-h"],
+        capture_output=True,
+        text=True,
+    )
+    
+    assert result.returncode == 0, f"release-tool -h failed with exit code {result.returncode}"
+    assert "Usage:" in result.stdout or "usage:" in result.stdout.lower()
+
+
+def test_docker_image_default_command(build_docker_image):
+    """Test that the Docker image runs release-tool as its default command."""
+    # Run the container without specifying a command
+    # This should execute the default CMD from the Dockerfile
+    result = subprocess.run(
+        ["docker", "run", "--rm", build_docker_image],
+        capture_output=True,
+        text=True,
+        timeout=5,
+    )
+    
+    # The default command should run release-tool, which without arguments
+    # should either show help or an error message from release-tool
+    # We're checking that it's release-tool that runs, not bash or another shell
+    assert result.returncode in [0, 1, 2], f"Unexpected exit code: {result.returncode}"
+    
+    # Verify the output contains release-tool-specific content
+    output = result.stdout + result.stderr
+    assert any(
+        keyword in output.lower()
+        for keyword in ["release-tool", "usage", "command"]
+    ), "Default command does not appear to be release-tool"