Add testing setup with coverage configuration and GitHub Actions workflow

Author: decodingchris

.coveragerc

@@ -0,0 +1,13 @@
+[run]
+branch = True
+source = gitvault
+omit =
+    */tests/*
+    */.venv/*
+    */venv/*
+    */__init__.py
+    */.cache/*
+
+[report]
+show_missing = True
+fail_under = 80

.github/workflows/test.yml

@@ -0,0 +1,36 @@
+name: Run Tests and Coverage
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install coverage pytest
+
+      - name: Run tests with coverage
+        run: bash scripts/test.sh
+
+      - name: Upload HTML coverage report
+        uses: actions/upload-artifact@v4
+        with:
+          name: htmlcov-${{ matrix.python-version }}
+          path: htmlcov/

.gitignore

@@ -182,3 +182,6 @@ memory-bank/
 # GitVault
 .gitvault_private/
 .gitvaultinclude
+
+# VS Code
+.vscode/

README.md

@@ -0,0 +1,87 @@
+# GitVault
+
+A simple way to keep your private files safe while sharing your code with the world.
+
+---
+
+## Overview
+
+GitVault helps you **manage sensitive files and folders** that you don’t want in your public Git repo. It lets you back up and version those private files in a separate, secure repo — so you get the best of both worlds.
+
+---
+
+## What it does
+
+- Use a `.gitvaultinclude` file to list private stuff you want to track (which should also be in `.gitignore`)
+- `gitvault init` sets up GitVault in your project, creating the private repo and config files
+- `gitvault status` shows what’s changed in your private files since your last save
+- `gitvault save` commits and pushes those private changes to your private repo
+- `gitvault discard` lets you throw away private changes you don’t want to keep
+- Keeps secrets out of your public repo, no surprises
+- Manual control — **you decide when to save, discard, or check**
+
+---
+
+## How to use it
+
+1. **Initialize GitVault**
+
+Run this once in your repo to set things up:
+
+```bash
+gitvault init
+```
+
+2. **List your private files**
+
+Create a `.gitvaultinclude` file with paths to your private files or folders (make sure they’re also in `.gitignore`):
+
+```
+secrets.env
+private_notes/
+config/dev.yaml
+```
+
+3. **See what’s changed**
+
+```bash
+gitvault status
+```
+
+4. **Save your private changes**
+
+```bash
+gitvault save
+```
+
+5. **Discard private changes you don’t want**
+
+```bash
+gitvault discard
+```
+
+That’s it — your sensitive stuff is safely versioned, but never exposed.
+
+---
+
+## Installation
+
+_Coming soon on PyPI!_  
+For now, just clone this repo and install the dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+## Contributing
+
+Ideas, bugs, or want to help out?  
+Pull requests are welcome! Or just open an issue and let’s chat.
+
+---
+
+## License
+
+MIT License

requirements.txt

@@ -1,2 +1,3 @@
 click==8.1.8
-gitpython==3.1.44
+gitpython==3.1.44
+pytest==8.3.5

scripts/test.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -e
+
+coverage run -m pytest
+coverage report -m
+coverage html

tests/conftest.py

@@ -0,0 +1,36 @@
+import pytest
+from unittest import mock
+
+@pytest.fixture
+def temp_dir(tmp_path):
+    """Provides a temporary directory unique to the test invocation."""
+    return tmp_path
+
+@pytest.fixture
+def mock_git_repo():
+    """Mocks GitPython's Repo object."""
+    with mock.patch("git.Repo") as mock_repo_cls:
+        mock_repo = mock.Mock()
+        mock_repo_cls.return_value = mock_repo
+        yield mock_repo
+
+@pytest.fixture(autouse=True)
+def shared_setup_teardown():
+    """Shared setup/teardown logic for all tests, including patching gh repo create."""
+    import subprocess as sp
+    from unittest import mock
+
+    real_run = sp.run
+
+    def fake_run(*args, **kwargs):
+        # Support subprocess.run(args, **kwargs) where args can be list or str
+        cmd = args[0] if args else kwargs.get("args")
+        if isinstance(cmd, list) and len(cmd) >= 3:
+            if cmd[0] == "gh" and cmd[1] == "repo" and cmd[2] == "create":
+                # Simulate successful repo creation without creating a real repo
+                return sp.CompletedProcess(cmd, 0, stdout="Simulated repo created\n", stderr="")
+        # Otherwise, call the real subprocess.run
+        return real_run(*args, **kwargs)
+
+    with mock.patch("subprocess.run", side_effect=fake_run):
+        yield