Skip to content

Speakr is a personal, self-hosted web application designed for transcribing audio recordings

Python
8.6 KB
Raw Blame
"""Per-user timezone for text the server writes (#412).

The issue: with a naming template such as "{{datetime}} <label>", a recording
made at 09:13 local time (UTC+3, stored as 06:13 UTC) was titled 06:13. Titles
now use the owner's zone: the browser's zone in 'auto' mode, a zone chosen in
Account settings in 'fixed' mode, else the admin default. Stored data and API
output stay UTC (tests/test_datetime_contract.py).

SHARED-DB: users, recordings and the admin setting are restored afterwards.
"""

import os
import sys
import uuid
from datetime import datetime
from unittest.mock import patch

import pytest
from flask import g, has_app_context
from flask.testing import FlaskClient

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from src.app import app, db
from src.models import NamingTemplate, Recording, SystemSetting, User
from src.services.titling import compute_title
from src.tasks import processing
from src.utils import timezones as tz

app.config["WTF_CSRF_ENABLED"] = False


class _Client(FlaskClient):
    def open(self, *args, **kwargs):
        if has_app_context():
            g.pop('_login_user', None)
        return super().open(*args, **kwargs)


@pytest.fixture
def admin_default():
    """Pin the admin default for the test, restore it afterwards."""
    with app.app_context():
        old = SystemSetting.get_setting(tz.DEFAULT_SETTING_KEY, None)

    def set_(value):
        with app.app_context():
            SystemSetting.set_setting(tz.DEFAULT_SETTING_KEY, value, setting_type='string')
            db.session.commit()
    set_('UTC')
    yield set_
    with app.app_context():
        if old is None:
            SystemSetting.query.filter_by(key=tz.DEFAULT_SETTING_KEY).delete()
            db.session.commit()
        else:
            set_(old)


@pytest.fixture
def made():
    ids = []
    yield ids
    with app.app_context():
        db.session.rollback()
        for model, oid in reversed(ids):
            obj = db.session.get(model, oid)
            if obj is not None:
                if isinstance(obj, User):
                    obj.default_naming_template_id = None
                    db.session.commit()
                db.session.delete(obj)
        db.session.commit()


def _user(made, **kw):
    s = uuid.uuid4().hex[:8]
    u = User(username=f"tz_{s}", email=f"tz_{s}@local.test", password="x", **kw)
    db.session.add(u)
    db.session.commit()
    made.append((User, u.id))
    return u


def _client(user_id):
    c = _Client(app, app.response_class, use_cookies=True)
    with c.session_transaction() as sess:
        sess["_user_id"] = str(user_id)
    return c


# ------------------------------------------------------------------ helpers

def test_to_local_converts_naive_utc_and_handles_dst():
    assert tz.to_local(datetime(2026, 10, 1, 6, 13), "Europe/Istanbul") == datetime(2026, 10, 1, 9, 13)
    assert tz.to_local(datetime(2026, 1, 15, 17, 0), "America/New_York") == datetime(2026, 1, 15, 12, 0)   # EST
    assert tz.to_local(datetime(2026, 7, 15, 17, 0), "America/New_York") == datetime(2026, 7, 15, 13, 0)   # EDT
    assert tz.to_local(None, "UTC") is None


@pytest.mark.parametrize("name,ok", [("Europe/Istanbul", True), ("UTC", True), ("Mars/Olympus", False),
                                     ("", False), (None, False), ("../../etc/passwd", False)])
def test_is_valid_timezone(name, ok):
    assert tz.is_valid_timezone(name) is ok


def test_user_zone_falls_back_to_the_admin_default(made, admin_default):
    admin_default("Asia/Tokyo")
    with app.app_context():
        assert tz.user_timezone(_user(made)) == "Asia/Tokyo"
        assert tz.user_timezone(_user(made, timezone="Europe/Istanbul")) == "Europe/Istanbul"
        assert tz.user_timezone(_user(made, timezone="Bogus/Zone")) == "Asia/Tokyo"


def test_browser_zone_is_saved_in_auto_mode_only(made):
    with app.app_context():
        auto = _user(made, timezone_mode="auto")
        fixed = _user(made, timezone="Europe/Berlin", timezone_mode="fixed")
        assert tz.record_browser_timezone(auto, "Europe/Istanbul") is True
        assert tz.record_browser_timezone(fixed, "Europe/Istanbul") is False
        assert tz.record_browser_timezone(auto, "Not/AZone") is False
        assert (auto.timezone, fixed.timezone) == ("Europe/Istanbul", "Europe/Berlin")


