k-space/wildflock
11
0
Fork 0
Code Issues Pull Requests Packages Projects Activity

Adding tests, bumping packages with audit warnings

Browse Source
This commit is contained in:
Sergo
2025-12-09 00:35:46 +02:00
parent 58363c2c1d
commit b8d4208caf
7 changed files with 2183 additions and 467 deletions
Download Patch File Download Diff File Expand all files Collapse all files

331
test/services/aliases/aliases.test.ts
View File

@@ -1,11 +1,340 @@
// For more information about this file see https://dove.feathersjs.com/guides/cli/service.test.html
import assert from 'assert';
import { app } from '../../../src/app';
import * as sinon from 'sinon';
import config from 'config';
import { faker } from '@faker-js/faker';
import wildDuckClient from '../../../src/clients/wildduck.client';
describe('aliases service', () => {
let sandbox: sinon.SinonSandbox;
beforeEach(() => {
sandbox = sinon.createSandbox();
});
afterEach(() => {
sandbox.restore();
});
it('registered the service', () => {
const service = app.service('aliases');
assert.ok(service, 'Registered the service');
});
it('creates a new alias successfully', async () => {
const service = app.service('aliases');
const configGetStub = sandbox.stub(config, 'get');
configGetStub.withArgs('wildDuck.domain').returns('example.com');
configGetStub.withArgs('wildDuck.preferredDomain').returns('example.com');
sandbox.stub(faker.git, 'commitSha').returns('abcd');
sandbox.stub(faker.color, 'human').returns('red');
sandbox.stub(faker.animal, 'snake').returns('snake');
sandbox.stub(wildDuckClient, 'get').callsFake((url: string) => {
if (url === 'addresses/resolve/user@example.com') {
return Promise.resolve({
data: {
success: true,
user: 'user123',
id: 'addr123',
address: 'user@example.com',
main: true,
tags: [],
created: '2025-01-01',
},
});
}
if (url === '/users/user123/addresses') {
return Promise.resolve({
data: {
success: true,
results: [
{
success: true,
id: 'alias456',
address: 'red-snake-abcd@example.com',
main: false,
user: 'user123',
tags: ['test'],
created: '2025-12-09T10:00:00Z',
},
],
},
});
}
return Promise.reject(new Error(`Unexpected URL: ${url}`));
});
sandbox.stub(wildDuckClient, 'post').resolves({
data: {
success: true,
id: 'alias456',
},
});
const params = {
session: {
user: {
emails: ['user@example.com'],
},
},
};
const data = { tags: ['test'] };
const result = await service.create(data, params);
assert.ok(Array.isArray(result), 'Result should be an array');
assert.strictEqual(result.length, 1, 'Result should contain one alias');
assert.strictEqual(
result[0].address,
'red-snake-abcd@example.com',
'Alias should have the expected address'
);
assert.deepStrictEqual(result[0].tags, ['test'], 'Alias should have the correct tags');
assert.ok(result[0].created, 'Alias should have a created date');
assert.strictEqual(result[0].id, 'alias456', 'Removable alias should have an id');
});
it('finds user aliases successfully', async () => {
const service = app.service('aliases');
const configGetStub = sandbox.stub(config, 'get');
configGetStub.withArgs('wildDuck.domain').returns('example.com');
configGetStub.withArgs('wildDuck.preferredDomain').returns('example.com');
sandbox.stub(wildDuckClient, 'get').callsFake((url: string) => {
if (url === 'addresses/resolve/user@example.com') {
return Promise.resolve({
data: {
success: true,
user: 'user123',
id: 'addr123',
address: 'user@example.com',
main: true,
tags: [],
created: '2025-01-01',
},
});
}
if (url === '/users/user123/addresses') {
return Promise.resolve({
data: {
success: true,
results: [
{
success: true,
id: 'alias456',
address: 'red-snake-abcd@example.com',
main: false,
user: 'user123',
tags: ['test'],
created: '2025-12-09T10:00:00Z',
},
{
success: true,
id: null,
address: 'user@example.com',
main: true,
user: 'user123',
tags: [],
created: '2025-01-01',
},
],
},
});
}
return Promise.reject(new Error(`Unexpected URL: ${url}`));
});
const params = {
session: {
user: {
emails: ['user@example.com'],
},
},
};
const result = await service.find(params);
assert.ok(Array.isArray(result), 'Result should be an array');
assert.strictEqual(result.length, 2, 'Result should contain two aliases');
assert.strictEqual(result[0].address, 'red-snake-abcd@example.com', 'First alias address');
assert.strictEqual(result[0].id, 'alias456', 'Removable alias has id');
assert.strictEqual(result[1].address, 'user@example.com', 'Second alias address');
assert.strictEqual(result[1].id, null, 'Main alias has no id');
});
it('removes an alias successfully', async () => {
const service = app.service('aliases');
const configGetStub = sandbox.stub(config, 'get');
configGetStub.withArgs('wildDuck.domain').returns('example.com');
configGetStub.withArgs('wildDuck.preferredDomain').returns('example.com');
sandbox.stub(wildDuckClient, 'get').callsFake((url: string) => {
if (url === 'addresses/resolve/user@example.com') {
return Promise.resolve({
data: {
success: true,
user: 'user123',
id: 'addr123',
address: 'user@example.com',
main: true,
tags: [],
created: '2025-01-01',
},
});
}
if (url === 'addresses/resolve/alias456') {
return Promise.resolve({
data: {
success: true,
id: 'alias456',
address: 'red-snake-abcd@example.com',
main: false,
user: 'user123',
tags: ['test'],
created: '2025-12-09T10:00:00Z',
},
});
}
if (url === '/users/user123/addresses') {
return Promise.resolve({
data: {
success: true,
results: [],
},
});
}
return Promise.reject(new Error(`Unexpected URL: ${url}`));
});
sandbox.stub(wildDuckClient, 'delete').resolves({
data: {
success: true,
},
});
const params = {
session: {
user: {
emails: ['user@example.com'],
},
},
};
const result = await service.remove('alias456', params);
assert.ok(Array.isArray(result), 'Result should be an array');
assert.strictEqual(result.length, 0, 'Result should be empty after deletion');
});
it('throws error when creating alias fails', async () => {
const service = app.service('aliases');
const configGetStub = sandbox.stub(config, 'get');
configGetStub.withArgs('wildDuck.domain').returns('example.com');
configGetStub.withArgs('wildDuck.preferredDomain').returns('example.com');
sandbox.stub(faker.git, 'commitSha').returns('abcd');
sandbox.stub(faker.color, 'human').returns('red');
sandbox.stub(faker.animal, 'snake').returns('snake');
sandbox.stub(wildDuckClient, 'get').callsFake((url: string) => {
if (url === 'addresses/resolve/user@example.com') {
return Promise.resolve({
data: {
success: true,
user: 'user123',
id: 'addr123',
address: 'user@example.com',
main: true,
tags: [],
created: '2025-01-01',
},
});
}
return Promise.reject(new Error(`Unexpected URL: ${url}`));
});
sandbox.stub(wildDuckClient, 'post').resolves({
data: {
success: false,
},
});
const params = {
session: {
user: {
emails: ['user@example.com'],
},
},
};
const data = { tags: ['test'] };
try {
await service.create(data, params);
assert.fail('Should have thrown an error');
} catch (error: any) {
assert.strictEqual(error.message, 'Failed to create alias');
}
});
it('throws error when removing alias with invalid domain', async () => {
const service = app.service('aliases');
const configGetStub = sandbox.stub(config, 'get');
configGetStub.withArgs('wildDuck.domain').returns('example.com');
configGetStub.withArgs('wildDuck.preferredDomain').returns('example.com');
sandbox.stub(wildDuckClient, 'get').callsFake((url: string) => {
if (url === 'addresses/resolve/user@example.com') {
return Promise.resolve({
data: {
success: true,
user: 'user123',
id: 'addr123',
address: 'user@example.com',
main: true,
tags: [],
created: '2025-01-01',
},
});
}
if (url === 'addresses/resolve/alias456') {
return Promise.resolve({
data: {
success: true,
id: 'alias456',
address: 'red-snake-abcd@invalid.com',
main: false,
user: 'user123',
tags: ['test'],
created: '2025-12-09T10:00:00Z',
},
});
}
return Promise.reject(new Error(`Unexpected URL: ${url}`));
});
const params = {
session: {
user: {
emails: ['user@example.com'],
},
},
};
try {
await service.remove('alias456', params);
assert.fail('Should have thrown an error');
} catch (error: any) {
assert.strictEqual(error.message, 'Unable to delete address');
}
});
});

