Deploymentcenter/tests/e2e/suite_bugtracker.py

#!/usr/bin/env python3
"""
Bugtracker, Roadmap und Fehlerstrom.

Diese Gruppe geht den Weg, den ein Agent tatsaechlich nimmt: melden, Arbeit
holen, uebernehmen, kommentieren, abschliessen. Einzelne Endpunkte fuer sich
zu pruefen wuerde die Uebergaenge auslassen - und dort sitzen die Fehler, die
weh tun (doppelte Items, zwei Agenten am selben Item, verlorene Reservierung).
"""

import time

from harness import (test, erwarte, erwarte_status, erwarte_erfolg,
                     erwarte_fehler, ueberspringen)

PROJEKT = 'myapp'   # aus sql/schema.sql - ein Projekt, das nach dem Zuruecksetzen existiert
BUILD = '9.9.9-test'


def _item_id(resp):
    """
    Die Antwort nennt die ID als item_id. Ueber diesen einen Ort geholt,
    damit eine Umbenennung im Vertrag genau einen Testfall betrifft und
    nicht zehn.
    """
    for name in ('item_id', 'id'):
        wert = resp.feld(name)
        if isinstance(wert, int) and wert > 0:
            return wert
    return resp.feld('item', 'id')


def _liste(resp, *kandidaten):
    """Die Liste aus einer Antwort holen, ohne sich auf einen Feldnamen zu verlassen."""
    for name in kandidaten:
        wert = resp.feld(name)
        if isinstance(wert, list):
            return wert
    for wert in (resp.json or {}).values():
        if isinstance(wert, list):
            return wert
    return []


# ---------------------------------------------------------------------------
# Melden
# ---------------------------------------------------------------------------

@test('bugtracker', 'Meldung legt ein Item an')
def _(ctx):
    ref = 'e2e-%d' % int(time.time())
    r = ctx.client.post('/api/bugtracker/v1/report', body={
        'project_slug': PROJEKT,
        'title': 'Automatischer Testlauf: Beispielbefund',
        'description': 'Angelegt von tests/e2e. Darf jederzeit geloescht werden.',
        'severity': 'high',
        'environment': 'testing',
        'build_version': BUILD,
        'error_message': 'RuntimeException: Beispiel',
        'file_path': 'tests/e2e/suite_bugtracker.py',
        'line_no': 42,
        'client_ref': ref,
    })
    erwarte_erfolg(r)
    item_id = _item_id(r)
    erwarte(isinstance(item_id, int) and item_id > 0,
            "Keine Item-ID in der Antwort: %s" % r.kurz(300))
    ctx['bug_id'] = item_id
    ctx['bug_ref'] = ref


@test('bugtracker', 'Wiederholte Meldung erzeugt kein Duplikat')
def _(ctx):
    """
    Gleiches client_ref, gleiches Item. Ein Agent, dem die Verbindung
    wegbricht, sendet erneut - und soll damit nicht den Tracker fluten.
    """
    r = ctx.client.post('/api/bugtracker/v1/report', body={
        'project_slug': PROJEKT,
        'title': 'Automatischer Testlauf: Beispielbefund',
        'description': 'Zweite Sendung derselben Meldung.',
        'severity': 'high',
        'environment': 'testing',
        'build_version': BUILD,
        'client_ref': ctx['bug_ref'],
    })
    erwarte_erfolg(r)
    erneut = _item_id(r)
    erwarte(erneut == ctx['bug_id'],
            "Zweite Sendung erzeugte Item #%s statt #%s" % (erneut, ctx['bug_id']))
    erwarte(r.feld('is_new') is not True,
            "Die zweite Sendung gilt als neues Item: %s" % r.kurz(300))


@test('bugtracker', 'Idempotency-Key im Header wirkt wie client_ref')
def _(ctx):
    ref = 'e2e-header-%d' % int(time.time())
    body = {
        'project_slug': PROJEKT,
        'title': 'Automatischer Testlauf: Kopfzeilen-Idempotenz',
        'description': 'Erste Sendung.',
        'environment': 'testing',
        'build_version': BUILD,
    }
    r1 = ctx.client.post('/api/bugtracker/v1/report', body=body,
                         headers={'Idempotency-Key': ref})
    erwarte_erfolg(r1)
    r2 = ctx.client.post('/api/bugtracker/v1/report', body=body,
                         headers={'Idempotency-Key': ref})
    erwarte_erfolg(r2)
    erwarte(_item_id(r1) == _item_id(r2),
            "Header-Idempotenz greift nicht: #%s dann #%s" % (_item_id(r1), _item_id(r2)))
    erwarte(r2.feld('idempotent_hit') is True,
            "Die zweite Sendung wurde nicht als Wiederholung erkannt: %s" % r2.kurz(300))


@test('bugtracker', 'Unbekannter Schweregrad faellt auf den Standard zurueck')
def _(ctx):
    """
    Ein Client mit einem Tippfehler soll seine Meldung loswerden, nicht eine
    Fehlermeldung. Die Anwendung normalisiert - das muss so bleiben, sonst
    verlieren Agenten Befunde an einer Kleinigkeit.
    """
    r = ctx.client.post('/api/bugtracker/v1/report', body={
        'project_slug': PROJEKT,
        'title': 'Automatischer Testlauf: unbekannter Schweregrad',
        'severity': 'ganz-dringend-echt-jetzt',
        'environment': 'testing',
        'build_version': BUILD,
        'client_ref': 'e2e-severity-%d' % int(time.time()),
    })
    erwarte_erfolg(r)


