@microsoft/useragent-sdk
Version:
SDK for building decentralized identity wallets and enterprise agents.
153 lines • 8.21 kB
JavaScript
;
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const CredentialIssuer_1 = require("../../src/credentials/CredentialIssuer");
const Identifier_1 = require("../../src/Identifier");
const UserAgentError_1 = require("../../src/UserAgentError");
const CredentialManifest_1 = require("../../src/credentials/CredentialManifest");
const TestDataHandler_1 = require("./TestDataHandler");
let fetchMock;
describe('CredentialIssuer', () => {
let credentialManifest;
let issuerIdentifier;
let consumer;
let inputCredential;
let testVerifiedCredential;
beforeAll(() => {
fetchMock = require('fetch-mock');
credentialManifest = new CredentialManifest_1.default({
credential: 'example',
endpoint: 'https://enterpriseagent.org/verifiedcredential.json'
});
issuerIdentifier = new Identifier_1.default('did:test:example.id');
consumer = new Identifier_1.default('did:test:consumer.id');
inputCredential = {
issuedBy: consumer,
issuedTo: issuerIdentifier,
issuedAt: new Date()
};
testVerifiedCredential = {
issuedBy: issuerIdentifier,
issuedTo: consumer,
issuedAt: new Date()
};
});
afterEach(() => {
fetchMock.restore();
});
describe('create', () => {
it('should create a new CredentialIssuer from Credential Manifest Endpoint', async () => {
fetchMock.get('https://enterpriseagent.org/credentialManifest.json', new Promise(resolve => resolve(credentialManifest)));
const issuer = await CredentialIssuer_1.default.create(issuerIdentifier, 'https://enterpriseagent.org/credentialManifest.json');
expect(issuer).toBeDefined();
expect(issuer.manifest).toEqual(credentialManifest);
});
it('should create a new CredentialIssuer from Credential Manifest Object', async () => {
const issuer = await CredentialIssuer_1.default.create(issuerIdentifier, credentialManifest);
expect(issuer).toBeDefined();
expect(issuer.manifest).toEqual(credentialManifest);
});
it('should throw an error when fetch returns 404', async () => {
fetchMock.get('https://enterpriseagent.org/credentialManifest.json', 404);
try {
const issuer = await CredentialIssuer_1.default.create(issuerIdentifier, 'https://enterpriseagent.org/credentialManifest.json');
console.log(issuer);
fail();
}
catch (error) {
expect(error).toBeDefined();
expect(error instanceof UserAgentError_1.default).toBeTruthy();
expect(error.message).toEqual(`Failed to request a credential manifest from the issuer 'did:test:example.id.'`);
}
});
it('should throw an error when server returns 500', async () => {
fetchMock.get('https://enterpriseagent.org/credentialManifest.json', 500);
try {
const issuer = await CredentialIssuer_1.default.create(issuerIdentifier, 'https://enterpriseagent.org/credentialManifest.json');
console.log(issuer);
fail();
}
catch (error) {
expect(error).toBeDefined();
expect(error instanceof UserAgentError_1.default).toBeTruthy();
expect(error.message).toEqual(`'https://enterpriseagent.org/credentialManifest.json' returned an error with 'Internal Server Error'`);
}
});
});
describe('requestCredential', () => {
afterEach(() => {
fetchMock.restore();
});
it('should get a verified credential back', async () => {
const options = { method: 'POST' };
fetchMock.mock('https://enterpriseagent.org/verifiedcredential.json', testVerifiedCredential, options);
const issuer = new CredentialIssuer_1.default(issuerIdentifier, credentialManifest);
const verifiedCredential = await issuer.requestCredential(inputCredential);
expect(verifiedCredential).toBeDefined();
expect(verifiedCredential.issuedBy.id).toEqual('did:test:example.id');
expect(verifiedCredential.issuedTo.id).toEqual('did:test:consumer.id');
});
it('should throw an error when fetch returns 404', async () => {
const response = { status: 404, body: testVerifiedCredential };
const options = { method: 'POST' };
fetchMock.mock('https://enterpriseagent.org/verifiedcredential.json', response, options);
try {
const issuer = new CredentialIssuer_1.default(issuerIdentifier, credentialManifest);
const verifiedCredential = await issuer.requestCredential(inputCredential);
console.log(verifiedCredential);
fail();
}
catch (error) {
expect(error).toBeDefined();
expect(error instanceof UserAgentError_1.default).toBeTruthy();
expect(error.message).toEqual(`Failed to request a credential from the issuer 'did:test:example.id.'`);
}
});
it('should throw a timeout error', async () => {
const delay = new Promise((_res, _rej) => setTimeout(_res, 40000));
// const response = { status: 404, body: VERIFIEDCREDENTIAL };
// const options = { method: 'POST' };
fetchMock.mock('https://enterpriseagent.org/verifiedcredential.json', delay.then((_response) => 404));
try {
const issuer = new CredentialIssuer_1.default(issuerIdentifier, credentialManifest);
const verifiedCredential = await issuer.requestCredential(inputCredential);
console.log(verifiedCredential);
fail();
}
catch (error) {
expect(error).toBeDefined();
expect(error instanceof UserAgentError_1.default).toBeTruthy();
expect(error.message).toEqual(`Requesting a credential from '${credentialManifest.endpoint}' timed out`);
}
}, 50000);
});
describe('handleCredentialRequest', () => {
let issuer;
let testDataHandler;
beforeEach(async () => {
issuer = await CredentialIssuer_1.default.create(issuerIdentifier, credentialManifest);
testDataHandler = new TestDataHandler_1.default();
});
it('should throw an error because credential does not match credential manifest', async () => {
spyOn(issuer, 'validateCredential').and.returnValue(false);
try {
await issuer.handleCredentialRequest(inputCredential, testDataHandler);
}
catch (error) {
expect(error).toBeDefined();
expect(error instanceof UserAgentError_1.default).toBeTruthy();
expect(error.message).toEqual(`Credential issued by '${inputCredential.issuedBy.id}' does not match credential manifest '${credentialManifest.credential}'`);
}
});
it('should handle the Credential Request and return new Credential', async () => {
const credential = await issuer.handleCredentialRequest(inputCredential, testDataHandler);
expect(credential.issuedTo).toEqual(inputCredential.issuedBy);
expect(credential.issuedBy).toEqual(inputCredential.issuedTo);
expect(credential.issuedAt).toBeDefined();
});
});
});
//# sourceMappingURL=CredentialIssuer.spec.js.map