@connectid-tools/rp-nodejs-sdk 4.2.1 → 5.0.0

package/src/tests/cert-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/tests/cert-utils.test.js

@@ -0,0 +1,13 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import { getCertificate } from '../utils/cert-utils.js';
+test('should use content when certificate content and path are passed', () => {
+    assert.strictEqual(getCertificate('.gitignore', 'abcdefg'), 'abcdefg');
+});
+test('should use path when content is falsy', () => {
+    assert.ok(getCertificate('.gitignore', '').toString().includes('# These are some examples of commonly ignored file patterns.'));
+    // @ts-ignore
+    assert.ok(getCertificate('.gitignore', 0).toString().includes('# These are some examples of commonly ignored file patterns.'));
+    // @ts-ignore
+    assert.ok(getCertificate('.gitignore', null).toString().includes('# These are some examples of commonly ignored file patterns.'));
+});

package/src/tests/functional-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/tests/functional-utils.test.js

@@ -0,0 +1,13 @@
+import test from 'node:test';
+import { partition } from '../utils/functional-utils.js';
+import assert from 'node:assert';
+test('should partition list', () => {
+    const [odd, even] = partition([1, 2, 3, 4, 5], (input) => input % 2 == 1);
+    assert.deepEqual(odd, [1, 3, 5]);
+    assert.deepEqual(even, [2, 4]);
+});
+test('should partition empty list', () => {
+    const [odd, even] = partition([], (input) => input % 2 == 1);
+    assert.deepEqual(odd, []);
+    assert.deepEqual(even, []);
+});

package/src/tests/participant-filters.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/tests/participant-filters.test.js