@test('bugtracker', 'Absender kommt aus dem Token, nicht aus dem Body')
def _(ctx):
    """created_by darf nicht frei waehlbar sein - sonst ist die Herkunft wertlos."""
    ref = 'e2e-absender-%d' % int(time.time())
    r = ctx.client.post('/api/bugtracker/v1/report', body={
        'project_slug': PROJEKT,
        'title': 'Automatischer Testlauf: Absender',
        'environment': 'testing',
        'build_version': BUILD,
        'created_by': 'jemand-ganz-anderes',
        'client_ref': ref,
    })
    erwarte_erfolg(r)

    detail = ctx.client.get('/api/bugtracker/v1/manage',
                            query={'action': 'get', 'id': _item_id(r)})
    erwarte_erfolg(detail)
    item = detail.feld('item') or detail.json
    erstellt_von = str(item.get('created_by', '')) if isinstance(item, dict) else ''
    erwarte(erstellt_von != 'jemand-ganz-anderes',
            "created_by wurde aus dem Body uebernommen: %r" % erstellt_von)


# ---------------------------------------------------------------------------
# Lesen
# ---------------------------------------------------------------------------

@test('bugtracker', 'Projektliste enthaelt die angelegten Projekte')
def _(ctx):
    """
    Die Liste kommt aus dc_projects, nicht aus den Meldungen. Genau das ist
    der Unterschied, den ein Client kennen muss: In ein unbekanntes Projekt
    zu melden ist erlaubt, aber es taucht deshalb nicht in der Liste auf.
    """
    r = ctx.client.get('/api/bugtracker/v1/projects')
    erwarte_erfolg(r)
    slugs = [p.get('slug') for p in _liste(r, 'projects') if isinstance(p, dict)]
    erwarte(PROJEKT in slugs, "Projekt %r fehlt in der Liste: %s" % (PROJEKT, slugs))
    erwarte('deploymentcenter' in slugs,
            "Das eigene Projekt fehlt in der Liste: %s" % slugs)


@test('bugtracker', 'Liste findet das angelegte Item')
def _(ctx):
    r = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'list', 'project_slug': PROJEKT, 'limit': 50})
    erwarte_erfolg(r)
    items = _liste(r, 'items', 'bugs', 'data')
    ids = [i.get('id') for i in items if isinstance(i, dict)]
    erwarte(ctx['bug_id'] in ids, "Item #%s nicht in der Liste (%s)" % (ctx['bug_id'], ids[:10]))


@test('bugtracker', 'Suche nach der Nummer findet das Item')
def _(ctx):
    """
    Die Nummer ist das, was ueberall zitiert wird - und war ausgerechnet
    ueber die Suche nicht auffindbar: Sie steht in keiner der durchsuchten
    Spalten. Wer sie eingab, bekam nichts.
    """
    r = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'list', 'project_slug': PROJEKT,
                              'search': str(ctx['bug_id']), 'limit': 50})
    erwarte_erfolg(r)
    ids = [i.get('id') for i in _liste(r, 'items', 'bugs', 'data') if isinstance(i, dict)]
    erwarte(ctx['bug_id'] in ids,
            "Suche nach %s findet das Item nicht (%s)" % (ctx['bug_id'], ids[:10]))


@test('bugtracker', 'Suche mit Raute liefert genau dieses Item')
def _(ctx):
    """
    Mit Raute ist die Absicht eindeutig - dann darf kein Treffer dabei sein,
    der die Zahl nur im Text stehen hat.
    """
    r = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'list', 'project_slug': PROJEKT,
                              'search': '#%s' % ctx['bug_id'], 'limit': 50})
    erwarte_erfolg(r)
    ids = [i.get('id') for i in _liste(r, 'items', 'bugs', 'data') if isinstance(i, dict)]
    erwarte(ids == [ctx['bug_id']],
            "Erwartet genau [%s], bekommen %s" % (ctx['bug_id'], ids))


@test('bugtracker', 'Suche nach einer fremden Nummer findet nichts')
def _(ctx):
    r = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'list', 'project_slug': PROJEKT,
                              'search': '#999999', 'limit': 50})
    erwarte_erfolg(r)
    ids = [i.get('id') for i in _liste(r, 'items', 'bugs', 'data') if isinstance(i, dict)]
    erwarte(ids == [], "Unerwartete Treffer: %s" % ids[:10])


@test('bugtracker', 'Einzelabruf liefert das Item')
def _(ctx):
    r = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'get', 'id': ctx['bug_id']})
    erwarte_erfolg(r)
    erwarte(str(ctx['bug_id']) in (r.body or ''), "Item #%s nicht enthalten" % ctx['bug_id'])


@test('bugtracker', 'Einzelabruf eines fehlenden Items antwortet 404')
def _(ctx):
    r = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'get', 'id': 999999})
    erwarte_fehler(r, http=404, code='not_found')


@test('bugtracker', 'Kennzahlen abrufbar')
def _(ctx):
    r = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'stats', 'project_slug': PROJEKT})
    erwarte_erfolg(r)


# ---------------------------------------------------------------------------
# Arbeiten
# ---------------------------------------------------------------------------

@test('bugtracker', 'Item laesst sich uebernehmen')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'claim', 'id': ctx['bug_id']}, body={})
    erwarte_erfolg(r)