# -------------------------------------------------------------- titles (#412)

def _templated(made, user, template):
    t = NamingTemplate(user_id=user.id, name="tz", template=template)
    db.session.add(t)
    db.session.commit()
    made.append((NamingTemplate, t.id))
    user.default_naming_template_id = t.id
    db.session.commit()
    r = Recording(user_id=user.id, title="Recording - a.wav", original_filename="a.wav", status="PROCESSING",
                  transcription="Speaker 1: hello there everyone, let us start the meeting.",
                  meeting_date=datetime(2026, 10, 1, 6, 13, 46))
    db.session.add(r)
    db.session.commit()
    made.append((Recording, r.id))
    return r


def test_issue_412_title_uses_the_owner_local_time(made, admin_default):
    with app.app_context():
        u = _user(made, timezone="Europe/Istanbul")
        r = _templated(made, u, "{{datetime}} standup")
        with patch.object(processing, "client", None):
            assert compute_title(r) == "2026-10-01 09:13 standup"


def test_without_any_zone_titles_stay_utc_as_before(made, admin_default):
    with app.app_context():
        u = _user(made)
        r = _templated(made, u, "{{date}} {{time}}")
        with patch.object(processing, "client", None):
            assert compute_title(r) == "2026-10-01 06:13"


def test_admin_default_applies_to_users_without_a_zone(made, admin_default):
    admin_default("America/Los_Angeles")
    with app.app_context():
        u = _user(made)
        r = _templated(made, u, "{{datetime}}")
        with patch.object(processing, "client", None):
            assert compute_title(r) == "2026-09-30 23:13"


def test_template_preview_default_is_now_in_the_user_zone(made, admin_default):
    with app.app_context():
        u = _user(made, timezone="Asia/Kolkata")
        t = NamingTemplate(user_id=u.id, name="p", template="{{time}}")
        db.session.add(t)
        db.session.commit()
        made.append((NamingTemplate, t.id))
        c = _client(u.id)
        expected = tz.now_local("Asia/Kolkata").strftime("%H:%M")
        resp = c.post(f"/api/naming-templates/{t.id}/test", json={})
        assert resp.status_code == 200, resp.get_data(as_text=True)[:300]
        assert resp.get_json()["result"] in (expected, tz.now_local("Asia/Kolkata").strftime("%H:%M"))


# --------------------------------------------------------------- endpoints

def test_timezone_endpoint_saves_the_browser_zone(made):
    with app.app_context():
        u = _user(made)
        uid = u.id
    c = _client(uid)
    resp = c.post("/api/user/timezone", json={"timezone": "Europe/Istanbul"})
    assert resp.status_code == 200 and resp.get_json() == {"timezone": "Europe/Istanbul", "mode": "auto"}
    resp = c.post("/api/user/timezone", json={"timezone": "No/Such"})
    assert resp.get_json()["timezone"] == "Europe/Istanbul"
    with app.app_context():
        assert db.session.get(User, uid).timezone == "Europe/Istanbul"


def test_account_form_fixes_or_releases_the_zone(made):
    with app.app_context():
        uid = _user(made).id
    c = _client(uid)
    base = {"preferences_form": "1", "ui_language": "en"}
    c.post("/account", data={**base, "timezone": "America/Chicago", "detected_timezone": "Europe/Istanbul"})
    with app.app_context():
        u = db.session.get(User, uid)
        assert (u.timezone, u.timezone_mode) == ("America/Chicago", "fixed")
    # a fixed zone is not replaced by the browser
    c.post("/api/user/timezone", json={"timezone": "Europe/Istanbul"})
    with app.app_context():
        assert db.session.get(User, uid).timezone == "America/Chicago"
    c.post("/account", data={**base, "timezone": "auto", "detected_timezone": "Europe/Istanbul"})
    with app.app_context():
        u = db.session.get(User, uid)
        assert (u.timezone, u.timezone_mode) == ("Europe/Istanbul", "auto")


def test_admin_default_timezone_is_validated(made, admin_default):
    with app.app_context():
        uid = _user(made, is_admin=True).id
    c = _client(uid)
    bad = c.post("/admin/settings", json={"key": "default_timezone", "value": "Mars/Olympus", "setting_type": "string"})
    assert bad.status_code == 400
    ok = c.post("/admin/settings", json={"key": "default_timezone", "value": "Europe/Berlin", "setting_type": "string"})
    assert ok.status_code == 200, ok.get_data(as_text=True)[:200]
    with app.app_context():
        assert tz.deployment_timezone() == "Europe/Berlin"