Files
VCCPlusOSS/platforms/macos/Tests/MCPArchiveAccessTests.swift

101 lines
6.3 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import Darwin
import SQLite3
import XCTest
@MainActor
final class MCPArchiveAccessTests: XCTestCase {
private let digest = String(repeating: "a", count: 64)
private func index(at url: URL) throws {
var db: OpaquePointer?
guard sqlite3_open(url.path, &db) == SQLITE_OK else { throw POSIXError(.EIO) }
defer { sqlite3_close(db) }
let sql = """
PRAGMA application_id=0x56434341;
PRAGMA user_version=1;
CREATE TABLE document(id INTEGER PRIMARY KEY,sha256 TEXT,title TEXT,collection TEXT,source_url TEXT,member_path TEXT,delivery_url TEXT,byte_size INTEGER,page_count INTEGER,issue_year INTEGER);
CREATE TABLE page(id INTEGER PRIMARY KEY,document_id INTEGER,page_number INTEGER,page_label TEXT,locator_kind TEXT,is_ocr INTEGER);
CREATE VIRTUAL TABLE page_terms USING fts5(terms,title_terms,content='',detail=none,columnsize=0);
INSERT INTO document VALUES(1,'\(digest)','Guide','Books','https://colorcomputerarchive.com/repo/Documents/Books/Guides.zip','Guide.pdf','https://delivery.invalid/Guide.pdf',12,20,NULL);
INSERT INTO page VALUES(1,1,17,NULL,'pdf_page',1),(2,1,18,NULL,'pdf_page',0);
INSERT INTO page_terms(rowid,terms,title_terms) VALUES(1,'joystk','guide'),(2,'joystk','guide');
"""
guard sqlite3_exec(db, sql, nil, nil, nil) == SQLITE_OK else { throw POSIXError(.EINVAL) }
}
/// Exercise the host boundary directly. A caller can bypass the helper's advertised tool list.
private func request(_ tool: String, _ arguments: [String: Any], using grant: [String: Any]) async throws -> [String: Any] {
let token = try XCTUnwrap(grant["token"] as? String)
let port = try XCTUnwrap(grant["port"] as? UInt16)
let request = try JSONSerialization.data(withJSONObject: ["version": 1, "tool": tool, "arguments": arguments, "token": token]) + Data([10])
let response = try await Task.detached {
let fd = socket(AF_INET, SOCK_STREAM, 0)
guard fd >= 0 else { throw POSIXError(.ENOTSOCK) }
let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true)
defer { try? handle.close() }
var timeout = timeval(tv_sec: 5, tv_usec: 0)
guard setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, socklen_t(MemoryLayout.size(ofValue: timeout))) == 0 else {
throw POSIXError(.ETIMEDOUT)
}
var peer = sockaddr_in()
peer.sin_family = sa_family_t(AF_INET)
peer.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
peer.sin_addr.s_addr = inet_addr("127.0.0.1")
peer.sin_port = port.bigEndian
let result = withUnsafePointer(to: &peer) {
$0.withMemoryRebound(to: sockaddr.self, capacity: 1) { Darwin.connect(fd, $0, socklen_t(MemoryLayout<sockaddr_in>.size)) }
}
guard result == 0 else { throw POSIXError(.ECONNREFUSED) }
try handle.write(contentsOf: request)
return try handle.readToEnd() ?? Data()
}.value
return try XCTUnwrap(JSONSerialization.jsonObject(with: response) as? [String: Any])
}
func testSearchOnlyGrantMatchesNativeAndRejectsBroaderAccess() async throws {
let base = FileManager.default.temporaryDirectory.appendingPathComponent("archive-mcp-" + UUID().uuidString)
try FileManager.default.createDirectory(at: base, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: base) }
let db = base.appendingPathComponent("ArchiveLibrary.sqlite")
try index(at: db)
let catalog = ArchiveLibraryCatalog(url: db), access = MCPArchiveAccess(catalog: catalog)
let grantFile = base.appendingPathComponent("grant.json")
try await access.connect(at: grantFile)
defer { access.revoke() }
let raw = try Data(contentsOf: grantFile)
var grant = try XCTUnwrap(JSONSerialization.jsonObject(with: raw) as? [String: Any])
XCTAssertEqual(grant["kind"] as? String, "archive")
XCTAssertEqual(grant["version"] as? Int, 2)
let native = try await catalog.search(query: "JOYSTK", collection: "Books", limit: 1, offset: 0)
let expected = try XCTUnwrap(native.first)
let reply = try await request("search_archive", ["query": "JOYSTK", "category": "Books", "limit": 1], using: grant)
let first = try XCTUnwrap(reply["result"] as? [String: Any])
let result = try XCTUnwrap((first["results"] as? [[String: Any]])?.first)
XCTAssertEqual(first["next_offset"] as? Int, 1)
XCTAssertEqual(result["citation_id"] as? String, expected.id)
XCTAssertEqual(result["source_url"] as? String, expected.sourceURL.absoluteString)
XCTAssertEqual(result["member_path"] as? String, "Guide.pdf")
XCTAssertEqual(result["pdf_page"] as? Int, expected.page)
XCTAssertFalse(String(describing: result).contains("delivery.invalid"))
let lookup = try await request("get_archive_citation", ["citation_id": expected.id], using: grant)
XCTAssertEqual(lookup["result"] as? NSDictionary, result as NSDictionary)
let next = try await request("search_archive", ["query": "JOYSTK", "offset": 1], using: grant)
let page2 = (next["result"] as? [String: Any])?["results"] as? [[String: Any]]
XCTAssertNotEqual(page2?.first?["citation_id"] as? String, expected.id)
XCTAssertEqual(page2?.count, 1)
let unsupported = try await request("read_source", ["document_id": "secret"], using: grant)
XCTAssertEqual(unsupported["error"] as? String, "access_denied")
let missing = try await request("get_archive_citation", ["citation_id": "private-id"], using: grant)
XCTAssertEqual(missing["error"] as? String, "citation_unavailable")
let badLimit = try await request("search_archive", ["query": "JOYSTK", "limit": true], using: grant)
XCTAssertEqual(badLimit["error"] as? String, "invalid_arguments")
grant["token"] = "wrong"
let denied = try await request("search_archive", ["query": "JOYSTK"], using: grant)
XCTAssertEqual(denied["error"] as? String, "access_denied")
await access.revoke().value
XCTAssertFalse(FileManager.default.fileExists(atPath: grantFile.path))
XCTAssertNil(access.grantFile)
}
}