@test('bugtracker', 'Ein uebernommenes Item ist fuer andere gesperrt')
def _(ctx):
    """
    Der Kern der Reservierung: Ein zweiter Agent darf dasselbe Item nicht
    bekommen. Ohne diese Sperre arbeiten zwei Agenten am selben Fehler und
    ueberschreiben sich gegenseitig.
    """
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'claim', 'id': ctx['bug_id']},
                        token=ctx.get('zweites_token') or ctx['master_token'], body={})
    if r.ok:
        # Dasselbe Token darf sein eigenes Item erneut uebernehmen; das ist
        # kein Fehler. Geprueft wird der fremde Zugriff - dafuer braucht es
        # ein zweites Token, das der Testlauf sich hier holt.
        prov = ctx.client.post('/api/tokens/v1/provision', body={
            'client_name': 'e2e-zweiter-agent',
            'scopes': ['bugtracker:manage'],
        })
        erwarte_erfolg(prov)
        ctx['zweites_token'] = prov.feld('sub_token')
        r = ctx.client.post('/api/bugtracker/v1/manage',
                            query={'action': 'claim', 'id': ctx['bug_id']},
                            token=ctx['zweites_token'], body={})
    erwarte_fehler(r, http=409, code='already_claimed')


@test('bugtracker', 'Kommentar wird angenommen')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'comment', 'id': ctx['bug_id']},
                        body={'comment': 'Automatischer Testlauf: Zwischenstand.',
                              'action_taken': 'investigated'})
    erwarte_erfolg(r)


@test('bugtracker', 'Leerer Kommentar wird abgewiesen')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'comment', 'id': ctx['bug_id']},
                        body={'comment': '   '})
    erwarte_fehler(r, http=400, code='missing_comment')


@test('bugtracker', 'Status laesst sich setzen')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'status', 'id': ctx['bug_id']},
                        body={'status': 'in_progress', 'notes': 'Automatischer Testlauf.'})
    erwarte_erfolg(r)


@test('bugtracker', 'Status ohne Angabe wird abgewiesen')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'status', 'id': ctx['bug_id']}, body={})
    erwarte_fehler(r, http=400, code='missing_status')


@test('bugtracker', 'Naechste Arbeit wird ausgegeben und reserviert')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'next'},
                        body={'project_slug': PROJEKT, 'limit': 1})
    erwarte_erfolg(r)
    items = _liste(r, 'items', 'item')
    ctx['next_id'] = items[0].get('id') if items and isinstance(items[0], dict) else None


@test('bugtracker', 'Abschluss verlangt die Build-Angabe')
def _(ctx):
    """Ohne "behoben in" ist ein Abschluss nicht nachpruefbar."""
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'resolve', 'id': ctx['bug_id']}, body={})
    erwarte_fehler(r, http=400, code='missing_build')


@test('bugtracker', 'Item laesst sich abschliessen')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'resolve', 'id': ctx['bug_id']},
                        body={'resolved_in_build': BUILD,
                              'resolution_notes': 'Automatischer Testlauf.'})
    erwarte_erfolg(r)


@test('bugtracker', 'Reservierung laesst sich zuruecknehmen')
def _(ctx):
    neu = ctx.client.post('/api/bugtracker/v1/report', body={
        'project_slug': PROJEKT,
        'title': 'Automatischer Testlauf: Reservierung zuruecknehmen',
        'environment': 'testing',
        'build_version': BUILD,
        'client_ref': 'e2e-release-%d' % int(time.time()),
    })
    erwarte_erfolg(neu)
    item = _item_id(neu)

    erwarte_erfolg(ctx.client.post('/api/bugtracker/v1/manage',
                                   query={'action': 'claim', 'id': item}, body={}))
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'release', 'id': item},
                        body={'note': 'Automatischer Testlauf.'})
    erwarte_erfolg(r)
    ctx['freies_item'] = item


@test('bugtracker', 'Bestaetigen haelt die geprueften Fassung fest, nicht nur den Status')
def _(ctx):
    """confirm ist nicht resolve.

    resolve behauptet "ich habe es behoben, in Build X"; confirm haelt eine
    Beobachtung fest - gegen dieses Paket geprueft, Fehler weg. Kam beides als
    status=closed im Bestand an, war die Frage "wurde das je gegen ein
    ausgeliefertes Paket geprueft?" nicht beantwortbar.
    """
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'confirm', 'id': ctx['bug_id']},
                        body={'verified_in_build': BUILD,
                              'notes': 'Automatischer Testlauf.'})
    erwarte_erfolg(r)

    danach = ctx.client.get('/api/bugtracker/v1/manage',
                            query={'action': 'get', 'id': ctx['bug_id']})
    erwarte_erfolg(danach)

    erwarte(danach.feld('item', 'status') == 'closed',
            "Nach der Bestaetigung sollte das Item geschlossen sein, ist aber %r."
            % danach.feld('item', 'status'))
    erwarte(danach.feld('item', 'verified_at') is not None,
            "verified_at fehlt - dann ist eine bestaetigte Nachpruefung von einem "
            "schlichten Schliessen nicht zu unterscheiden.")
    erwarte(danach.feld('item', 'verified_in_build') == BUILD,
            "verified_in_build sollte %r sein, ist %r."
            % (BUILD, danach.feld('item', 'verified_in_build')))


