sschuhmann/rehearshalhub
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: RehearsalHub POC

Browse Source 
Full-stack self-hosted band rehearsal platform:

Backend (FastAPI + SQLAlchemy 2.0 async):
- Auth with JWT (register, login, /me, settings)
- Band management with Nextcloud folder integration
- Song management with audio version tracking
- Nextcloud scan to auto-import audio files
- Band membership with link-based invite system
- Song comments
- Audio analysis worker (BPM, key, loudness, waveform)
- Nextcloud activity watcher for auto-import
- WebSocket support for real-time annotation updates
- Alembic migrations (0001–0003)
- Repository pattern, Ruff + mypy configured

Frontend (React 18 + Vite + TypeScript strict):
- Login/register page with post-login redirect
- Home page with band list and creation form
- Band page with member panel, invite link, song list, NC scan
- Song page with waveform player, annotations, comment thread
- Settings page for per-user Nextcloud credentials
- Invite acceptance page (/invite/:token)
- ESLint v9 flat config + TypeScript strict mode

Infrastructure:
- Docker Compose: PostgreSQL, Redis, API, worker, watcher, nginx
- nginx reverse proxy for static files + /api/ proxy
- make check runs all linters before docker compose build

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Steffen Schuhmann
2026-03-28 21:53:03 +01:00
commit f7be1b994d
139 changed files with 12743 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
api/tests/integration/__init__.py Normal file
View File

98
api/tests/integration/conftest.py Normal file
View File

@@ -0,0 +1,98 @@
"""Integration test fixtures using testcontainers for a real Postgres."""
import pytest
import pytest_asyncio
from httpx import ASGITransport, AsyncClient
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
from rehearsalhub.db.models import Base
from rehearsalhub.main import create_app
@pytest.fixture(scope="session")
def pg_container():
"""Start a real Postgres container for the test session."""
from testcontainers.postgres import PostgresContainer
with PostgresContainer("postgres:16-alpine") as pg:
yield pg
@pytest.fixture(scope="session")
def pg_url(pg_container) -> str:
url = pg_container.get_connection_url()
return url.replace("postgresql+psycopg2://", "postgresql+asyncpg://").replace(
"postgresql://", "postgresql+asyncpg://"
)
@pytest_asyncio.fixture(scope="session")
async def pg_engine(pg_url):
engine = create_async_engine(pg_url, echo=False)
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
yield engine
await engine.dispose()
@pytest_asyncio.fixture(scope="function")
async def db_session(pg_engine) -> AsyncSession:
"""Each test gets its own connection with a rolled-back transaction."""
async with pg_engine.connect() as conn:
trans = await conn.begin()
session = AsyncSession(bind=conn, expire_on_commit=False)
yield session
await session.close()
await trans.rollback()
@pytest_asyncio.fixture(scope="function")
async def client(db_session):
"""httpx AsyncClient with DB session dependency overridden."""
from rehearsalhub.db.engine import get_session
app = create_app()
app.dependency_overrides[get_session] = lambda: db_session
async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as c:
yield c
app.dependency_overrides.clear()
@pytest_asyncio.fixture(scope="function")
async def auth_headers(client, db_session):
"""Register + login a test user, return Authorization headers."""
from tests.factories import create_member
member = await create_member(db_session, email="auth@test.com")
await db_session.commit()
resp = await client.post(
"/api/v1/auth/login", json={"email": "auth@test.com", "password": "testpassword123"}
)
assert resp.status_code == 200, resp.text
token = resp.json()["access_token"]
return {"Authorization": f"Bearer {token}"}
@pytest_asyncio.fixture(scope="function")
async def current_member(db_session):
from tests.factories import create_member
member = await create_member(db_session, email=f"member_{__import__('uuid').uuid4().hex[:6]}@test.com")
await db_session.commit()
return member
@pytest_asyncio.fixture(scope="function")
async def auth_headers_for(client, db_session):
"""Factory fixture: given a member, return auth headers for them."""
async def _make(member):
from rehearsalhub.services.auth import create_access_token
token = create_access_token(str(member.id), member.email)
return {"Authorization": f"Bearer {token}"}
return _make

203
api/tests/integration/test_api_annotations.py Normal file
View File

