Устаревший тест, не дефект продукта. Аудиты configuration.intent и configuration.acknowledged пишутся через requestAccountingWrite на клиенте из pool.connect(), поэтому перехват pool.query в сценариях поздней отмены доступа и потерянного подтверждения никогда не срабатывал (revoked=false). Общий фикстур configuration-audit-commit получил помощник loseConfigurationAcknowledgement; тест GeoIP использует его и afterConfigurationIntentCommit. Ожидания продукта (нет повторного запроса, итог unknown при потере подтверждения) не менялись. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
105 lines
11 KiB
TypeScript
105 lines
11 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { randomUUID } from "node:crypto"
|
|
import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
|
|
import { tmpdir } from "node:os"
|
|
import path from "node:path"
|
|
import { createServer } from "node:http"
|
|
import { setTimeout as delay } from "node:timers/promises"
|
|
import Fastify from "fastify"
|
|
import { mcpConnectionCreateSchema } from "@mmapp/contracts/mcp"
|
|
import type { AuthUser } from "../lib/permissions.js"
|
|
import { pool } from "../db/index.js"
|
|
import { createMcpConnection, authenticateMcpToken, setConnectionStatus } from "../modules/mcp/store.js"
|
|
import { invokeMcpTool, approvePlan, applyPlan, loadPlan } from "../modules/mcp/runtime.js"
|
|
import { decryptSecret } from "../modules/mcp/security.js"
|
|
import { findMcpService } from "../modules/mcp/service-registry.js"
|
|
import { setGeoipFetchForTests, setGeoipValidateForTests, resetGeoipUpdateForTests } from "../services/geoip-update-collector.js"
|
|
import { resetGeoipForTests, GEOIP_COUNTRY_FILE, GEOIP_ASN_FILE } from "../services/traffic-flow-geoip.js"
|
|
import { updateGeoipManually } from "../services/geoip-manual-update.js"
|
|
import geoipRoutes from "../routes/geoip.js"
|
|
import { afterConfigurationIntentCommit, loseConfigurationAcknowledgement } from "./fixtures/configuration-audit-commit.js"
|
|
|
|
/** Isolated real HTTP/file/SQL acceptance. No real mirror or RouterOS traffic. */
|
|
export async function verifyMcpGeoipUpdate(actor:AuthUser){
|
|
const owner={...actor,id:"geoip-update-owner",permissions:[...actor.permissions,"mm:traffic:write"]}
|
|
const saved=(await pool.query("SELECT * FROM geoip_settings WHERE id=1")).rows[0]
|
|
const ids=(await pool.query<{id:number}>("SELECT id FROM servers ORDER BY id")).rows.map(row=>Number(row.id))
|
|
const issued=await createMcpConnection(mcpConnectionCreateSchema.parse({name:"GeoIP update fixture",mode:"approval",expiresAt:new Date(Date.now()+1800000).toISOString(),permissions:["mm:traffic:write"],scope:{allowGlobal:true,serverIds:ids,operationIds:["geoip.update"]},limits:{callsPerMinute:120,mutationsPerHour:100}}),owner)
|
|
const principal=await authenticateMcpToken(issued.token),protection=randomUUID(),dir=await mkdtemp(path.join(tmpdir(),"mcp-geoip-update-")),oldDir=process.env.GEOIP_DIR,originalFetch=globalThis.fetch,originalQuery=pool.query.bind(pool)
|
|
let mode="normal",calls=0
|
|
const requests:{url:string;etag:string|undefined}[]=[]
|
|
const upstream=createServer((req,res)=>{
|
|
calls++;requests.push({url:req.url!,etag:req.headers["if-none-match"] as string|undefined})
|
|
if(mode==="failure"){res.statusCode=503;res.end("NEVER_EXPOSE_UPSTREAM_BODY");return}
|
|
if(req.headers["if-none-match"]==='"fixture-v1"'){res.statusCode=304;res.end();return}
|
|
res.setHeader("etag",'"fixture-v1"');res.end("fixture "+req.url)
|
|
})
|
|
await new Promise<void>(resolve=>upstream.listen(0,"127.0.0.1",resolve))
|
|
const local=`http://127.0.0.1:${(upstream.address()as{port:number}).port}`
|
|
process.env.GEOIP_DIR=dir;resetGeoipForTests()
|
|
setGeoipFetchForTests((async(url,options)=>{
|
|
const parsed=new URL(String(url));assert.equal(parsed.origin,"https://github.com");assert.ok([GEOIP_COUNTRY_FILE,GEOIP_ASN_FILE].some(file=>parsed.pathname===`/P3TERX/GeoLite.mmdb/raw/download/${file}`))
|
|
const response=await originalFetch(local+"/"+path.posix.basename(parsed.pathname),options)
|
|
if(mode==="etag-drift")await pool.query("UPDATE geoip_settings SET etags_json=$1::jsonb WHERE id=1",[JSON.stringify({[GEOIP_COUNTRY_FILE]:"changed-during-download"})])
|
|
if(mode==="build-drift")await pool.query("UPDATE geoip_settings SET country_build_at='2000-01-01T00:00:00Z' WHERE id=1")
|
|
return response
|
|
})as typeof fetch)
|
|
const validate=async(file:string)=>{assert.match(await readFile(file,"utf8"),/^fixture /);return "2026-01-01T00:00:00.000Z"}
|
|
setGeoipValidateForTests({country:validate,asn:validate})
|
|
const rest=Fastify();await rest.register(geoipRoutes,{prefix:"/api"})
|
|
const prepare=()=>invokeMcpTool(principal,"mm_geoip_update_plan",{})as Promise<{planId:string;state:string}>
|
|
const wait=async(id:string)=>{for(let i=0;i<600;i++){const row=(await pool.query("SELECT state,error_code,verification FROM mcp_operations WHERE id=$1",[id])).rows[0];if(!["pending","running"].includes(row.state))return row;await delay(25)}throw Error("GeoIP fixture remains active; do not replay")}
|
|
const apply=async()=>{const plan=await prepare();assert.equal(plan.state,"awaiting-approval");await approvePlan(plan.planId,owner,true);const key=randomUUID(),op=await applyPlan(principal,plan.planId,key);return {plan,key,op,...await wait(op.id)}}
|
|
try{
|
|
await pool.query("INSERT INTO geoip_settings(id,enabled,update_interval_sec,etags_json) VALUES(1,false,604800,'{}'::jsonb) ON CONFLICT(id) DO UPDATE SET enabled=false,update_interval_sec=604800,etags_json='{}'::jsonb,last_check_at=NULL,last_success_at=NULL,last_error=NULL,country_build_at=NULL,asn_build_at=NULL")
|
|
const unapproved=await prepare();await assert.rejects(applyPlan(principal,unapproved.planId,randomUUID()));assert.equal(calls,0)
|
|
const cancelled=new AbortController();cancelled.abort(Error("cancelled before dispatch"));await assert.rejects(updateGeoipManually({signal:cancelled.signal}));await assert.rejects(invokeMcpTool(principal,"mm_geoip_update_plan",{},cancelled.signal));assert.equal(calls,0)
|
|
const denied=await createMcpConnection(mcpConnectionCreateSchema.parse({name:"GeoIP scope fixture",mode:"approval",expiresAt:new Date(Date.now()+1800000).toISOString(),permissions:["mm:traffic:write"],scope:{allowGlobal:true,serverIds:[],operationIds:["geoip.update"]}}),owner)
|
|
if(ids.length)await assert.rejects(invokeMcpTool(await authenticateMcpToken(denied.token),"mm_geoip_update_plan",{}))
|
|
await setConnectionStatus(denied.connection.id,"paused",owner)
|
|
let result=await apply();assert.equal(result.state,"applied");assert.equal(calls,2)
|
|
const receipt=(await pool.query("SELECT result FROM mcp_operation_steps WHERE operation_id=$1",[result.op.id])).rows[0].result
|
|
assert.equal(receipt.downloaded,2);assert.equal(receipt.ok,true);assert.ok(!JSON.stringify(receipt).includes(dir));assert.ok(!JSON.stringify(receipt).includes("NEVER_EXPOSE"))
|
|
await applyPlan(principal,result.plan.planId,result.key);assert.equal(calls,2)
|
|
const country=await readFile(path.join(dir,GEOIP_COUNTRY_FILE),"utf8")
|
|
const response=await rest.inject({method:"POST",url:"/api/geoip/update"});assert.equal(response.statusCode,200,response.body);assert.equal(response.json().snapshot.skippedUnchanged,2);assert.equal(calls,4);assert.deepEqual(requests.slice(2).map(request=>request.etag),['"fixture-v1"','"fixture-v1"']);assert.equal(await readFile(path.join(dir,GEOIP_COUNTRY_FILE),"utf8"),country)
|
|
const stale=await prepare();await approvePlan(stale.planId,owner,true);await writeFile(path.join(dir,GEOIP_COUNTRY_FILE),"fixture changed outside approved plan")
|
|
const beforeStale=calls;assert.equal((await wait((await applyPlan(principal,stale.planId,randomUUID())).id)).state,"rejected");assert.equal(calls,beforeStale)
|
|
for(const kind of ["geoip-settings","geoip-update"]){
|
|
await pool.query("INSERT INTO mcp_protections(id,object_ref,created_by) VALUES($1,$2::jsonb,$3)",[protection,JSON.stringify({kind,id:"1",protection:"deny"}),owner.id])
|
|
await assert.rejects(prepare());assert.equal((await rest.inject({method:"POST",url:"/api/geoip/update"})).statusCode,409);assert.equal(calls,beforeStale)
|
|
await pool.query("DELETE FROM mcp_protections WHERE id=$1",[protection])
|
|
}
|
|
mode="failure";result=await apply();assert.equal(result.state,"partial");assert.equal(calls,beforeStale+2);await applyPlan(principal,result.plan.planId,result.key);assert.equal(calls,beforeStale+2)
|
|
mode="normal"
|
|
const beforeDrift=(await pool.query("SELECT etags_json,country_build_at FROM geoip_settings WHERE id=1")).rows[0]
|
|
for(const drift of ["etag-drift","build-drift"]){
|
|
mode=drift;const before:number=calls,result=await apply();assert.equal(result.state,"unknown");assert.equal(calls,before+1,"Late metadata/ETag drift must forbid the second network source")
|
|
const atReturn:number=calls;await applyPlan(principal,result.plan.planId,result.key);assert.equal(calls,atReturn)
|
|
await pool.query("UPDATE geoip_settings SET etags_json=$1::jsonb,country_build_at=$2 WHERE id=1",[JSON.stringify(beforeDrift.etags_json),beforeDrift.country_build_at])
|
|
}
|
|
mode="normal"
|
|
const late=await prepare();await approvePlan(late.planId,owner,true)
|
|
// Audits commit on transaction clients, so hooks wrap pool.connect rather than pool.query.
|
|
const revoke=afterConfigurationIntentCommit("geoip-update",()=>setConnectionStatus(issued.connection.id,"paused",owner))
|
|
const beforeLate=calls
|
|
try{await wait((await applyPlan(principal,late.planId,randomUUID())).id);assert.equal(revoke.fired(),true);assert.equal(calls,beforeLate)}finally{revoke.restore();await setConnectionStatus(issued.connection.id,"active",owner)}
|
|
const unknown=await prepare();await approvePlan(unknown.planId,owner,true)
|
|
const lost=loseConfigurationAcknowledgement("geoip-update")
|
|
const key=randomUUID();let operationId=""
|
|
try{const op=await applyPlan(principal,unknown.planId,key);operationId=op.id;assert.equal((await wait(op.id)).state,"unknown");assert.equal(lost.dropped(),true)}finally{lost.restore()}
|
|
const beforeReplay=calls;await applyPlan(principal,unknown.planId,key);assert.equal(calls,beforeReplay)
|
|
const sealed=JSON.parse(await decryptSecret((await loadPlan(unknown.planId)).evidence.sealed)),service=findMcpService("geoip.update")!
|
|
assert.deepEqual(await service.reconcile!(sealed.steps[0].input,async()=>{}),{matchesDesiredState:false,matchesOriginalState:false});assert.equal(calls,beforeReplay)
|
|
const persisted=(await pool.query("SELECT result FROM mcp_operation_steps WHERE operation_id=$1",[operationId])).rows
|
|
assert.ok(!JSON.stringify(persisted).includes("NEVER_EXPOSE_UPSTREAM_BODY"))
|
|
console.log("✓ GeoIP manual update: human approval, shared REST HTTP/file/SQL semantics, disabled force, ETag/304, bounded safe receipts, scope/protections/cancel/stale/late revoke, partial errors, lost acknowledgement unknown, no replay and read-only unresolved reconciliation; isolated upstream only")
|
|
}finally{
|
|
pool.query=originalQuery as typeof pool.query;resetGeoipUpdateForTests();resetGeoipForTests();await rest.close();upstream.closeAllConnections();await new Promise<void>(resolve=>upstream.close(()=>resolve()))
|
|
if(oldDir===undefined)delete process.env.GEOIP_DIR;else process.env.GEOIP_DIR=oldDir
|
|
await setConnectionStatus(issued.connection.id,"paused",owner);await pool.query("DELETE FROM mcp_protections WHERE id=$1",[protection]);await pool.query("DELETE FROM geoip_settings WHERE id=1")
|
|
if(saved)await pool.query("INSERT INTO geoip_settings SELECT * FROM json_populate_record(NULL::geoip_settings,$1::json)",[JSON.stringify(saved)])
|
|
assert.ok(path.resolve(dir).startsWith(path.resolve(tmpdir())+path.sep));await rm(dir,{recursive:true,force:true})
|
|
}
|
|
}
|