@test('bugtracker', 'Bestaetigen geht nur, wo es etwas zu bestaetigen gibt')
def _(ctx):
    """Ein offenes Item zu bestaetigen waere ein Schliessen mit schmueckendem
    Beiwort - und stuende hinterher als geprueft in der Statistik."""
    neu = ctx.client.post('/api/bugtracker/v1/report', body={
        'project_slug': PROJEKT,
        'title': 'Automatischer Testlauf: nichts zu bestaetigen',
        'environment': 'testing',
        'build_version': BUILD,
        'client_ref': 'e2e-confirm-offen-%d' % int(time.time()),
    })
    erwarte_erfolg(neu)

    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'confirm', 'id': _item_id(neu)},
                        body={'verified_in_build': BUILD})
    erwarte_fehler(r, http=409, code='not_verifiable')


@test('bugtracker', 'Pruefen und Beheben sind verschiedene Rechte')
def _(ctx):
    """bugtracker:verify erlaubt bestaetigen, aber nicht beheben.

    Ohne diese Trennung stand die Rollengrenze eines Pruefagenten nur in
    seinem Prompt: Wer bestaetigen durfte, durfte auch resolve, bulk_update
    und die Roadmap umschreiben.
    """
    ausstellung = ctx.client.post('/api/tokens/v1/provision', body={
        'client_name': 'e2e-pruefer',
        'instance_id': 'testrunner-verify',
        'scopes': ['bugtracker:verify'],
        'environment': 'testing',
    })
    erwarte_erfolg(ausstellung)

    pruefer = ausstellung.feld('sub_token')
    if not pruefer:
        ueberspringen('Kein sub_token in der Antwort: %s' % ausstellung.kurz(200))

    ziel = ctx.client.post('/api/bugtracker/v1/report', body={
        'project_slug': PROJEKT,
        'title': 'Automatischer Testlauf: Rechtetrennung',
        'environment': 'testing',
        'build_version': BUILD,
        'client_ref': 'e2e-verify-scope-%d' % int(time.time()),
    })
    erwarte_erfolg(ziel)
    item = _item_id(ziel)

    # Darf er nicht: beheben.
    verboten = ctx.client.post('/api/bugtracker/v1/manage', token=pruefer,
                               query={'action': 'resolve', 'id': item},
                               body={'resolved_in_build': BUILD})
    erwarte_status(verboten, 401, 403)

    # Darf er: uebernehmen und kommentieren.
    erwarte_erfolg(ctx.client.post('/api/bugtracker/v1/manage', token=pruefer,
                                   query={'action': 'claim', 'id': item}, body={}))
    erwarte_erfolg(ctx.client.post('/api/bugtracker/v1/manage', token=pruefer,
                                   query={'action': 'comment', 'id': item},
                                   body={'comment': 'Automatischer Testlauf.'}))


@test('bugtracker', 'Unbekannte Aktion wird abgewiesen')
def _(ctx):
    r = ctx.client.get('/api/bugtracker/v1/manage', query={'action': 'alles-loeschen'})
    erwarte_fehler(r, http=(400, 404))


# ---------------------------------------------------------------------------
# Roadmap
# ---------------------------------------------------------------------------

@test('roadmap', 'Epic laesst sich anlegen')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/roadmap.php',
                        query={'action': 'epic'},
                        body={'project_slug': PROJEKT, 'epic': 'e2e-epic',
                              'title': 'Testlauf-Epic',
                              'summary': 'Angelegt vom automatischen Testlauf.',
                              'sort_order': 10})
    erwarte_erfolg(r)


@test('roadmap', 'Item laesst sich einplanen')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/roadmap.php',
                        query={'action': 'set', 'id': ctx['freies_item']},
                        body={'project_slug': PROJEKT, 'epic': 'e2e-epic',
                              'roadmap_rank': 5, 'target_build': BUILD})
    erwarte_erfolg(r)


@test('roadmap', 'Einplanen ohne Feld wird abgewiesen')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/roadmap.php',
                        query={'action': 'set', 'id': ctx['freies_item']},
                        body={'project_slug': PROJEKT})
    erwarte_fehler(r, http=400, code='nothing_to_do')


@test('roadmap', 'Einplanen eines fehlenden Items antwortet 404')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/roadmap.php',
                        query={'action': 'set', 'id': 999999},
                        body={'project_slug': PROJEKT, 'epic': 'e2e-epic'})
    erwarte_fehler(r, http=404, code='not_found')


@test('roadmap', 'Zurueckstellen ohne Ausloeser wird abgewiesen')
def _(ctx):
    """
    Die einzige echte Regel des Moduls.

    Ohne benannten Anlass ist ein Vorhaben nicht zurueckgestellt, sondern
    vergessen - und ein vergessener Punkt sieht in jeder Liste aus wie ein
    geplanter. Die Regel sitzt im Repository und muss deshalb auf allen
    Schreibwegen gleich greifen; geprueft wird hier der ueber roadmap.php.
    """
    r = ctx.client.post('/api/bugtracker/v1/roadmap.php',
                        query={'action': 'set', 'id': ctx['freies_item']},
                        body={'project_slug': PROJEKT, 'status': 'deferred'})
    erwarte_fehler(r, http=400, code='invalid_update')


@test('roadmap', 'Zurueckstellen mit Ausloeser wird angenommen')
def _(ctx):
    """
    Die Gegenprobe. Ohne sie liesse sich der Fall darueber auch dadurch
    bestehen, dass 'deferred' gar nicht mehr geht.
    """
    r = ctx.client.post('/api/bugtracker/v1/roadmap.php',
                        query={'action': 'set', 'id': ctx['freies_item']},
                        body={'project_slug': PROJEKT, 'status': 'deferred',
                              'defer_trigger': 'sobald der Testlauf danach fragt'})
    erwarte_erfolg(r)


