Deploymentcenter BotandClaude Opus 5
0e93345ab8
Drei Agenten haben von aussen gemeldet, und fast jeder Befund hat dieselbe Form: Irgendwo sprang ein Vorgabewert ein, obwohl die richtige Antwort bekannt war - meist das Projekt, an das der Aufrufer ohnehin gebunden ist. #351 manage?action=next antwortete durchgaengig mit HTTP 500. In BugRepo::buildFilter() stand :project_scope zweimal in derselben Anweisung; mit ATTR_EMULATE_PREPARES=false bindet PDO jeden Namen genau einmal - zwei Marker, ein Wert, SQLSTATE[HY093]. Getroffen war nur "next", weil nur dort der Rueckkanal-Filter gesetzt wird. Damit gab es keine exklusive Uebernahme. Es ist der VIERTE Fall dieser Bauart, deshalb prueft scripts/pruefe_platzhalter.py das jetzt mechanisch vor jedem Ausliefern. #382 Meldungen ohne project_slug landeten im Scheinprojekt "default" - #387 ohne dc_projects-Zeile, also project_id NULL. Die Antwort sah wie ein #397 Erfolg aus, und danach sperrte dieselbe Token-Bindung den Zugriff (403 project_forbidden). Der Rueckfall aufs Heimatprojekt war an !isWorkbench gebunden; ein Werkbank-Token ohne Slug bekam gar keinen Vorgabewert. Jetzt: genannter Slug, sonst Heimatprojekt, sonst 400. Ein unbekanntes Projekt wird abgewiesen statt still angelegt. #364 Ohne project_slug lieferten list, stats und die Roadmap ALLE #176 Projekte statt des eigenen, weil die Vorgabe auf "all" stand und ein Werkbank-Token beim Lesen absichtlich nicht unter die Schranke faellt. Gemessen: 393 Items, davon 28 eigene. Ausgerechnet der erste Aufruf jeder Sitzung. Die Roadmap antwortet ausserdem schmal - 55 Felder je Eintrag waren 628.392 Zeichen und fuellten das Kontextfenster. #404 Watchdog-Monitore bekamen nie ein Projekt: upsertHeartbeat() wurde keines uebergeben, obwohl authorizeSource() die Token-Bindung liest. Befunde erbten dadurch "default" - dc_findings(project_slug=...) war fuer eine laufende, meldende Instanz leer. #131 Wo der Leseweg richtig verengte, sagte er es nicht: HTTP 200 mit dem umgeschriebenen Filter sieht aus wie eine Auskunft ueber das angefragte Projekt. Ein Agent, der vor dem Melden dc_search fragt, legt so das Duplikat an. Jetzt scoped_to und scope_note im Umschlag - nur bei tatsaechlicher Verengung. #354 dc-testkit 1.1.0 wurde zweimal mit verschiedenem Inhalt ausgeliefert (1898 und 1930 Zeilen), 1.0.0 davor ebenso. Der Absatz ueber DC_TESTKIT_VERSION stand die ganze Zeit im Skript und hat nicht getragen. Jetzt 1.1.1 plus ein Riegel in deploy.py, der abbricht, wenn sich der Inhalt aendert und die Nummer nicht. Warum die Testsuite all das nicht sah: Ihr Master-Token ist an kein Projekt gebunden und nimmt deshalb ueberall den anderen Zweig. Es gab sogar einen Testfall fuer action=next - er lief gruen, waehrend der Aufruf in der Praxis ausnahmslos scheiterte. Die neuen Faelle benutzen ausdruecklich projektgebundene Token; testctl kann dafuer jetzt owner_type und scopes waehlen. Ausserdem: Die Agentenvorlage nennt fuer die SDK-Fassung dc_link_project statt einer abgeschriebenen Zahl - "SDK 2.5.1" stand dort als Beispiel und wurde als Wert uebernommen. Nicht enthalten: die 20 Altlasten in "default". Sie sind ueber die API nicht erreichbar; sql/wartung/2026-08-31_default-projekt-aufraeumen.sql liegt dafuer bereit (alle 20 haben einen titelgleichen Zwilling im richtigen Projekt). 156 e2e-Faelle gruen, davon 9 neue. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
960 lines
40 KiB
Python
960 lines
40 KiB
Python
#!/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)
|