@@ -0,0 +1,151 @@
+import ParticipantFilter from '../filter/participant-filters.js';
+import { participantsTestData } from '../test-data/participants-test-data.js';
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+const participantsFilter = new ParticipantFilter();
+describe('removeOutOfDateCertifications', () => {
+    it('should remove all certifications as they are all after the specified date', () => {
+        const filteredParticipants = participantsFilter.removeOutOfDateCertifications(getParticipantsTestData(), new Date('2005-01-01'));
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers[0].AuthorisationServerCertifications.length, 0);
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers[1].AuthorisationServerCertifications.length, 0);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers[0].AuthorisationServerCertifications.length, 0);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers[0].AuthorisationServerCertifications.length, 0);
+    });
+    it('should keep all certification as they span the specified date', () => {
+        const filteredParticipants = participantsFilter.removeOutOfDateCertifications(getParticipantsTestData(), new Date('2024-01-01'));
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers[0].AuthorisationServerCertifications.length, 4);
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers[1].AuthorisationServerCertifications.length, 4);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers[0].AuthorisationServerCertifications.length, 4);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers[0].AuthorisationServerCertifications.length, 1);
+    });
+    it('should keep all certification that span the specified date', () => {
+        const filteredParticipants = participantsFilter.removeOutOfDateCertifications(getParticipantsTestData(), new Date('2024-05-20'));
+        const testData = getParticipantsTestData();
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers[0].AuthorisationServerCertifications.length, 3);
+        assert.ok(!filteredParticipants[0].AuthorisationServers[0].AuthorisationServerCertifications.includes(testData[0].AuthorisationServers[0].AuthorisationServerCertifications[0]));
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers[1].AuthorisationServerCertifications.length, 2);
+        assert.ok(!filteredParticipants[0].AuthorisationServers[1].AuthorisationServerCertifications.includes(testData[0].AuthorisationServers[1].AuthorisationServerCertifications[0]));
+        assert.ok(!filteredParticipants[0].AuthorisationServers[1].AuthorisationServerCertifications.includes(testData[0].AuthorisationServers[1].AuthorisationServerCertifications[1]));
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers[0].AuthorisationServerCertifications.length, 1);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers[0].AuthorisationServerCertifications.length, 0);
+    });
+    it('should remove all certifications as they are all before the specified date', () => {
+        const filteredParticipants = participantsFilter.removeOutOfDateCertifications(getParticipantsTestData(), new Date('2025-01-01'));
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers[0].AuthorisationServerCertifications.length, 0);
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers[1].AuthorisationServerCertifications.length, 0);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers[0].AuthorisationServerCertifications.length, 0);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers[0].AuthorisationServerCertifications.length, 0);
+    });
+});
+describe('removeUnofficialCertifications', () => {
+    it('should remove certifications that do not have status "Certified"', () => {
+        const filteredParticipants = participantsFilter.removeUnofficialCertifications(getParticipantsTestData());
+        const testData = getParticipantsTestData();
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers[0].AuthorisationServerCertifications.length, 3);
+        assert.ok(!filteredParticipants[0].AuthorisationServers[0].AuthorisationServerCertifications.includes(testData[0].AuthorisationServers[0].AuthorisationServerCertifications[3]));
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers[1].AuthorisationServerCertifications.length, 3);
+        assert.ok(!filteredParticipants[0].AuthorisationServers[1].AuthorisationServerCertifications.includes(testData[0].AuthorisationServers[1].AuthorisationServerCertifications[2]));
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers[0].AuthorisationServerCertifications.length, 0);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers[0].AuthorisationServerCertifications.length, 1);
+    });
+});
+describe('removeInactiveAuthServers', () => {
+    it('should remove Auth Servers that do not have the Redirect:FAPI certification', () => {
+        const filteredParticipants = participantsFilter.removeInactiveAuthServers(getParticipantsTestData());
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers.length, 2);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers.length, 0);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers.length, 0);
+    });
+});
+describe('removeParticipantsWithoutAuthServers', () => {
+    it('should remove Participants that do not have any auth servers', () => {
+        const participants = getParticipantsTestData();
+        participants[1].AuthorisationServers = [];
+        const filteredParticipants = participantsFilter.removeParticipantsWithoutAuthServers(participants);
+        assert.strictEqual(filteredParticipants.length, 2);
+        assert.ok(filteredParticipants.includes(participants[0]));
+        assert.ok(filteredParticipants.includes(participants[2]));
+    });
+});
+describe('filterAuthServersForSupportedClaims', () => {
+    it('should filter auth servers that do not have the over25 required claims', () => {
+        const filteredParticipants = participantsFilter.filterAuthServersForSupportedClaims(getParticipantsTestData(), ['over25']);
+        const testData = getParticipantsTestData();
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers.length, 1);
+        assert.deepStrictEqual(filteredParticipants[0].AuthorisationServers[0], testData[0].AuthorisationServers[0]);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers.length, 0);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers.length, 0);
+    });
+    it('should filter auth servers that match multiple required claims', () => {
+        const filteredParticipants = participantsFilter.filterAuthServersForSupportedClaims(getParticipantsTestData(), ['address', 'over18']);
+        const testData = getParticipantsTestData();
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers.length, 0);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers.length, 1);
+        assert.deepStrictEqual(filteredParticipants[1].AuthorisationServers[0], testData[1].AuthorisationServers[0]);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers.length, 0);
+    });
+    it('should find auth servers with the name claim when asking for a name component', () => {
+        const filteredParticipants = participantsFilter.filterAuthServersForSupportedClaims(getParticipantsTestData(), ['given_name']);
+        const testData = getParticipantsTestData();
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers.length, 1);
+        assert.deepStrictEqual(filteredParticipants[0].AuthorisationServers[0], testData[0].AuthorisationServers[0]);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers.length, 0);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers.length, 0);
+    });
+});
+describe('removeFallbackIdentityServiceProvider', () => {
+    it('should filter out any manual verification auth servers', () => {
+        const filteredParticipants = participantsFilter.removeFallbackIdentityServiceProvider(getParticipantsTestData());
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers.length, 2);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers.length, 1);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers.length, 0);
+    });
+});
+describe('filterForFallbackIdentityServiceProviders', () => {
+    it('should return any auth servers that have the fallback provider certification', () => {
+        const filteredParticipants = participantsFilter.filterForFallbackIdentityServiceProviders(getParticipantsTestData());
+        const testData = getParticipantsTestData();
+        assert.strictEqual(filteredParticipants.length, 3);
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers.length, 0);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers.length, 0);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers.length, 1);
+        assert.deepStrictEqual(filteredParticipants[2], testData[2]);
+    });
+});
+describe('filterForRequiredCertifications', () => {
+    it('should return any auth servers that have the TDIF provider certification', () => {
+        const certificationFilters = [{ profileVariant: 'Identity Provider', profileType: 'TDIF Accreditation' }];
+        const filteredParticipants = participantsFilter.filterForRequiredCertifications(getParticipantsTestData(), certificationFilters);
+        const testData = getParticipantsTestData();
+        assert.deepStrictEqual(filteredParticipants[0].AuthorisationServers[0], testData[0].AuthorisationServers[1]);
+        assert.deepStrictEqual(filteredParticipants[1].AuthorisationServers[0], testData[1].AuthorisationServers[0]);
+        assert.strictEqual(filteredParticipants.length, 3);
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers.length, 1);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers.length, 1);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers.length, 0);
+    });
+    it('should return no auth servers when no auth servers have the requested certification', () => {
+        const certificationFilters = [{ profileType: 'Bad Profile', profileVariant: 'Bad Variant' }];
+        const filteredParticipants = participantsFilter.filterForRequiredCertifications(getParticipantsTestData(), certificationFilters);
+        assert.strictEqual(filteredParticipants.length, 3);
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers.length, 0);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers.length, 0);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers.length, 0);
+    });
+    it('should return only auth servers that have all matching certifications', () => {
+        const certificationFilters = [
+            { profileType: 'TDIF Accreditation', profileVariant: 'Identity Provider' },
+            { profileType: 'Channel', profileVariant: 'web' },
+        ];
+        const filteredParticipants = participantsFilter.filterForRequiredCertifications(getParticipantsTestData(), certificationFilters);
+        const testData = getParticipantsTestData();
+        assert.deepStrictEqual(filteredParticipants[0].AuthorisationServers[0], testData[0].AuthorisationServers[1]);
+        assert.strictEqual(filteredParticipants.length, 3);
+        assert.strictEqual(filteredParticipants[0].AuthorisationServers.length, 1);
+        assert.strictEqual(filteredParticipants[1].AuthorisationServers.length, 0);
+        assert.strictEqual(filteredParticipants[2].AuthorisationServers.length, 0);
+    });
+});
+function getParticipantsTestData() {
+    return JSON.parse(JSON.stringify(participantsTestData));
+}