@test('roadmap', 'Zurueckgestelltes taucht nicht in der Arbeitsschlange auf')
def _(ctx):
    """
    Der Zweck des Status. Stuende ein zurueckgestelltes Vorhaben weiterhin in
    ?action=next, waere es lediglich anders beschriftet.
    """
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'next'}, body={'limit': 5})
    erwarte_erfolg(r)
    ids = [i.get('id') for i in (r.feld('items', default=[]) or [])]

    # ?action=next uebernimmt, was es ausgibt. Wieder freigeben, sonst haelt
    # dieser Testfall fuenf Items bis zum Lease-Ende - und der naechste Lauf
    # oder ein Mensch an der Instanz wundert sich, wo die Arbeit hin ist.
    for i in ids:
        ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'release', 'id': i},
                        body={'note': 'Automatischer Testlauf.'})

    erwarte(ctx['freies_item'] not in ids,
            'Item #%s ist zurueckgestellt, wurde aber als Arbeit ausgegeben'
            % ctx['freies_item'])


@test('roadmap', 'Roadmap laesst sich lesen')
def _(ctx):
    for aktion in ('list', 'epics', 'next', 'active'):
        r = ctx.client.get('/api/bugtracker/v1/roadmap.php',
                           query={'action': aktion, 'project_slug': PROJEKT})
        erwarte_erfolg(r)


@test('roadmap', 'Roadmap laesst sich rendern')
def _(ctx):
    r = ctx.client.get('/api/bugtracker/v1/roadmap.php',
                       query={'action': 'render', 'project_slug': PROJEKT})
    erwarte_erfolg(r)


@test('roadmap', 'Werkbank-Token laesst sich anlegen')
def _(ctx):
    """
    Der Tokentyp, den MCP-Adapter und dc-testkit benutzen: dev_agent, an ein
    Projekt gebunden. Bis hierher benutzte ihn kein Testfall - und genau
    deshalb blieb der Fall darunter jahrelang ungeprueft.
    """
    r = ctx.testctl('workbench_token', project_slug=PROJEKT, name='e2e-werkbank')
    erwarte_erfolg(r)
    erwarte(r.feld('raw_token'), 'Kein Token in der Antwort: %s' % r.kurz(300))
    ctx['werkbank_token'] = r.feld('raw_token')


@test('roadmap', 'Werkbank-Token rendert seine Roadmap ohne Projektangabe')
def _(ctx):
    """
    BEFUND (29.08.2026): Beim Lesen laesst projectFilter() ein Werkbank-Token
    bewusst durch - es soll die ganze Landschaft sehen und liefert deshalb
    null. Damit wurde der Projektbezug zu "all", und action=render lehnte mit
    "missing_project" ab. Ausgerechnet der Tokentyp, den der MCP-Adapter
    verlangt, konnte seine eigene Roadmap nicht rendern.

    Das Token ist trotzdem an ein Projekt gebunden. "Meine Roadmap" ohne
    Angabe heisst genau dieses Projekt.
    """
    r = ctx.client.get('/api/bugtracker/v1/roadmap.php',
                       query={'action': 'render'},
                       token=ctx['werkbank_token'])
    erwarte_erfolg(r)
    erwarte(r.feld('project_slug') == PROJEKT,
            'Gerendert wurde %r statt des Heimatprojekts %r'
            % (r.feld('project_slug'), PROJEKT))
    erwarte('dc:roadmap' in (r.feld('markdown') or ''),
            'Im Ergebnis fehlt der Blockmarker: %s' % r.kurz(200))


@test('roadmap', 'Werkbank-Token bekommt die Projektliste mit Beziehungen')
def _(ctx):
    """
    BEFUND (29.08.2026): ProjectLinks::between() und forProject() benutzten
    denselben Platzhalter mehrfach im Statement. Bei
    ATTR_EMULATE_PREPARES = false ist das nicht zulaessig - PDO zaehlt
    Parameter, statt sie zu benennen, und wirft HY093.

    Die Abfrage laeuft nur, wenn ein Heimatprojekt gesetzt ist, also
    ausschliesslich mit einem Werkbank-Token. Fuer das Master-Token des
    Testlaufs wurde der Zweig uebersprungen - deshalb blieb ein sicherer
    500er unbemerkt, bis der MCP-Adapter die Ressource dc://projekte abrief.

    Derselbe Fehler steckte schon in der Volltextsuche des Bugtrackers. Beim
    dritten Mal ist es kein Zufall mehr, sondern eine Falle des Frameworks -
    ein Suchlauf ueber alle prepare()-Aufrufe gehoert zur Durchsicht.
    """
    r = ctx.client.get('/api/bugtracker/v1/projects', token=ctx['werkbank_token'])
    erwarte_erfolg(r)
    projekte = r.feld('projects', default=[]) or []
    erwarte(projekte, 'Leere Projektliste: %s' % r.kurz(300))

    eigen = [p for p in projekte if p.get('slug') == PROJEKT]
    erwarte(eigen, 'Das eigene Projekt %r fehlt in der Liste.' % PROJEKT)
    erwarte((eigen[0].get('relation') or {}).get('kind') == 'self',
            'Das eigene Projekt sollte relation.kind="self" tragen, hat aber %r'
            % eigen[0].get('relation'))


