@kya-os/mcp-i
Version:
The TypeScript MCP framework with identity features built-in
244 lines (243 loc) • 7.72 kB
JavaScript
;
/**
* Mock Identity Provider for testing
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.MockIdentityProvider = void 0;
exports.getMockIdentityProvider = getMockIdentityProvider;
exports.resetMockIdentityProvider = resetMockIdentityProvider;
const test_1 = require("@kya-os/contracts/test");
const test_environment_1 = require("./test-environment");
const deterministic_keys_1 = require("./deterministic-keys");
/**
* Mock Identity Provider for testing XMCP-I applications
*/
class MockIdentityProvider {
identities = new Map();
delegations = new Map();
ktaFailures = new Set();
deterministicSeed;
constructor(config) {
(0, test_environment_1.ensureTestMode)();
if (config) {
this.configure(config);
}
else {
// Load predefined test identities by default
this.loadPredefinedIdentities();
}
}
/**
* Configure the mock provider
*/
configure(config) {
(0, test_environment_1.ensureTestMode)();
// Validate configuration
const validatedConfig = test_1.MockIdentityProviderConfigSchema.partial().parse(config);
if (validatedConfig.identities) {
this.identities.clear();
Object.entries(validatedConfig.identities).forEach(([key, identity]) => {
this.identities.set(key, identity);
});
}
if (validatedConfig.delegations) {
this.delegations.clear();
Object.entries(validatedConfig.delegations).forEach(([key, status]) => {
this.delegations.set(key, status);
});
}
if (validatedConfig.ktaFailures) {
this.ktaFailures.clear();
validatedConfig.ktaFailures.forEach((failure) => {
this.ktaFailures.add(failure);
});
}
if (validatedConfig.deterministicSeed) {
this.deterministicSeed = validatedConfig.deterministicSeed;
}
}
/**
* Load predefined test identities
*/
loadPredefinedIdentities() {
const predefined = (0, deterministic_keys_1.getPredefinedTestIdentities)();
Object.entries(predefined).forEach(([key, identity]) => {
this.identities.set(key, identity);
// Set all predefined identities as active by default
this.delegations.set(`${identity.did}:${identity.kid}`, "active");
});
}
/**
* Set identity for a given key
*/
setIdentity(key, identity) {
(0, test_environment_1.ensureTestMode)();
this.identities.set(key, identity);
}
/**
* Get identity by key
*/
getIdentity(key) {
(0, test_environment_1.ensureTestMode)();
return this.identities.get(key);
}
/**
* Generate and set a new test identity
*/
generateIdentity(key, testName, options) {
(0, test_environment_1.ensureTestMode)();
const identity = (0, deterministic_keys_1.generateTestIdentity)(testName, {
...options,
seed: this.deterministicSeed,
});
this.setIdentity(key, identity);
this.setDelegation(`${identity.did}:${identity.kid}`, "active");
return identity;
}
/**
* Set delegation status for a DID:KeyID combination
*/
setDelegation(didKeyId, status) {
(0, test_environment_1.ensureTestMode)();
this.delegations.set(didKeyId, status);
}
/**
* Get delegation status
*/
getDelegationStatus(did, kid) {
(0, test_environment_1.ensureTestMode)();
return this.delegations.get(`${did}:${kid}`) || "revoked";
}
/**
* Simulate KTA failure scenarios
*/
simulateKTAFailure(errorType) {
(0, test_environment_1.ensureTestMode)();
this.ktaFailures.add(errorType);
}
/**
* Clear KTA failure simulation
*/
clearKTAFailure(errorType) {
(0, test_environment_1.ensureTestMode)();
this.ktaFailures.delete(errorType);
}
/**
* Check if a KTA failure should be simulated
*/
shouldSimulateKTAFailure(errorType) {
(0, test_environment_1.ensureTestMode)();
return this.ktaFailures.has(errorType);
}
/**
* Get all active KTA failures
*/
getActiveKTAFailures() {
(0, test_environment_1.ensureTestMode)();
return Array.from(this.ktaFailures);
}
/**
* Mock KTA registration call
*/
async mockRegister(did, _kid) {
(0, test_environment_1.ensureTestMode)();
// Simulate network failure
if (this.shouldSimulateKTAFailure("network")) {
throw new Error(`${test_1.TEST_ERROR_CODES.MOCK_KTA_FAILURE}: Network error`);
}
// Simulate auth failure
if (this.shouldSimulateKTAFailure("auth")) {
return {
success: false,
error: "Authentication failed",
};
}
// Simulate invalid response
if (this.shouldSimulateKTAFailure("invalid")) {
return {
success: false,
error: "Invalid response from KTA",
};
}
// Simulate timeout
if (this.shouldSimulateKTAFailure("timeout")) {
await new Promise((resolve) => setTimeout(resolve, 5000));
throw new Error(`${test_1.TEST_ERROR_CODES.MOCK_KTA_FAILURE}: Request timeout`);
}
// Success case
return {
success: true,
agentURL: `https://test-kta.example.com/agents/${did.replace("did:test:", "")}`,
};
}
/**
* Mock KTA delegation check
*/
async mockCheckDelegation(did, kid) {
(0, test_environment_1.ensureTestMode)();
// Simulate failures if configured
if (this.shouldSimulateKTAFailure("network")) {
throw new Error(`${test_1.TEST_ERROR_CODES.MOCK_KTA_FAILURE}: Network error during delegation check`);
}
if (this.shouldSimulateKTAFailure("auth")) {
return {
status: "revoked",
error: "Authentication failed",
};
}
const status = this.getDelegationStatus(did, kid);
return { status };
}
/**
* Reset the mock provider to initial state
*/
reset() {
(0, test_environment_1.ensureTestMode)();
this.identities.clear();
this.delegations.clear();
this.ktaFailures.clear();
this.deterministicSeed = undefined;
this.loadPredefinedIdentities();
}
/**
* Get all configured identities
*/
getAllIdentities() {
(0, test_environment_1.ensureTestMode)();
return Object.fromEntries(this.identities.entries());
}
/**
* Get all delegation statuses
*/
getAllDelegations() {
(0, test_environment_1.ensureTestMode)();
return Object.fromEntries(this.delegations.entries());
}
}
exports.MockIdentityProvider = MockIdentityProvider;
/**
* Global mock identity provider instance for testing
*/
let globalMockProvider;
/**
* Get or create the global mock identity provider
*/
function getMockIdentityProvider() {
(0, test_environment_1.ensureTestMode)();
if (!globalMockProvider) {
globalMockProvider = new MockIdentityProvider();
}
return globalMockProvider;
}
/**
* Reset the global mock identity provider
*/
function resetMockIdentityProvider() {
(0, test_environment_1.ensureTestMode)();
if (globalMockProvider) {
globalMockProvider.reset();
}
else {
globalMockProvider = new MockIdentityProvider();
}
}