package/src/tests/pushed-authorisation-request-endpoint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/tests/pushed-authorisation-request-endpoint.test.js

@@ -0,0 +1,159 @@
+import { PushedAuthorisationRequestEndpoint } from '../endpoints/pushed-authorisation-request-endpoint.js';
+import { config } from '../config.js';
+import { Agent } from 'undici';
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+describe('generateClaimsRequest', () => {
+    function createEndpoint(sdkConfig = config) {
+        const httpClient = new Agent();
+        const jwtHelper = {}; // Mock
+        const logger = {
+            info: () => { },
+            debug: () => { },
+            warn: () => { },
+            error: () => { },
+        };
+        const participantsEndpoint = {}; // Mock
+        return new PushedAuthorisationRequestEndpoint(sdkConfig, httpClient, jwtHelper, logger, participantsEndpoint);
+    }
+    it('should return name, birthdate essential claims', () => {
+        const endpoint = createEndpoint();
+        const claimsRequest = endpoint.generateClaimsRequest(['name', 'birthdate'], []);
+        const expected = {
+            id_token: {
+                name: { essential: true },
+                birthdate: { essential: true },
+            },
+        };
+        assert.deepEqual(claimsRequest, expected);
+    });
+    it('should return name essential, given_name essential, birthdate voluntary, email voluntary claims', () => {
+        const endpoint = createEndpoint();
+        const claimsRequest = endpoint.generateClaimsRequest(['name', 'given_name'], ['birthdate', 'email']);
+        const expected = {
+            id_token: {
+                name: { essential: true },
+                given_name: { essential: true },
+                email: { essential: false },
+                birthdate: { essential: false },
+            },
+        };
+        assert.deepEqual(claimsRequest, expected);
+    });
+    it('should return essential when claims are in both lists', () => {
+        const endpoint = createEndpoint();
+        const claimsRequest = endpoint.generateClaimsRequest(['name', 'given_name'], ['name', 'birthdate']);
+        const expected = {
+            id_token: {
+                name: { essential: true },
+                given_name: { essential: true },
+                birthdate: { essential: false },
+            },
+        };
+        assert.deepEqual(claimsRequest, expected);
+    });
+    it('should return only voluntary claims', () => {
+        const endpoint = createEndpoint();
+        const claimsRequest = endpoint.generateClaimsRequest([], ['name', 'birthdate']);
+        const expected = {
+            id_token: {
+                name: { essential: false },
+                birthdate: { essential: false },
+            },
+        };
+        assert.deepEqual(claimsRequest, expected);
+    });
+    it('should create essential extended claims', () => {
+        const endpoint = createEndpoint();
+        const claimsRequest = endpoint.generateClaimsRequest(['over18', 'over65'], []);
+        const expected = {
+            id_token: {
+                verified_claims: {
+                    verification: {
+                        trust_framework: { value: 'au_connectid' },
+                    },
+                    claims: {
+                        over18: { essential: true },
+                        over65: { essential: true },
+                    },
+                },
+            },
+        };
+        assert.deepEqual(claimsRequest, expected);
+    });
+    it('should create essential and voluntary extended claims', () => {
+        const endpoint = createEndpoint();
+        const claimsRequest = endpoint.generateClaimsRequest(['over18'], ['over65']);
+        const expected = {
+            id_token: {
+                verified_claims: {
+                    verification: {
+                        trust_framework: { value: 'au_connectid' },
+                    },
+                    claims: {
+                        over18: { essential: true },
+                        over65: { essential: false },
+                    },
+                },
+            },
+        };
+        assert.deepEqual(claimsRequest, expected);
+    });
+    it('should create extended claims and normal essential claims', () => {
+        const endpoint = createEndpoint();
+        const claimsRequest = endpoint.generateClaimsRequest(['given_name', 'over18'], []);
+        const expected = {
+            id_token: {
+                given_name: { essential: true },
+                verified_claims: {
+                    verification: {
+                        trust_framework: { value: 'au_connectid' },
+                    },
+                    claims: {
+                        over18: { essential: true },
+                    },
+                },
+            },
+        };
+        assert.deepEqual(claimsRequest, expected);
+    });
+    it('should create extended claims and normal essential and voluntary claims', () => {
+        const endpoint = createEndpoint();
+        const claimsRequest = endpoint.generateClaimsRequest(['given_name', 'over18'], ['last_name', 'over65']);
+        const expected = {
+            id_token: {
+                given_name: { essential: true },
+                last_name: { essential: false },
+                verified_claims: {
+                    verification: {
+                        trust_framework: { value: 'au_connectid' },
+                    },
+                    claims: {
+                        over18: { essential: true },
+                        over65: { essential: false },
+                    },
+                },
+            },
+        };
+        assert.deepEqual(claimsRequest, expected);
+    });
+    it('should create extended claims with beneficiary account', () => {
+        const endpoint = createEndpoint();
+        const claimsRequest = endpoint.generateClaimsRequest(['beneficiary_account_au', 'beneficiary_account_au_payid'], ['beneficiary_account_international']);
+        const expected = {
+            id_token: {
+                verified_claims: {
+                    verification: {
+                        trust_framework: { value: 'au_connectid' },
+                    },
+                    claims: {
+                        beneficiary_account_au: { essential: true },
+                        beneficiary_account_au_payid: { essential: true },
+                        beneficiary_account_international: { essential: false },
+                    },
+                },
+            },
+        };
+        assert.deepEqual(claimsRequest, expected);
+    });
+});

package/src/tests/relying-party-client-sdk.test.d.ts

@@ -0,0 +1 @@
+export {};