@test('roadmap', 'Werkbank-Token sieht weiterhin die ganze Landschaft')
def _(ctx):
    """
    Die Gegenprobe zum Fall darueber. Der Rueckfall aufs Heimatprojekt darf
    nur dort greifen, wo ein konkretes Projekt gebraucht wird - beim Lesen
    ueber alle Projekte hinweg waere er eine Einschraenkung, die es vorher
    nicht gab.
    """
    r = ctx.client.get('/api/bugtracker/v1/roadmap.php',
                       query={'action': 'list', 'project_slug': 'all'},
                       token=ctx['werkbank_token'])
    erwarte_erfolg(r)


# ---------------------------------------------------------------------------
# 2.8.1 - vier Befunde aus der Fremdmeldung
# ---------------------------------------------------------------------------
# Allen vier ist gemeinsam, dass sie nur mit einem PROJEKTGEBUNDENEN Token
# auftreten. Das Master-Token des Testlaufs ist an kein Projekt gebunden und
# nimmt deshalb ueberall den anderen Zweig - deswegen war die Suite gruen,
# waehrend drei Agenten dieselben Fehler von aussen meldeten.
#
# Marke "roadmap", obwohl es der Sache nach Bugtracker-Faelle sind: Sie
# brauchen ctx['werkbank_token'], und das entsteht weiter oben in dieser
# Gruppe. Mit der Marke "bugtracker" liefen sie im vollen Lauf zwar mit,
# wurden unter --gruppe bugtracker aber uebersprungen - eine Pruefung, die
# sich beim Nachsehen selbst wegfiltert, ist keine.

@test('roadmap', 'action=next laeuft mit einem projektgebundenen Token')
def _(ctx):
    """
    BEFUND #351: manage?action=next antwortete durchgaengig mit HTTP 500 -
    ueber MCP, curl und dc-testkit gleichermassen, mit und ohne Parameter.
    claim, release, list und stats liefen am selben Endpunkt mit demselben
    Token durch.

    Ursache war ein benannter Platzhalter, der zweimal in derselben Anweisung
    stand (:project_scope in BugRepo::buildFilter, Rueckkanal fuer
    Nachpruefungen). Mit ATTR_EMULATE_PREPARES = false bindet PDO jeden Namen
    genau einmal - zwei Marker, ein Wert, SQLSTATE[HY093].

    Warum die Suite das nicht sah: Der Zweig wird nur betreten, wenn das
    Token an ein Projekt gebunden ist. Der bestehende next-Testfall benutzt
    das ungebundene Master-Token und ging deshalb daran vorbei. Dieser hier
    nimmt ausdruecklich das Werkbank-Token.

    Geprueft wird nur, DASS es durchlaeuft. Ob Items zurueckkommen, haengt am
    Zustand der Testdatenbank und ist hier nicht die Frage.
    """
    r = ctx.client.post('/api/bugtracker/v1/manage',
                        query={'action': 'next'},
                        token=ctx['werkbank_token'],
                        body={'limit': 1})
    erwarte_erfolg(r)


@test('roadmap', 'Meldung ohne project_slug geht ins Heimatprojekt')
def _(ctx):
    """
    BEFUND #382/#387: Eine Meldung ohne project_slug landete im Projekt
    "default". Das ist kein Projekt - es hat keine dc_projects-Zeile, also
    blieb project_id NULL. Die Meldung war angelegt und quittiert, aber fuer
    denselben Melder danach unerreichbar: action=update antwortete 403
    project_forbidden, weil sein Token an sein eigenes Projekt gebunden ist.

    Der Server legte Items dort ab, wo der Melder sie nicht anfassen darf -
    und die Antwort sah wie ein Erfolg aus. Zwanzig Items sind so entstanden.

    Das Weglassen ist der dokumentierte Normalfall, deshalb steht dieser
    Testfall hier und nicht als Randfall.
    """
    r = ctx.client.post('/api/bugtracker/v1/report',
                        token=ctx['werkbank_token'],
                        body={
                            'title': 'e2e: Meldung ohne Projektangabe',
                            'description': 'Angelegt von tests/e2e. Darf geloescht werden.',
                            'severity': 'low',
                            'environment': 'testing',
                            'client_ref': 'e2e-ohne-slug-%d' % int(time.time()),
                        })
    erwarte_erfolg(r)

    erwarte(r.feld('project_slug') == PROJEKT,
            'Die Meldung ging nach %r statt ins Heimatprojekt %r'
            % (r.feld('project_slug'), PROJEKT))

    # Gegenprobe am Item selbst: Die Antwort koennte das Richtige sagen und
    # das Falsche getan haben.
    g = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'get', 'id': _item_id(r)},
                       token=ctx['werkbank_token'])
    erwarte_erfolg(g)
    erwarte(g.feld('item', 'project_slug') == PROJEKT,
            'Das Item liegt in %r statt in %r'
            % (g.feld('item', 'project_slug'), PROJEKT))


