Files
MikrotikManager/backend/src/services/certificates-state.test.ts
T

43 lines
5.0 KiB
TypeScript

import assert from "node:assert/strict"
import {mapObservedCertificate,readCertificateServerState,collectCertificatesState,readCertificateRowsWithClock} from "./certificates-state.js"
import {certificatesStateSchema,certificateObservedSchema} from "@mmapp/contracts/certificates"
const server={id:1,name:"Router"},now=new Date("2026-10-01T00:00:00Z")
const raw={".id":"*A",name:"cert-live",flags:"KT","invalid-before":"2026-09-01T00:00:00Z","invalid-after":"2026-11-01T00:00:00Z","key-size":"2048",trusted:"true"}
const good=mapObservedCertificate(server,raw,now)
assert.equal(good.status,"valid");assert.equal(good.daysLeft,31);assert.equal(good.keySize,2048);assert.equal(good.trusted,true);assert.equal(good.rosId,"*A")
const unknown=mapObservedCertificate(server,{name:"unsigned"},now)
assert.equal(unknown.daysLeft,null);assert.equal(unknown.status,"unknown");assert.equal(unknown.trusted,null);assert.equal(unknown.keySize,null);assert.equal(unknown.rosId,null)
for(const date of ["yesterday","2026-02-30T00:00:00Z","oct/01/2026 12:00:00","2026-11-01"]){const row=mapObservedCertificate(server,{...raw,"invalid-after":date},now);assert.equal(row.daysLeft,null,date);assert.equal(row.status,"unknown");assert.equal(row.rawValidUntil,date)}
assert.equal(mapObservedCertificate(server,{...raw,"invalid-before":"2026-10-01T03:00:00+03:00"},now).validFrom,now.toISOString())
assert.equal(mapObservedCertificate(server,{...raw,"invalid-before":"2026-12-01T00:00:00Z"},now).status,"unknown")
assert.equal(mapObservedCertificate(server,{...raw,flags:undefined,revoked:undefined},now).status,"unknown")
assert.equal(mapObservedCertificate(server,{...raw,flags:"R","invalid-after":undefined},now).status,"revoked")
assert.equal(mapObservedCertificate(server,{...raw,flags:"E","invalid-after":undefined},now).status,"expired")
assert.equal(mapObservedCertificate(server,{...raw,"invalid-after":"2026-09-01T00:00:00Z"},now).status,"expired")
for(const size of ["0","bad","256x","-1","256.5"])assert.equal(mapObservedCertificate(server,{...raw,"key-size":size},now).keySize,null)
assert.equal((await readCertificateServerState(server,async()=>[])).error,null)
for(const value of [{certificates:[]},[{}],[raw,raw],[{...raw,flags:true}]])assert.ok((await readCertificateServerState(server,async()=>value)).error)
const partial=await collectCertificatesState([server,{id:2,name:"offline"}],srv=>async()=>{if(srv.id===2)throw new Error("offline");return [raw]})
assert.equal(partial.servers[0].certificates.length,1);assert.equal(partial.servers[1].error,"offline");assert.equal((await collectCertificatesState([],()=>async()=>[])).servers.length,0)
for(const value of [{...partial,servers:[partial.servers[0],partial.servers[0]]},{...partial,servers:[{...partial.servers[0],serverId:"2"}]},{...partial,servers:[{...partial.servers[0],error:"failure"}]}])assert.equal(certificatesStateSchema.safeParse(value).success,false)
assert.equal(certificateObservedSchema.safeParse({...good,validUntil:null}).success,false)
console.log("Certificate observed: unknown/date timezone/invalid calendar, flags, key size, known empty, malformed/duplicate/context, partial devices; no DB/RouterOS")
const setupFailure=await collectCertificatesState([server,{id:2,name:"bad client"}],srv=>{if(srv.id===2)throw new Error("client setup refused");return async()=>[raw]});assert.equal(setupFailure.servers[0].certificates.length,1);assert.equal(setupFailure.servers[1].error,"client setup refused")
const native={...raw,"invalid-before":"2026-10-14 15:37:47","invalid-after":"2027-01-12 15:37:46"}
const calibrated=mapObservedCertificate(server,native,new Date("2026-10-14T14:37:23Z"),"+02:00")
assert.equal(calibrated.validFrom,"2026-10-14T13:37:47.000Z");assert.equal(calibrated.validUntil,"2027-01-12T13:37:46.000Z");assert.equal(calibrated.status,"valid");assert.equal(calibrated.rawValidUntil,native["invalid-after"])
for(const offset of [undefined,null,"bad","+14:01","+24:00","+02:60"])assert.equal(mapObservedCertificate(server,native,now,offset).validUntil,null)
assert.equal(mapObservedCertificate(server,{...native,"invalid-after":"2026-02-30 12:00:00"},now,"+02:00").validUntil,null)
assert.equal(mapObservedCertificate(server,raw,now,"+02:00").validUntil,"2026-11-01T00:00:00.000Z")
for(const offsets of [["+02:00","+02:00"],["+02:00","+01:00"],[null,"+02:00"],["+02:00",null]]) {
let index=0
const rows=await readCertificateRowsWithClock(async()=>[native],async()=>({"gmt-offset":offsets[index++]}))
const observed=await readCertificateServerState(server,async()=>rows)
assert.equal(observed.error,null);assert.equal(observed.certificates[0].validUntil,offsets[0]!==null&&offsets[0]===offsets[1]?"2027-01-12T13:37:46.000Z":null)
}
const clockFailure=await readCertificateRowsWithClock(async()=>[native],async()=>{throw Error("clock denied")})
assert.equal((await readCertificateServerState(server,async()=>clockFailure)).certificates[0].daysLeft,null)
console.log("Native dates: observed stable clock offset, future winter expiry, missing/changed/failed clock, invalid calendar, explicit ISO preservation passed")