knso/Webklar-Kundenbereich
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
cb6291410d051bb8a61ef542f4297b919cedbce8
Webklar-Kundenbereich/test/shopJobs.test.js
T
ClaudeandClaude Opus 5.5 cb6291410d Shop Review A I4: Shop-Limit 300 je Stunde, hoechstens 3 offene Bestellungen je IP und Shop in 30 Minuten 
Die IP wird nur als gesalzener Kurz-Hash (sha256, 16 Hex-Zeichen) im Bestell-JSON abgelegt; der Tagesjob entfernt ihn bei der Anonymisierung mit. Die Pruefung laeuft unter der Bestandssperre, Honigtopf und Fehlversuche legen nichts an und zaehlen nicht. Antwort 429 zu_viele_offen mit Retry-After 1800.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 09:34:03 +00:00

454 lines
24 KiB
JavaScript
Raw Blame History

import { test, after, beforeEach } from 'node:test'
import assert from 'node:assert/strict'
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import { startAppwriteMock } from './support/appwriteMock.js'
import { schemaKeys } from './support/schema.js'
import { useTestEnv } from './support/testEnv.js'
import { SHOP_DATETIMES } from '../server/services/shop/schema.js'
// Webshop J3: Tagesjob (Anonymisieren, Unbezahltes loeschen, abgeschaltete Shops loeschen), Stundenjob, Kundenloeschung, Registrierung.
// Alles gegen den Appwrite-Nachbau und einen temporaeren Upload-Ordner; die Uhr ist immer ein fester Zeitpunkt.
const aw = await startAppwriteMock({
schema: {
portalFeatures: schemaKeys('portalFeatures'),
shopConfig: schemaKeys('shopConfig'),
shopProducts: schemaKeys('shopProducts'),
shopOrders: schemaKeys('shopOrders'),
shopWiderrufe: schemaKeys('shopWiderrufe'),
},
datetimes: SHOP_DATETIMES,
defaultLimit: 25,
})
const uploadDir = mkdtempSync(path.join(os.tmpdir(), 'shop-jobs-'))
process.env.SHOP_UPLOAD_DIR = uploadDir
after(() => {
rmSync(uploadDir, { recursive: true, force: true })
return aw.close()
})
useTestEnv({ appwriteUrl: aw.url, stripeUrl: 'http://127.0.0.1:1' })
const { config } = await import('../server/config.js')
const { deleteDocument, getDocument } = await import('../server/services/appwriteAdmin.js')
const { taeglicherJob, stuendlicherJob, minutenJob, anonymisierGrenze } = await import('../server/services/shop/jobs.js')
const { deleteCustomerWithPortalAccess } = await import('../server/services/customerAdmin.js')
const sf = await import('../server/services/siteFeatures.js')
const KEY = 'abcdefghijklmnop'
const KEY2 = 'bcdefghijklmnopq'
const TAG = 24 * 3600 * 1000
const JETZT = new Date('2026-10-05T10:00:00.000Z')
const vor = (tage, von = JETZT) => new Date(von.getTime() - tage * TAG).toISOString()
let n = 0
const id = (prefix) => `${prefix}${++n}`
const shop = (shopId, over = {}) => aw.seed('shopConfig', { $id: shopId, customerId: 'cs1', projectId: 'p1', siteKey: KEY, geoeffnet: true, ...over })
const feature = (shopId, over = {}) =>
aw.seed('portalFeatures', { $id: shopId, customerId: 'cs1', projectId: 'p1', featureKey: 'shop', siteKey: KEY, state: 'active', enabled: true, ...over })
const PERSON = {
kaeufer: { name: 'Max Mustermann', email: 'max@example.com', telefon: '0123' },
lieferadresse: { line1: 'Hauptstr. 1', postal_code: '67722', city: 'Winnweiler', country: 'DE' },
rechnungsadresse: { line1: 'Hauptstr. 1', postal_code: '67722', city: 'Winnweiler', country: 'DE' },
}
const bestellung = (shopId, over = {}, daten = {}) => {
const doc = {
$id: id('o'),
shopId,
customerId: 'cs1',
bestellnummer: '26-ABC123',
status: 'versendet',
summeCent: 2500,
erstelltAt: vor(10),
bezahltAt: vor(10),
kaeuferEmail: 'max@example.com',
bestellung: JSON.stringify({ positionen: [{ produktId: 'a', name: 'Tasse', menge: 2, einzelCent: 1000 }], summen: { gesamtCent: 2500 }, ...PERSON, ...daten }),
...over,
}
aw.seed('shopOrders', doc)
return doc.$id
}
const widerruf = (shopId, over = {}) => {
const doc = { $id: id('w'), shopId, bestellnummer: '26-ABC123', name: 'Max Mustermann', email: 'max@example.com', nachricht: 'Ich widerrufe.', eingangAt: vor(10), ...over }
aw.seed('shopWiderrufe', doc)
return doc.$id
}
const produkt = (shopId) => {
const doc = { $id: id('pr'), shopId, customerId: 'cs1', aktiv: true, sort: 1, name: 'Tasse', produkt: '{}' }
aw.seed('shopProducts', doc)
return doc.$id
}
const bild = (siteKey, bildId = id('img')) => {
const ordner = path.join(uploadDir, siteKey)
mkdirSync(ordner, { recursive: true })
writeFileSync(path.join(ordner, `${bildId}-l.webp`), 'x')
writeFileSync(path.join(ordner, `${bildId}-s.webp`), 'x')
writeFileSync(path.join(ordner, `${bildId}.json`), JSON.stringify({ claimed: true, createdAt: vor(400) }))
return bildId
}
const order = (orderId) => aw.docs('shopOrders').get(orderId)
const daten = (orderId) => JSON.parse(order(orderId).bestellung)
beforeEach(async () => {
for (const name of ['shopConfig', 'shopProducts', 'shopOrders', 'shopWiderrufe', 'portalFeatures']) {
for (const docId of aw.docs(name).keys()) await deleteDocument(config.collections[name], docId)
}
rmSync(uploadDir, { recursive: true, force: true })
mkdirSync(uploadDir, { recursive: true })
config.shop.mode = 'on'
config.shop.loeschDeckel = undefined
})
// ------------------------------------------------------------------------------------------------ Anonymisieren
test('anonymisierGrenze: 1. Januar Berlin, drei Jahre nach Ende des Bestelljahres', () => {
// Bestelljahr 2026 -> Ende 31.12.2026 -> +3 Jahre = 01.01.2030 (Berlin)
assert.equal(anonymisierGrenze(new Date('2029-12-31T22:59:59.999Z')).toISOString(), '2025-12-31T23:00:00.000Z', 'noch 2029 in Berlin: Grenze = 01.01.2026 (Bestelljahr 2026 ist noch nicht dran)')
assert.equal(anonymisierGrenze(new Date('2029-12-31T23:00:00.000Z')).toISOString(), '2026-12-31T23:00:00.000Z', 'ab 01.01.2030 00:00 Berlin: Grenze = 01.01.2027 (Bestelljahr 2026 ist dran)')
})
test('Bestellung aus 2026 wird genau am 1. Januar 2030 (Berlin) anonymisiert, nicht eine Sekunde vorher', async () => {
shop('s_a')
const o = bestellung('s_a', { erstelltAt: '2026-06-01T10:00:00.000Z' }, { ipHash: 'abcdef0123456789' })
const vorher = await taeglicherJob(new Date('2029-12-31T22:59:59.000Z')) // 23:59:59 Berlin
assert.equal(vorher.bestellungenAnonymisiert, 0)
assert.equal(order(o).anonymisiertAt, undefined)
assert.equal(order(o).kaeuferEmail, 'max@example.com')
const nachher = await taeglicherJob(new Date('2029-12-31T23:00:00.000Z')) // 00:00 Berlin, 1.1.2030
assert.equal(nachher.bestellungenAnonymisiert, 1)
assert.equal(nachher.fehler, 0)
const doc = order(o)
assert.equal(doc.kaeuferEmail, '')
assert.ok(doc.anonymisiertAt)
const d = daten(o)
assert.equal(d.ipHash, undefined, 'der IP-Hash wird mit anonymisiert')
assert.deepEqual(d.kaeufer, { name: '', email: '', telefon: '' })
assert.equal('lieferadresse' in d, false)
assert.equal('rechnungsadresse' in d, false)
assert.equal(d.positionen[0].name, 'Tasse', 'Positionen bleiben')
assert.equal(d.summen.gesamtCent, 2500, 'Betraege bleiben')
assert.equal(doc.bestellnummer, '26-ABC123')
assert.equal(doc.status, 'versendet')
assert.equal(doc.summeCent, 2500)
assert.ok(!JSON.stringify(doc).includes('Mustermann'))
})
test('Silvester-Nacht: eine Bestellung vom 31.12.2026 23:30 UTC gehoert in Berlin zu 2027 und folgt erst 2031', async () => {
shop('s_b')
const o = bestellung('s_b', { erstelltAt: '2026-12-31T23:30:00.000Z' })
await taeglicherJob(new Date('2030-06-01T10:00:00.000Z'))
assert.equal(order(o).anonymisiertAt, undefined, '2027 ist 2030 noch nicht dran')
await taeglicherJob(new Date('2031-01-01T10:00:00.000Z'))
assert.ok(order(o).anonymisiertAt)
})
test('Anonymisierung ist idempotent und fasst andere Shops und junge Bestellungen nicht an', async () => {
shop('s_c')
shop('s_d', { siteKey: KEY2 })
const alt = bestellung('s_c', { erstelltAt: '2020-03-01T10:00:00.000Z' })
const jung = bestellung('s_c', { erstelltAt: '2026-03-01T10:00:00.000Z' })
const erste = await taeglicherJob(JETZT)
assert.equal(erste.bestellungenAnonymisiert, 1)
const stand = order(alt).anonymisiertAt
const zweite = await taeglicherJob(new Date(JETZT.getTime() + TAG))
assert.equal(zweite.bestellungenAnonymisiert, 0)
assert.equal(order(alt).anonymisiertAt, stand)
assert.equal(order(jung).kaeuferEmail, 'max@example.com')
assert.equal(daten(jung).kaeufer.name, 'Max Mustermann')
})
test('Widerrufe: Name, E-Mail und Nachricht werden nach derselben Frist (eingangAt) geleert, die Bestellnummer bleibt', async () => {
shop('s_e')
const alt = widerruf('s_e', { eingangAt: '2026-02-01T10:00:00.000Z' })
const jung = widerruf('s_e', { eingangAt: '2027-02-01T10:00:00.000Z' })
assert.equal((await taeglicherJob(new Date('2029-12-31T22:59:59.000Z'))).widerrufeAnonymisiert, 0)
const erg = await taeglicherJob(new Date('2030-01-01T10:00:00.000Z'))
assert.equal(erg.widerrufeAnonymisiert, 1)
const a = aw.docs('shopWiderrufe').get(alt)
assert.deepEqual([a.name, a.email, a.nachricht, a.bestellnummer], ['', '', '', '26-ABC123'])
assert.equal(aw.docs('shopWiderrufe').get(jung).email, 'max@example.com')
assert.equal((await taeglicherJob(new Date('2030-01-02T10:00:00.000Z'))).widerrufeAnonymisiert, 0, 'idempotent')
})
// ------------------------------------------------------------------------------------------------ Unbezahltes
test('unbezahlte Bestellungen: storniert und alte offene nach 30 Tagen weg; bezahlte, junge und solche mit bezahltAt bleiben', async () => {
shop('s_f')
const storniertAlt = bestellung('s_f', { status: 'storniert', erstelltAt: vor(31), bezahltAt: null })
const storniertJung = bestellung('s_f', { status: 'storniert', erstelltAt: vor(29), bezahltAt: null })
const offenAlt = bestellung('s_f', { status: 'offen', erstelltAt: vor(40), bezahltAt: null })
const offenJung = bestellung('s_f', { status: 'offen', erstelltAt: vor(2), bezahltAt: null })
const bezahltAlt = bestellung('s_f', { status: 'versendet', erstelltAt: vor(100) })
const stornoMitZahlung = bestellung('s_f', { status: 'storniert', erstelltAt: vor(100), bezahltAt: vor(100) })
const erg = await taeglicherJob(JETZT)
assert.equal(erg.unbezahltGeloescht, 2)
assert.equal(erg.fehler, 0)
for (const weg of [storniertAlt, offenAlt]) assert.equal(aw.docs('shopOrders').has(weg), false)
for (const da of [storniertJung, offenJung, bezahltAlt, stornoMitZahlung]) assert.equal(aw.docs('shopOrders').has(da), true)
assert.equal((await taeglicherJob(JETZT)).unbezahltGeloescht, 0)
})
// ------------------------------------------------------------------------------------------------ Abgeschaltete Shops
test('Shop seit 91 Tagen disabled: Artikel, Bestellungen, Widerrufe, Bilder und shopConfig weg; Funktionsdokument bleibt disabled mit Vermerk', async () => {
shop('s_g')
feature('s_g', { state: 'disabled', enabled: false, disabledAt: vor(91), disabledReason: 'team', adminNote: 'war aus' })
const p = produkt('s_g')
const o = bestellung('s_g')
const w = widerruf('s_g')
const b = bild(KEY)
// anderer Shop: aktiv, und einer erst 30 Tage disabled: bleiben unberuehrt
shop('s_h', { siteKey: KEY2 })
feature('s_h', { siteKey: KEY2, projectId: 'p2' })
const o2 = bestellung('s_h')
const bild2 = bild(KEY2)
shop('s_i', { siteKey: 'cdefghijklmnopqr' })
feature('s_i', { siteKey: 'cdefghijklmnopqr', projectId: 'p3', state: 'disabled', disabledAt: vor(30) })
const o3 = bestellung('s_i')
const erg = await taeglicherJob(JETZT)
assert.equal(erg.shopsGeloescht, 1)
assert.equal(erg.shopDokumenteGeloescht, 3)
assert.equal(erg.fehler, 0)
assert.equal(aw.docs('shopProducts').has(p), false)
assert.equal(aw.docs('shopOrders').has(o), false)
assert.equal(aw.docs('shopWiderrufe').has(w), false)
assert.equal(aw.docs('shopConfig').has('s_g'), false)
assert.equal(existsSync(path.join(uploadDir, KEY)), false)
assert.equal(existsSync(path.join(uploadDir, KEY, `${b}-l.webp`)), false)
const f = aw.docs('portalFeatures').get('s_g')
assert.equal(f.state, 'disabled')
assert.equal(f.adminNote, 'Shopdaten gelöscht am 2026-10-05')
assert.ok(f.adminNote.length <= 300)
assert.equal(aw.docs('shopOrders').has(o2), true)
assert.equal(aw.docs('shopConfig').has('s_h'), true)
assert.equal(existsSync(path.join(uploadDir, KEY2, `${bild2}-l.webp`)), true)
assert.equal(aw.docs('shopOrders').has(o3), true, '30 Tage reichen nicht')
assert.equal(aw.docs('shopConfig').has('s_i'), true)
// zweiter Lauf: nichts mehr zu tun, der Vermerk haelt ihn kurz
aw.resetListCalls()
const nochmal = await taeglicherJob(new Date(JETZT.getTime() + TAG))
assert.equal(nochmal.shopsGeloescht, 0)
assert.equal(aw.listCalls('shopProducts').length, 0)
})
test('Shop ohne siteKey-Bilder und ohne Dokumente: shopConfig wird trotzdem entfernt; wieder eingeschaltete Shops bleiben', async () => {
shop('s_j')
feature('s_j', { state: 'disabled', disabledAt: vor(100) })
shop('s_k', { siteKey: KEY2 })
feature('s_k', { siteKey: KEY2, state: 'active', disabledAt: null })
const o = bestellung('s_k')
const erg = await taeglicherJob(JETZT)
assert.equal(erg.shopsGeloescht, 1)
assert.equal(aw.docs('shopConfig').has('s_j'), false)
assert.equal(aw.docs('shopOrders').has(o), true)
})
test('Deckel: je Lauf hoechstens config.shop.loeschDeckel Loeschungen, der Rest folgt an den naechsten Tagen', async () => {
config.shop.loeschDeckel = 3
shop('s_l')
feature('s_l', { state: 'disabled', disabledAt: vor(120) })
const ids = { o: [], w: [], p: [] }
for (let i = 0; i < 4; i++) ids.o.push(bestellung('s_l'))
for (let i = 0; i < 2; i++) ids.w.push(widerruf('s_l'))
ids.p.push(produkt('s_l'))
bild(KEY)
const gesamt = () => aw.docs('shopOrders').size + aw.docs('shopWiderrufe').size + aw.docs('shopProducts').size
assert.equal(gesamt(), 7)
const tag1 = await taeglicherJob(JETZT)
assert.equal(tag1.gedeckelt, true)
assert.equal(tag1.shopsGeloescht, 0)
assert.equal(gesamt(), 4)
assert.equal(aw.docs('shopConfig').has('s_l'), true, 'shopConfig bleibt, bis alles weg ist')
assert.equal(existsSync(path.join(uploadDir, KEY)), true, 'Bilder auch')
const tag2 = await taeglicherJob(new Date(JETZT.getTime() + TAG))
assert.equal(gesamt(), 1)
assert.equal(tag2.shopsGeloescht, 0)
const tag3 = await taeglicherJob(new Date(JETZT.getTime() + 2 * TAG))
assert.equal(gesamt(), 0)
assert.equal(tag3.shopsGeloescht, 1)
assert.equal(aw.docs('shopConfig').has('s_l'), false)
assert.equal(existsSync(path.join(uploadDir, KEY)), false)
assert.equal(tag3.gedeckelt, false)
})
test('Deckel gilt auch fuer unbezahlte und anonymisierte Bestellungen', async () => {
config.shop.loeschDeckel = 2
shop('s_m')
for (let i = 0; i < 5; i++) bestellung('s_m', { status: 'storniert', erstelltAt: vor(60), bezahltAt: null })
for (let i = 0; i < 3; i++) bestellung('s_m', { erstelltAt: '2020-01-01T10:00:00.000Z' })
const tag1 = await taeglicherJob(JETZT)
assert.equal(tag1.unbezahltGeloescht, 2)
assert.equal(tag1.bestellungenAnonymisiert, 2)
assert.equal(tag1.gedeckelt, true)
let t = 1
let letzte = tag1
while (letzte.gedeckelt && t < 10) letzte = await taeglicherJob(new Date(JETZT.getTime() + t++ * TAG))
assert.equal([...aw.docs('shopOrders').values()].filter((d) => d.status === 'storniert').length, 0)
assert.equal([...aw.docs('shopOrders').values()].filter((d) => !d.anonymisiertAt).length, 0)
})
// ------------------------------------------------------------------------------------------------ Schalter, Fehler
test('SHOP_ENABLED=off ohne Shop-Dokumente: der Tagesjob kehrt nach einer Abfrage zurueck; mit Shop-Dokumenten laeuft er (Fristen gelten weiter)', async () => {
config.shop.mode = 'off'
aw.resetListCalls()
assert.deepEqual(await taeglicherJob(JETZT), { aus: true })
assert.equal(aw.listCalls().length, 1, 'genau eine Abfrage')
assert.equal(aw.listCalls()[0].collection, 'shopConfig')
assert.deepEqual(await stuendlicherJob(JETZT), { aus: true })
assert.deepEqual(await minutenJob(JETZT), { aus: true })
shop('s_n')
const o = bestellung('s_n', { status: 'storniert', erstelltAt: vor(60), bezahltAt: null })
const erg = await taeglicherJob(JETZT)
assert.equal(erg.unbezahltGeloescht, 1)
assert.equal(aw.docs('shopOrders').has(o), false)
})
test('Fehler sind je Schritt und je Dokument abgesichert: ein kaputter Widerruf stoppt weder Bestellungen noch andere Shops', async (t) => {
const warn = t.mock.method(console, 'warn', () => {})
shop('s_o')
shop('s_p', { siteKey: KEY2 })
const w1 = widerruf('s_o', { eingangAt: '2020-01-01T10:00:00.000Z' })
const w2 = widerruf('s_o', { eingangAt: '2020-01-02T10:00:00.000Z' })
const o = bestellung('s_o', { erstelltAt: '2020-01-01T10:00:00.000Z' })
const w3 = widerruf('s_p', { eingangAt: '2020-01-01T10:00:00.000Z' })
aw.failNext({ collection: 'shopWiderrufe', method: 'PATCH', status: 500, message: 'Fehler fuer max@example.com' })
const erg = await taeglicherJob(JETZT)
assert.equal(erg.fehler, 1)
assert.equal(erg.widerrufeAnonymisiert, 2)
assert.ok(order(o).anonymisiertAt)
const geleert = [w1, w2, w3].filter((x) => !aw.docs('shopWiderrufe').get(x).email)
assert.equal(geleert.length, 2)
const logs = warn.mock.calls.map((c) => String(c.arguments[0])).join('\n')
assert.match(logs, /taeglicherJob: shopWiderrufe .* fehlgeschlagen/)
assert.ok(!logs.includes('Mustermann'), 'keine Kaeuferdaten im Log')
// der naechste Lauf holt das kaputte Dokument nach
assert.equal((await taeglicherJob(new Date(JETZT.getTime() + TAG))).widerrufeAnonymisiert, 1)
})
test('Fehler beim Loeschen eines Shops stoppt die anderen nicht und laesst den Vermerk weg', async (t) => {
t.mock.method(console, 'warn', () => {})
shop('s_q')
feature('s_q', { state: 'disabled', disabledAt: vor(100) })
bestellung('s_q')
shop('s_r', { siteKey: KEY2 })
feature('s_r', { siteKey: KEY2, projectId: 'p2', state: 'disabled', disabledAt: vor(100) })
bestellung('s_r')
aw.failNext({ collection: 'shopOrders', method: 'DELETE', status: 500, message: 'kaputt' })
const erg = await taeglicherJob(JETZT)
assert.equal(erg.fehler, 1)
assert.equal(erg.shopsGeloescht, 1)
const offen = ['s_q', 's_r'].filter((x) => aw.docs('shopConfig').has(x))
assert.equal(offen.length, 1)
assert.equal(aw.docs('portalFeatures').get(offen[0]).adminNote, undefined, 'kein Vermerk ohne vollstaendige Loeschung')
assert.equal((await taeglicherJob(new Date(JETZT.getTime() + TAG))).shopsGeloescht, 1)
assert.equal(aw.docs('shopConfig').size, 0)
})
test('ein Lesefehler beim Auflisten der Shops stoppt die Loeschung abgeschalteter Shops nicht', async (t) => {
t.mock.method(console, 'warn', () => {})
shop('s_s')
feature('s_s', { state: 'disabled', disabledAt: vor(100) })
aw.failNext({ collection: 'shopConfig', method: 'GET', status: 500, message: 'kaputt' })
const erg = await taeglicherJob(JETZT)
assert.equal(erg.fehler, 1)
assert.equal(erg.shopsGeloescht, 1)
})
// ------------------------------------------------------------------------------------------------ Stundenjob
test('Stundenjob raeumt nie beanspruchte Bilder nach 24 h auf', async () => {
const ordner = path.join(uploadDir, KEY)
mkdirSync(ordner, { recursive: true })
for (const [bildId, claimed] of [['alt1', false], ['alt2', true]]) {
writeFileSync(path.join(ordner, `${bildId}-l.webp`), 'x')
writeFileSync(path.join(ordner, `${bildId}-s.webp`), 'x')
writeFileSync(path.join(ordner, `${bildId}.json`), JSON.stringify({ claimed, createdAt: vor(3) }))
}
const erg = await stuendlicherJob(JETZT)
assert.equal(erg.bilderEntfernt, 1)
assert.equal(existsSync(path.join(ordner, 'alt1.json')), false)
assert.equal(existsSync(path.join(ordner, 'alt2.json')), true)
})
// ------------------------------------------------------------------------------------------------ Kundenloeschung
test('Kunde loeschen: Webshop wird abgeschaltet (Grund kunde_geloescht), geoeffnet=false, Daten bleiben fuer die 90 Tage', async () => {
aw.seed('customers', { $id: 'cs9', name: 'Weg', email: 'weg@example.invalid' })
aw.seed('websiteProjects', { $id: 'p9', customerId: 'cs9', projectName: 'Laden' })
aw.seed('shopConfig', { $id: 'f_p9_shop', customerId: 'cs9', projectId: 'p9', siteKey: KEY, geoeffnet: true })
aw.seed('portalFeatures', { $id: 'f_p9_shop', customerId: 'cs9', projectId: 'p9', featureKey: 'shop', siteKey: KEY, state: 'active', enabled: true })
const o = bestellung('f_p9_shop')
aw.seed('shopConfig', { $id: 'f_fremd', customerId: 'cs8', projectId: 'p8', siteKey: KEY2, geoeffnet: true })
await deleteCustomerWithPortalAccess('cs9')
assert.equal(aw.docs('customers').has('cs9'), false)
const f = aw.docs('portalFeatures').get('f_p9_shop')
assert.deepEqual([f.state, f.enabled, f.adminNote, f.disabledReason], ['disabled', false, 'Kunde gelöscht', 'kunde_geloescht'])
assert.ok(Math.abs(Date.parse(f.disabledAt) - Date.now()) < 5000)
assert.equal(aw.docs('shopConfig').get('f_p9_shop').geoeffnet, false)
assert.equal(aw.docs('shopConfig').get('f_fremd').geoeffnet, true, 'Shop eines anderen Kunden unberuehrt')
assert.equal(aw.docs('shopOrders').has(o), true, 'Daten bleiben bis zur 90-Tage-Frist')
// 89 Tage spaeter noch da, nach 91 Tagen vom Tagesjob geloescht
const frueh = new Date(Date.parse(f.disabledAt) + 89 * TAG)
assert.equal((await taeglicherJob(frueh)).shopsGeloescht, 0)
assert.equal(aw.docs('shopOrders').has(o), true)
const spaet = new Date(Date.parse(f.disabledAt) + 91 * TAG)
assert.equal((await taeglicherJob(spaet)).shopsGeloescht, 1)
assert.equal(aw.docs('shopOrders').has(o), false)
assert.equal(aw.docs('shopConfig').has('f_p9_shop'), false)
assert.equal(aw.docs('portalFeatures').get('f_p9_shop').state, 'disabled')
})
const kundeMitShop = (kunde, projekt) => {
aw.seed('customers', { $id: kunde, name: 'Weg', email: `${kunde}@example.invalid` })
aw.seed('websiteProjects', { $id: projekt, customerId: kunde, projectName: 'Laden' })
aw.seed('shopConfig', { $id: `f_${projekt}_shop`, customerId: kunde, projectId: projekt, siteKey: KEY, geoeffnet: true })
aw.seed('portalFeatures', { $id: `f_${projekt}_shop`, customerId: kunde, projectId: projekt, featureKey: 'shop', siteKey: KEY, state: 'active', enabled: true })
}
test('Kunde loeschen gelingt auch, wenn das Abschalten des Webshops scheitert (Fehler im Log); der Shop wird trotzdem geschlossen', async (t) => {
const log = t.mock.method(console, 'error', () => {})
kundeMitShop('cs10', 'p10')
aw.failNext({ collection: 'portalFeatures', method: 'PATCH', status: 500, message: 'kaputt' })
await deleteCustomerWithPortalAccess('cs10')
assert.equal(aw.docs('customers').has('cs10'), false)
assert.ok(log.mock.calls.some((c) => /Webshop von Kunde cs10 nicht abgeschaltet/.test(String(c.arguments[0]))))
assert.equal((await sf.getFeatureDoc('cs10', 'p10', 'shop')).state, 'active', 'das Dokument bleibt wie es war')
assert.equal(aw.docs('shopConfig').get('f_p10_shop').geoeffnet, false)
})
test('Kunde loeschen gelingt auch, wenn das Schliessen des Webshops scheitert (Fehler im Log); die Funktion ist abgeschaltet', async (t) => {
const log = t.mock.method(console, 'error', () => {})
kundeMitShop('cs11', 'p11')
aw.failNext({ collection: 'shopConfig', method: 'PATCH', status: 500, message: 'kaputt' })
await deleteCustomerWithPortalAccess('cs11')
assert.equal(aw.docs('customers').has('cs11'), false)
assert.ok(log.mock.calls.some((c) => /Webshop von Kunde cs11 nicht geschlossen/.test(String(c.arguments[0]))))
assert.equal((await sf.getFeatureDoc('cs11', 'p11', 'shop')).state, 'disabled')
})
// ------------------------------------------------------------------------------------------------ Registrierung
test('server/index.js registriert Minuten- (75 s), Stunden- (130 s) und Tagesjob (200 s) mit unref', () => {
const quelle = readFileSync(new URL('../server/index.js', import.meta.url), 'utf8')
assert.match(quelle, /from '\.\/services\/shop\/jobs\.js'/)
for (const [name, sekunden, takt] of [['shopMinuten', 75, '60 \\* 1000'], ['shopStunden', 130, '60 \\* 60 \\* 1000'], ['shopTages', 200, '24 \\* 60 \\* 60 \\* 1000']]) {
assert.match(quelle, new RegExp(`setTimeout\\(\\(\\) => \\{\\s*${name}\\(\\)\\s*setInterval\\(${name}, ${takt}\\)\\.unref\\(\\)\\s*\\}, ${sekunden} \\* 1000\\)\\.unref\\(\\)`), name)
}
})
test('Dokument bleibt lesbar: getDocument liefert das Funktionsdokument nach der Loeschung', async () => {
shop('s_z')
feature('s_z', { state: 'disabled', disabledAt: vor(100) })
await taeglicherJob(JETZT)
assert.equal((await getDocument(config.collections.portalFeatures, 's_z')).state, 'disabled')
})
Reference in new issue View Git Blame Copy Permalink