@test('roadmap', 'Meldung in ein unbekanntes Projekt wird abgewiesen')
def _(ctx):
    """
    Die zweite Haelfte desselben Befunds. Ein Tippfehler im project_slug wurde
    bis 2.8.0 klaglos angenommen und erzeugte dieselbe Sorte Waise wie
    "default" - nur unter anderem Namen. Wer nicht weiss, wohin eine Meldung
    gehoert, soll das erfahren statt geraten zu bekommen.
    """
    r = ctx.client.post('/api/bugtracker/v1/report',
                        token=ctx['werkbank_token'],
                        body={
                            'project_slug': 'gibt-es-nicht-e2e',
                            'title': 'e2e: Meldung in ein erfundenes Projekt',
                            'evidence': 'Erwartet wird eine Absage, kein Item. '
                                        'Dieser Text erfuellt die Begruendungspflicht.',
                            'environment': 'testing',
                        })
    erwarte_fehler(r, http=400, code='unknown_project')


@test('roadmap', 'Liste ohne project_slug bleibt im eigenen Projekt')
def _(ctx):
    """
    BEFUND #364 (und #176, dieselbe Sache): Ohne project_slug lieferten
    manage?action=list, dc_search und dc_roadmap die Eintraege ALLER Projekte.
    Die Werkzeugbeschreibung sagte das Gegenteil ("Ohne project_slug das
    eigene Projekt"), was den Widerspruch lange verdeckt hat.

    Grund war eine Voreinstellung auf 'all': Ein Werkbank-Token faellt beim
    Lesen absichtlich nicht unter die Projektschranke - es soll die Landschaft
    sehen duerfen. Damit war der Zwangsfilter leer und die Vorgabe griff.

    Das wiegt schwer, weil CLAUDE.md dc_roadmap zum ersten Aufruf jeder
    Sitzung macht: Der Agent bekam einen fremden Backlog vorgelegt, den er
    nach derselben Regel nicht bearbeiten darf.
    """
    r = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'list', 'limit': 100},
                       token=ctx['werkbank_token'])
    erwarte_erfolg(r)

    erwarte(r.feld('filters', 'project_slug') == PROJEKT,
            'Gefiltert wurde auf %r statt auf das Heimatprojekt %r'
            % (r.feld('filters', 'project_slug'), PROJEKT))

    fremd = sorted({i.get('project_slug')
                    for i in (r.feld('items', default=[]) or [])
                    if i.get('project_slug') != PROJEKT})
    erwarte(not fremd, 'Fremde Projekte in der Antwort: %s' % fremd)


@test('roadmap', 'Verengter Leseweg sagt, dass er verengt hat')
def _(ctx):
    """
    BEFUND #131: Ein an Projekt X gebundenes Token, das nach Projekt Y fragt,
    bekam beim SCHREIBEN eine klare Absage (403 project_forbidden) und beim
    LESEN HTTP 200 - mit den Items von X und einem Umschlag, in dem
    filters.project_slug bereits auf X umgeschrieben war. Die Antwort sah aus
    wie eine gueltige Auskunft ueber Y.

    Das ist keine Spitzfindigkeit: Die Prompt-Vorlage schickt jeden Agenten
    vor jeder Meldung durch dc_search ("gibt es das schon?"). Auf "gibt es das
    im Deploymentcenter schon?" kam eine leere, plausible Antwort - und das
    Duplikat wurde angelegt. Einem Melder ist genau das beinahe passiert;
    tatsaechlich waren es 71 Items.

    Die Schranke bleibt, wo sie ist. Sie sagt jetzt nur, dass sie zugegangen
    ist.

    Es braucht ein gebundenes NICHT-Werkbank-Token: Ein dev_agent faellt beim
    Lesen absichtlich nicht unter die Schranke und wird deshalb nie verengt.
    """
    r = ctx.testctl('workbench_token', project_slug=PROJEKT,
                    name='e2e-laufzeit', owner_type='project',
                    scopes=['bugtracker:read'])
    erwarte_erfolg(r)
    token = r.feld('raw_token')
    erwarte(token, 'Kein Token in der Antwort: %s' % r.kurz(300))

    r = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'list', 'project_slug': 'deploymentcenter',
                              'limit': 5},
                       token=token)
    erwarte_erfolg(r)

    erwarte(r.feld('filters', 'project_slug') == PROJEKT,
            'Die Verengung selbst fehlt: gefiltert wurde auf %r'
            % r.feld('filters', 'project_slug'))
    erwarte(r.feld('scoped_to') == PROJEKT,
            'scoped_to fehlt oder ist falsch: %r' % r.feld('scoped_to'))
    erwarte('deploymentcenter' in (r.feld('scope_note') or ''),
            'scope_note nennt das angefragte Projekt nicht: %r' % r.feld('scope_note'))


@test('roadmap', 'Ohne Verengung steht kein Hinweis im Umschlag')
def _(ctx):
    """
    Gegenprobe. Der Hinweis darf nur auftauchen, wenn wirklich etwas anderes
    geliefert wurde als gefragt - sonst ist er Rauschen und wird ignoriert,
    gerade dann, wenn er einmal zaehlt.
    """
    r = ctx.client.get('/api/bugtracker/v1/manage',
                       query={'action': 'list', 'project_slug': PROJEKT, 'limit': 5},
                       token=ctx['werkbank_token'])
    erwarte_erfolg(r)
    erwarte(r.feld('scoped_to') is None,
            'scoped_to steht im Umschlag, obwohl nichts verengt wurde: %r'
            % r.feld('scoped_to'))