54
test/services/auth-oidc/auth-oidc.test.ts
View File

@@ -1,11 +1,63 @@
// For more information about this file see https://dove.feathersjs.com/guides/cli/service.test.html
import assert from 'assert';
import { app } from '../../../src/app';
import * as sinon from 'sinon';
import config from 'config';
import { Issuer, generators } from 'openid-client';
describe('auth-oidc service', () => {
let sandbox: sinon.SinonSandbox;
beforeEach(() => {
sandbox = sinon.createSandbox();
});
afterEach(() => {
sandbox.restore();
});
it('registered the service', () => {
const service = app.service('auth-oidc');
assert.ok(service, 'Registered the service');
});
it('initiates OIDC authentication flow', async () => {
const service = app.service('auth-oidc');
const configGetStub = sandbox.stub(config, 'get');
configGetStub.withArgs('oidc.gatewayUri').returns('https://oidc.example.com');
configGetStub.withArgs('oidc.clientId').returns('client123');
configGetStub.withArgs('oidc.clientSecret').returns('secret123');
configGetStub.withArgs('oidc.redirectUris').returns(['https://app.example.com/auth-oidc/callback']);
configGetStub.withArgs('oidc.responseTypes').returns('code');
configGetStub.withArgs('oidc.signedResponseAlg').returns('RS256');
configGetStub.withArgs('oidc.authMethod').returns('client_secret_basic');
configGetStub.withArgs('clientUrl').returns('https://app.example.com');
configGetStub.withArgs('oidc.scopes').returns('openid profile email');
configGetStub.withArgs('oidc.codeChallengeMethod').returns('S256');
const mockClient = {
authorizationUrl: sandbox.stub().returns('https://oidc.example.com/auth?code_challenge=abc123'),
};
const mockIssuer = {
Client: sandbox.stub().returns(mockClient),
};
sandbox.stub(Issuer, 'discover').resolves(mockIssuer as any);
sandbox.stub(generators, 'codeVerifier').returns('verifier123');
sandbox.stub(generators, 'codeChallenge').returns('challenge123');
const params = {
session: {} as any,
};
const result = await service.find(params);
assert.strictEqual(typeof result, 'string', 'Result should be a string URL');
assert.ok(result.includes('https://oidc.example.com/auth'), 'Result should be the auth URL');
assert.strictEqual(params.session.codeVerifier, 'verifier123', 'Code verifier should be stored in session');
assert.ok(mockClient.authorizationUrl.calledOnce, 'Authorization URL should be generated');
});
});