@@ -0,0 +1,203 @@
"""Integration tests for annotation endpoints."""
import uuid
import pytest
from tests.factories import (
create_annotation,
create_audio_version,
create_band,
create_member,
create_song,
)
@pytest.mark.asyncio
@pytest.mark.integration
async def test_create_point_annotation(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
song = await create_song(db_session, band_id=band.id, creator_id=current_member.id)
version = await create_audio_version(db_session, song_id=song.id, uploader_id=current_member.id)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.post(
f"/api/v1/versions/{version.id}/annotations",
json={"type": "point", "timestamp_ms": 3000, "body": "Nice groove here", "tags": ["groove"]},
headers=headers,
)
assert resp.status_code == 201, resp.text
data = resp.json()
assert data["type"] == "point"
assert data["timestamp_ms"] == 3000
assert data["tags"] == ["groove"]
@pytest.mark.asyncio
@pytest.mark.integration
async def test_create_range_annotation(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
song = await create_song(db_session, band_id=band.id, creator_id=current_member.id)
version = await create_audio_version(db_session, song_id=song.id, uploader_id=current_member.id)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.post(
f"/api/v1/versions/{version.id}/annotations",
json={
"type": "range",
"timestamp_ms": 5000,
"range_end_ms": 15000,
"label": "Vamp section",
"tags": ["vamp", "groove"],
},
headers=headers,
)
assert resp.status_code == 201, resp.text
data = resp.json()
assert data["type"] == "range"
assert data["range_end_ms"] == 15000
@pytest.mark.asyncio
@pytest.mark.integration
async def test_create_annotation_invalid_range_returns_422(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
song = await create_song(db_session, band_id=band.id, creator_id=current_member.id)
version = await create_audio_version(db_session, song_id=song.id)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.post(
f"/api/v1/versions/{version.id}/annotations",
json={"type": "range", "timestamp_ms": 5000, "range_end_ms": 3000},
headers=headers,
)
assert resp.status_code == 422
@pytest.mark.asyncio
@pytest.mark.integration
async def test_list_annotations(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
song = await create_song(db_session, band_id=band.id, creator_id=current_member.id)
version = await create_audio_version(db_session, song_id=song.id)
await create_annotation(db_session, version_id=version.id, author_id=current_member.id, timestamp_ms=1000)
await create_annotation(db_session, version_id=version.id, author_id=current_member.id, timestamp_ms=3000)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.get(f"/api/v1/versions/{version.id}/annotations", headers=headers)
assert resp.status_code == 200
data = resp.json()
assert len(data) == 2
assert data[0]["timestamp_ms"] == 1000
assert data[1]["timestamp_ms"] == 3000
@pytest.mark.asyncio
@pytest.mark.integration
async def test_update_annotation(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
song = await create_song(db_session, band_id=band.id, creator_id=current_member.id)
version = await create_audio_version(db_session, song_id=song.id)
annotation = await create_annotation(
db_session, version_id=version.id, author_id=current_member.id
)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.patch(
f"/api/v1/annotations/{annotation.id}",
json={"resolved": True, "label": "Updated label"},
headers=headers,
)
assert resp.status_code == 200
data = resp.json()
assert data["resolved"] is True
assert data["label"] == "Updated label"
@pytest.mark.asyncio
@pytest.mark.integration
async def test_delete_annotation(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
song = await create_song(db_session, band_id=band.id, creator_id=current_member.id)
version = await create_audio_version(db_session, song_id=song.id)
annotation = await create_annotation(
db_session, version_id=version.id, author_id=current_member.id
)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.delete(f"/api/v1/annotations/{annotation.id}", headers=headers)
assert resp.status_code == 204
# Should be gone from list
list_resp = await client.get(f"/api/v1/versions/{version.id}/annotations", headers=headers)
assert all(a["id"] != str(annotation.id) for a in list_resp.json())
@pytest.mark.asyncio
@pytest.mark.integration
async def test_add_reaction(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
song = await create_song(db_session, band_id=band.id, creator_id=current_member.id)
version = await create_audio_version(db_session, song_id=song.id)
annotation = await create_annotation(
db_session, version_id=version.id, author_id=current_member.id
)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.post(
f"/api/v1/annotations/{annotation.id}/reactions",
json={"emoji": "🔥"},
headers=headers,
)
assert resp.status_code == 201
assert resp.json()["emoji"] == "🔥"
@pytest.mark.asyncio
@pytest.mark.integration
async def test_search_ranges(client, db_session, auth_headers_for, current_member):
from rehearsalhub.db.models import RangeAnalysis
from rehearsalhub.repositories.annotation import AnnotationRepository
band = await create_band(db_session, creator_id=current_member.id)
song = await create_song(db_session, band_id=band.id, creator_id=current_member.id)
version = await create_audio_version(db_session, song_id=song.id)
annotation = await create_annotation(
db_session,
version_id=version.id,
author_id=current_member.id,
type="range",
timestamp_ms=5000,
range_end_ms=15000,
tags=["groove"],
)
# Manually insert a range_analysis
ra = RangeAnalysis(
annotation_id=annotation.id,
version_id=version.id,
start_ms=5000,
end_ms=15000,
bpm=120.0,
key="G major",
scale="major",
)
db_session.add(ra)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.get(
f"/api/v1/bands/{band.id}/search/ranges",
params={"bpm_min": 110, "bpm_max": 130, "key": "G major"},
headers=headers,
)
assert resp.status_code == 200
results = resp.json()
assert len(results) >= 1
assert any(r["bpm"] is not None for r in results)

73
api/tests/integration/test_api_auth.py Normal file
View File

@@ -0,0 +1,73 @@
"""Integration tests for auth endpoints."""
import pytest
import pytest_asyncio
@pytest.mark.asyncio
@pytest.mark.integration
async def test_register_creates_member(client, db_session):
resp = await client.post(
"/api/v1/auth/register",
json={"email": "newuser@test.com", "password": "pass123!", "display_name": "New User"},
)
assert resp.status_code == 201, resp.text
data = resp.json()
assert data["email"] == "newuser@test.com"
assert data["display_name"] == "New User"
assert "password_hash" not in data
assert "id" in data
@pytest.mark.asyncio
@pytest.mark.integration
async def test_register_duplicate_email_returns_409(client, db_session):
await client.post(
"/api/v1/auth/register",
json={"email": "dup@test.com", "password": "pass123!", "display_name": "User"},
)
resp = await client.post(
"/api/v1/auth/register",
json={"email": "dup@test.com", "password": "pass456!", "display_name": "User2"},
)
assert resp.status_code == 409
@pytest.mark.asyncio
@pytest.mark.integration
async def test_login_returns_jwt(client, db_session):
await client.post(
"/api/v1/auth/register",
json={"email": "login@test.com", "password": "pass123!", "display_name": "Login User"},
)
resp = await client.post(
"/api/v1/auth/login",
json={"email": "login@test.com", "password": "pass123!"},
)
assert resp.status_code == 200, resp.text
data = resp.json()
assert "access_token" in data
assert data["token_type"] == "bearer"
@pytest.mark.asyncio
@pytest.mark.integration
async def test_login_wrong_password_returns_401(client, db_session):
await client.post(
"/api/v1/auth/register",
json={"email": "wrongpw@test.com", "password": "correct!", "display_name": "User"},
)
resp = await client.post(
"/api/v1/auth/login",
json={"email": "wrongpw@test.com", "password": "wrong!"},
)
assert resp.status_code == 401
@pytest.mark.asyncio
@pytest.mark.integration
async def test_protected_endpoint_without_token_returns_401(client):
import uuid
resp = await client.get(f"/api/v1/bands/{uuid.uuid4()}")
assert resp.status_code == 401

74
api/tests/integration/test_api_bands.py Normal file
View File

@@ -0,0 +1,74 @@
"""Integration tests for band endpoints."""
import uuid
import pytest
from tests.factories import create_band, create_member
@pytest.mark.asyncio
@pytest.mark.integration
async def test_create_band(client, db_session, auth_headers_for, current_member):
headers = await auth_headers_for(current_member)
resp = await client.post(
"/api/v1/bands",
json={"name": "My Band", "slug": "my-band-001", "genre_tags": ["rock"]},
headers=headers,
)
assert resp.status_code == 201, resp.text
data = resp.json()
assert data["name"] == "My Band"
assert data["slug"] == "my-band-001"
assert data["genre_tags"] == ["rock"]
@pytest.mark.asyncio
@pytest.mark.integration
async def test_create_band_duplicate_slug_returns_409(client, db_session, auth_headers_for, current_member):
headers = await auth_headers_for(current_member)
await create_band(db_session, name="Existing", slug="taken-slug", creator_id=current_member.id)
await db_session.commit()
resp = await client.post(
"/api/v1/bands",
json={"name": "Another", "slug": "taken-slug"},
headers=headers,
)
assert resp.status_code == 409
@pytest.mark.asyncio
@pytest.mark.integration
async def test_get_band_with_members(client, db_session, auth_headers_for, current_member):
headers = await auth_headers_for(current_member)
band = await create_band(db_session, creator_id=current_member.id)
await db_session.commit()
resp = await client.get(f"/api/v1/bands/{band.id}", headers=headers)
assert resp.status_code == 200, resp.text
data = resp.json()
assert data["id"] == str(band.id)
assert len(data["memberships"]) == 1
assert data["memberships"][0]["role"] == "admin"
@pytest.mark.asyncio
@pytest.mark.integration
async def test_get_band_non_member_returns_403(client, db_session, auth_headers_for, current_member):
headers = await auth_headers_for(current_member)
# Band with a different creator
other_member = await create_member(db_session, email="other@test.com")
band = await create_band(db_session, creator_id=other_member.id)
await db_session.commit()
resp = await client.get(f"/api/v1/bands/{band.id}", headers=headers)
assert resp.status_code == 403
@pytest.mark.asyncio
@pytest.mark.integration
async def test_get_band_not_found_returns_404(client, db_session, auth_headers_for, current_member):
headers = await auth_headers_for(current_member)
resp = await client.get(f"/api/v1/bands/{uuid.uuid4()}", headers=headers)
assert resp.status_code in (403, 404)

99
api/tests/integration/test_api_songs.py Normal file
View File

@@ -0,0 +1,99 @@
"""Integration tests for song and version endpoints."""
import pytest
from tests.factories import create_audio_version, create_band, create_member, create_song
@pytest.mark.asyncio
@pytest.mark.integration
async def test_create_song(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.post(
f"/api/v1/bands/{band.id}/songs",
json={"title": "New Song", "status": "jam"},
headers=headers,
)
assert resp.status_code == 201, resp.text
data = resp.json()
assert data["title"] == "New Song"
assert data["status"] == "jam"
assert data["band_id"] == str(band.id)
@pytest.mark.asyncio
@pytest.mark.integration
async def test_list_songs(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
await create_song(db_session, band_id=band.id, title="Song 1")
await create_song(db_session, band_id=band.id, title="Song 2")
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.get(f"/api/v1/bands/{band.id}/songs", headers=headers)
assert resp.status_code == 200
data = resp.json()
assert len(data) == 2
titles = {s["title"] for s in data}
assert "Song 1" in titles
assert "Song 2" in titles
@pytest.mark.asyncio
@pytest.mark.integration
async def test_create_version_increments_version_number(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
song = await create_song(db_session, band_id=band.id, creator_id=current_member.id)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp1 = await client.post(
f"/api/v1/songs/{song.id}/versions",
json={"nc_file_path": "/bands/test/songs/song/v1.wav", "nc_file_etag": "etag1"},
headers=headers,
)
assert resp1.status_code == 201
assert resp1.json()["version_number"] == 1
resp2 = await client.post(
f"/api/v1/songs/{song.id}/versions",
json={"nc_file_path": "/bands/test/songs/song/v2.wav", "nc_file_etag": "etag2"},
headers=headers,
)
assert resp2.status_code == 201
assert resp2.json()["version_number"] == 2
@pytest.mark.asyncio
@pytest.mark.integration
async def test_list_versions(client, db_session, auth_headers_for, current_member):
band = await create_band(db_session, creator_id=current_member.id)
song = await create_song(db_session, band_id=band.id, creator_id=current_member.id)
await create_audio_version(db_session, song_id=song.id, version_number=1)
await create_audio_version(db_session, song_id=song.id, version_number=2)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.get(f"/api/v1/songs/{song.id}/versions", headers=headers)
assert resp.status_code == 200
data = resp.json()
assert len(data) == 2
@pytest.mark.asyncio
@pytest.mark.integration
async def test_non_member_cannot_create_song(client, db_session, auth_headers_for, current_member):
other = await create_member(db_session, email="other2@test.com")
band = await create_band(db_session, creator_id=other.id)
await db_session.commit()
headers = await auth_headers_for(current_member)
resp = await client.post(
f"/api/v1/bands/{band.id}/songs",
json={"title": "Intruder Song", "status": "jam"},
headers=headers,
)
assert resp.status_code == 403