@test('roadmap', 'Roadmap antwortet standardmaessig schmal')
def _(ctx):
    """
    BEFUND #364, zweiter Teil: Die Roadmap lieferte je Eintrag den vollen
    Datensatz mit rund fuenfzig Feldern - fuer 57 Eintraege etwa 137.000
    Zeichen. Ausgerechnet der erste Aufruf einer Sitzung fuellte damit das
    Kontextfenster, bevor die Arbeit begann.

    Geprueft wird die Zusage, nicht die Zeichenzahl: compact liefert die
    Uebersichtsfelder, fields=full weiterhin alles.
    """
    schmal = ctx.client.get('/api/bugtracker/v1/roadmap.php',
                            query={'action': 'list', 'limit': 5},
                            token=ctx['werkbank_token'])
    erwarte_erfolg(schmal)
    erwarte(schmal.feld('fields') == 'compact',
            'Vorgabe ist %r statt "compact"' % schmal.feld('fields'))

    voll = ctx.client.get('/api/bugtracker/v1/roadmap.php',
                          query={'action': 'list', 'limit': 5, 'fields': 'full'},
                          token=ctx['werkbank_token'])
    erwarte_erfolg(voll)

    s_items = _liste(schmal, 'items')
    v_items = _liste(voll, 'items')

    if not s_items or not v_items:
        ueberspringen('Keine Roadmap-Eintraege in %s vorhanden.' % PROJEKT)

    erwarte(len(s_items[0]) < len(v_items[0]),
            'Die schmale Sicht hat %d Felder, die volle %d - sie sollte weniger haben.'
            % (len(s_items[0]), len(v_items[0])))
    erwarte('title' in s_items[0] and 'id' in s_items[0],
            'In der schmalen Sicht fehlen Titel oder ID: %s' % sorted(s_items[0]))
    erwarte('stack_trace' not in s_items[0],
            'Die schmale Sicht traegt weiterhin stack_trace mit.')


@test('roadmap', 'Abgleich uebersieht eine Markererwaehnung im Fliesstext')
def _(ctx):
    """
    BEFUND (29.08.2026): spliceBlock() und check() suchten den erzeugten Block
    mit strpos() auf den Startmarker - also die erste Fundstelle im Text.

    Das ging gut, bis eine Datei den Marker ERWAEHNTE. Die Einleitung einer
    ordentlichen Roadmap tut genau das: sie erklaert, was zwischen den
    dc:roadmap-Markern steht. Der Splice setzte dort an und ueberschrieb den
    halben Dateikopf; der Abgleich klammerte Prosa aus statt des Blocks.

    Bitter daran ist, dass es ausgerechnet die Dateien trifft, die das
    Verfahren beschreiben - also die guten.

    Geprueft wird mit einer Datei, die den Marker erst erwaehnt und dann
    wirklich fuehrt: Ein Verweis VOR der Erwaehnung muss in der Pruefung
    ankommen, ein Verweis INNERHALB des Blocks nicht.
    """
    inhalt = (
        '# Roadmap\n\n'
        'Zwischen den `<!-- dc:roadmap -->`-Markern steht eine erzeugte Kopie.\n\n'
        'Siehe #%d fuer den Rest.\n\n'
        '<!-- dc:roadmap stand=2020-01-01T00:00Z items=1 projekt=%s -->\n'
        '| #999999 | erzeugt, wird nicht geprueft |\n'
        '<!-- /dc:roadmap -->\n'
    ) % (ctx['freies_item'], PROJEKT)

    r = ctx.client.post('/api/bugtracker/v1/roadmap.php',
                        query={'action': 'check'},
                        body={'project_slug': PROJEKT, 'content': inhalt})
    erwarte_erfolg(r)

    codes = [f['code'] for f in (r.feld('findings', default=[]) or [])]
    erwarte('unknown_item' not in codes,
            'Der erzeugte Block wurde mitgeprueft - die Markererwaehnung in der '
            'Einleitung hat den Blockanfang bestimmt. Befunde: %s' % codes)
    erwarte(r.feld('checked') >= 1,
            'Der Verweis vor dem Block wurde nicht geprueft (checked=%s) - es '
            'wurde zu viel ausgeklammert.' % r.feld('checked'))


@test('roadmap', 'Roadmap-Schreibzugriff verlangt Verwaltungsrecht')
def _(ctx):
    r = ctx.client.post('/api/bugtracker/v1/roadmap.php',
                        query={'action': 'set', 'id': ctx['freies_item']},
                        token=ctx['sub_token'],
                        body={'project_slug': PROJEKT, 'epic': 'e2e-epic'})
    erwarte_fehler(r, http=(401, 403))


# ---------------------------------------------------------------------------
# Fehlerstrom
# ---------------------------------------------------------------------------

@test('fehlerstrom', 'Ausnahme laesst sich melden')
def _(ctx):
    r = ctx.client.post('/api/errors/v1/report', body={
        'project_slug': PROJEKT,
        'exception': 'System.NullReferenceException',
        'message': 'Automatischer Testlauf: Beispielausnahme',
        'stack_trace': 'at Test.Method() in Test.cs:line 1',
        'level': 'error',
        'build': BUILD,
        'environment': 'testing',
        'file': 'Test.cs',
        'line': 1,
        'client_ref': 'e2e-error-%d' % int(time.time()),
    })
    erwarte_erfolg(r)


@test('fehlerstrom', 'Meldung ohne Token abgewiesen')
def _(ctx):
    r = ctx.client.post('/api/errors/v1/report', token=None,
                        body={'project_slug': PROJEKT, 'message': 'ohne Token'})
    erwarte_fehler(r, http=401)