62
test/services/auth-oidc/callback/callback.test.ts
View File

@@ -1,11 +1,71 @@
// For more information about this file see https://dove.feathersjs.com/guides/cli/service.test.html
import assert from 'assert';
import { app } from '../../../../src/app';
import * as sinon from 'sinon';
import config from 'config';
import { Issuer } from 'openid-client';
describe('auth-oidc/callback service', () => {
let sandbox: sinon.SinonSandbox;
beforeEach(() => {
sandbox = sinon.createSandbox();
});
afterEach(() => {
sandbox.restore();
});
it('registered the service', () => {
const service = app.service('auth-oidc/callback');
assert.ok(service, 'Registered the service');
});
it('completes OIDC authentication and sets user session', async () => {
const service = app.service('auth-oidc/callback');
const configGetStub = sandbox.stub(config, 'get');
configGetStub.withArgs('oidc.gatewayUri').returns('https://oidc.example.com');
configGetStub.withArgs('oidc.clientId').returns('client123');
configGetStub.withArgs('oidc.clientSecret').returns('secret123');
configGetStub.withArgs('oidc.redirectUris').returns(['https://app.example.com/auth-oidc/callback']);
configGetStub.withArgs('clientUrl').returns('https://app.example.com');
const mockTokenSet = {
access_token: 'access123',
id_token: 'id123',
};
const mockUserinfo = {
sub: 'user123',
email: 'user@example.com',
name: 'Test User',
};
const mockClient = {
callback: sandbox.stub().resolves(mockTokenSet),
userinfo: sandbox.stub().resolves(mockUserinfo),
};
const mockIssuer = {
Client: sandbox.stub().returns(mockClient),
};
sandbox.stub(Issuer, 'discover').resolves(mockIssuer as any);
const params = {
session: { codeVerifier: 'verifier123' } as any,
query: {
iss: 'https://oidc.example.com',
code: 'authcode123',
},
};
const result = await service.find(params);
assert.strictEqual(result, '/', 'Result should be the redirect path');
assert.deepStrictEqual(params.session.user, mockUserinfo, 'User info should be stored in session');
assert.ok(mockClient.callback.calledOnce, 'Callback should be called');
assert.ok(mockClient.userinfo.calledOnce, 'Userinfo should be fetched');
});
});