@wazo/sdk 0.43.14 → 0.44.0

package/esm/domain/__tests__/Contact.test.js

@@ -1,393 +0,0 @@
-import Contact from '../Contact';
-const genericContactResponse = {
-    column_types: [
-        'name',
-        'firstname',
-        'lastname',
-        'number',
-        'callable',
-        'voicemail',
-        'favorite',
-        'email',
-        'personal',
-    ],
-    term: 'a',
-    column_headers: [
-        'Nom',
-        'Pr\u00e9nom',
-        'Nom de famille',
-        'Num\u00e9ro',
-        'Mobile',
-        'Bo\u00eete vocale',
-        'Favoris',
-        'E-mail',
-        'Personnel',
-    ],
-    results: [],
-};
-const contact1 = {
-    source: 'internal',
-    column_values: [
-        'Jonathan Lessard',
-        'Jonathan',
-        'Lessard',
-        '8020',
-        '06800880',
-        null,
-        false,
-        'jonathan@example.com',
-        false,
-    ],
-    backend: 'wazo',
-    relations: {
-        user_id: 8,
-        xivo_id: '6cd695d2-cdb9-4444-8b2d-27425ab85fa8',
-        agent_id: null,
-        endpoint_id: 8,
-        user_uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
-        source_entry_id: '8',
-    },
-};
-const contact2 = {
-    source: 'internal',
-    column_values: [
-        'John Doe',
-        'John',
-        'Doe',
-        '8021',
-        '06800881',
-        null,
-        false,
-        'john@example.com',
-        false,
-    ],
-    backend: 'wazo',
-    relations: {
-        user_id: 9,
-        xivo_id: '6cd695d2-cdb9-4444-8b2d-27425ab85fa9',
-        agent_id: null,
-        endpoint_id: 9,
-        user_uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b55',
-        source_entry_id: '9',
-    },
-};
-const parsedContact1 = new Contact({
-    name: 'Jonathan Lessard',
-    firstName: 'Jonathan',
-    lastName: 'Lessard',
-    number: '8020',
-    numbers: [
-        {
-            label: 'primary',
-            number: '8020',
-        },
-        {
-            label: 'secondary',
-            number: '06800880',
-        },
-    ],
-    favorited: false,
-    email: 'jonathan@example.com',
-    emails: [
-        {
-            label: 'primary',
-            email: 'jonathan@example.com',
-        },
-    ],
-    address: '',
-    entreprise: '',
-    birthday: '',
-    note: '',
-    endpointId: 8,
-    personal: false,
-    source: 'internal',
-    sourceId: '8',
-    uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
-    backend: 'wazo',
-});
-const parsedContact2 = new Contact({
-    name: 'John Doe',
-    firstName: 'John',
-    lastName: 'Doe',
-    number: '8021',
-    numbers: [
-        {
-            label: 'primary',
-            number: '8021',
-        },
-        {
-            label: 'secondary',
-            number: '06800881',
-        },
-    ],
-    favorited: false,
-    email: 'john@example.com',
-    emails: [
-        {
-            label: 'primary',
-            email: 'john@example.com',
-        },
-    ],
-    address: '',
-    entreprise: '',
-    birthday: '',
-    note: '',
-    endpointId: 9,
-    personal: false,
-    source: 'internal',
-    sourceId: '9',
-    uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b55',
-    backend: 'wazo',
-});
-describe('Contact domain', () => {
-    it('is extern when given no uuid', () => {
-        const boba = new Contact({});
-        expect(boba.isIntern()).toBeFalsy();
-    });
-    it('is intern when given a uuid', () => {
-        const boba = new Contact({
-            uuid: '123',
-        });
-        expect(boba.isIntern()).toBeTruthy();
-    });
-    it('is the same contact when it has the same uuid and sourceId', () => {
-        const john = new Contact({
-            uuid: '12345',
-            sourceId: '800',
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        const sam = new Contact({
-            uuid: '12345',
-            sourceId: '800',
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        expect(john.is(sam)).toBe(true);
-    });
-    it('is the same contact when it has the same uuid and no sourceId', () => {
-        const john = new Contact({
-            uuid: '12345',
-            sourceId: undefined,
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        const sam = new Contact({
-            uuid: '12345',
-            sourceId: undefined,
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        expect(john.is(sam)).toBe(true);
-    });
-    it('is the same contact when it has the same uuid and no sourceId', () => {
-        const john = new Contact({
-            uuid: '12345',
-            sourceId: undefined,
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        const sam = new Contact({
-            uuid: '12345',
-            sourceId: undefined,
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        expect(john.is(sam)).toBe(true);
-    });
-    it('is the same contact when one is missing a uuid but they have the same sourceId', () => {
-        const john = new Contact({
-            uuid: '12345',
-            sourceId: '800',
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        const sam = new Contact({
-            uuid: undefined,
-            sourceId: '800',
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        expect(john.is(sam)).toBe(true);
-    });
-    it('is the same contact when one is missing a sourceId but they have the same sourceId', () => {
-        const john = new Contact({
-            uuid: '12345',
-            sourceId: '800',
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        const sam = new Contact({
-            uuid: '12345',
-            sourceId: undefined,
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        expect(john.is(sam)).toBe(true);
-    });
-    it('is the same contact even when it has different uuid', () => {
-        const john = new Contact({
-            uuid: 'abc',
-            sourceId: '800',
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        const sam = new Contact({
-            uuid: '12345',
-            sourceId: '800',
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        expect(john.is(sam)).toBe(true);
-    });
-    it('is the same contact even when it has different sourceId', () => {
-        const john = new Contact({
-            uuid: '12345',
-            sourceId: '100',
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        const sam = new Contact({
-            uuid: '12345',
-            sourceId: '800',
-            backend: 'some-backend',
-            source: 'wazo',
-        });
-        expect(john.is(sam)).toBe(true);
-    });
-    it('has the id given the same uuid', () => {
-        const contact = new Contact({
-            uuid: 'uuid-12345',
-        });
-        expect(contact.hasId('uuid-12345')).toBeTruthy();
-    });
-    it('does not have the id given a different uuid', () => {
-        const contact = new Contact({
-            uuid: 'uuid-12345',
-        });
-        expect(contact.hasId('uuid-dummy')).toBeFalsy();
-    });
-    it('does separate names with a single space', () => {
-        const contact = new Contact({
-            name: 'John Smith',
-        });
-        const { firstName, lastName } = contact.separateName();
-        expect(firstName).toBe('John');
-        expect(lastName).toBe('Smith');
-    });
-    it('does separate names with multiple spaces', () => {
-        const contact = new Contact({
-            name: 'John  Smith',
-        });
-        const { firstName, lastName } = contact.separateName();
-        expect(firstName).toBe('John');
-        expect(lastName).toBe('Smith');
-    });
-    it('is available given an available state', () => {
-        const contact = new Contact({
-            uuid: 'uuid-12345',
-            state: 'available',
-        });
-        expect(contact.isAvailable()).toBeTruthy();
-    });
-    it('is not available given a non available state', () => {
-        const contact = new Contact({
-            uuid: 'uuid-12345',
-            state: 'donotdisturb',
-        });
-        expect(contact.isAvailable()).toBeFalsy();
-    });
-    it('is not available given no state', () => {
-        const contact = new Contact({
-            uuid: 'uuid-12345',
-        });
-        expect(contact.isAvailable()).toBeFalsy();
-    });
-    it('can parse a plain contact to domain', () => {
-        const response = {
-            ...genericContactResponse,
-            results: [contact1],
-        };
-        const contact = Contact.parse(response.results[0], response.column_types);
-        expect(contact).toEqual(parsedContact1);
-    });
-    it('should merge 2 contact', () => {
-        const noBirthdayContact = new Contact({
-            uuid: 'uuid-12345',
-            lastActivity: 'yesterday',
-            birthday: undefined,
-        });
-        const noLastActivityContact = new Contact({
-            uuid: 'uuid-12345',
-            lastActivity: undefined,
-            birthday: 'tomorrow',
-        });
-        const result = noBirthdayContact.merge(noLastActivityContact);
-        expect(result.lastActivity).toBe('yesterday');
-        expect(result.birthday).toBe('tomorrow');
-    });
-    it('returns all contacts when parsing many contacts with no limit', () => {
-        const response = {
-            ...genericContactResponse,
-            results: [contact1, contact2],
-        };
-        const contacts = Contact.parseMany(response);
-        expect(contacts).toEqual([parsedContact1, parsedContact2]);
-    });
-    it('returns all contacts when parsing many contacts with a higher limit than number of results', () => {
-        const response = {
-            ...genericContactResponse,
-            results: [contact1, contact2],
-        };
-        const contacts = Contact.parseMany(response, 0, 1000);
-        expect(contacts).toEqual([parsedContact1, parsedContact2]);
-    });
-    it('returns limited contacts when parsing many contacts with a smaller limit than number of results', () => {
-        const response = {
-            ...genericContactResponse,
-            results: [contact1],
-        };
-        const contacts = Contact.parseMany(response, 0, 1);
-        expect(contacts).toEqual([parsedContact1]);
-    });
-    it('returns all contacts when parsing many contacts with same limit than number of results', () => {
-        const response = {
-            ...genericContactResponse,
-            results: [contact1, contact2],
-        };
-        const contacts = Contact.parseMany(response, 0, 2);
-        expect(contacts).toEqual([parsedContact1, parsedContact2]);
-    });
-    it('returns an empty array when parsing many contact with limit of 0', () => {
-        const response = {
-            ...genericContactResponse,
-            results: [contact1, contact2],
-        };
-        const contacts = Contact.parseMany(response, 0, 0);
-        expect(contacts).toEqual([]);
-    });
-    it('returns all contacts when parsing many contacts with a negative limit', () => {
-        const response = {
-            ...genericContactResponse,
-            results: [contact1, contact2],
-        };
-        const contacts = Contact.parseMany(response, 0, -1);
-        expect(contacts).toEqual([parsedContact1, parsedContact2]);
-    });
-    it('returns all contacts when parsing many contacts with a null limit', () => {
-        const response = {
-            ...genericContactResponse,
-            results: [contact1, contact2],
-        };
-        const contacts = Contact.parseMany(response, 0, null);
-        expect(contacts).toEqual([parsedContact1, parsedContact2]);
-    });
-    it('returns all contacts after the first one when parsing many contacts with an offset of 1', () => {
-        const response = {
-            ...genericContactResponse,
-            results: [contact1, contact2],
-        };
-        const contacts = Contact.parseMany(response, 1, null);
-        expect(contacts).toEqual([parsedContact2]);
-    });
-});

package/esm/domain/__tests__/IndirectTransfer.test.js

@@ -1,67 +0,0 @@
-import CallSession from '../CallSession';
-import IndirectTransfer from '../IndirectTransfer';
-describe('Indirect transfer', () => {
-    describe('on parse from call session', () => {
-        it('should return valid IndirectTransfer', async () => {
-            const sourceId = 'source-id';
-            const destinationId = 'destination-id';
-            const indirectTransfer = IndirectTransfer.parseFromCallSession(new CallSession({
-                callId: sourceId,
-            }), new CallSession({
-                callId: destinationId,
-            }));
-            expect(indirectTransfer).toEqual({
-                sourceId,
-                destinationId,
-            });
-        });
-    });
-    describe('on check destination', () => {
-        it('should match when destination is the same', async () => {
-            const destinationId = 'destination-id';
-            const indirectTransfer = new IndirectTransfer({
-                sourceId: 'some-id',
-                destinationId,
-            });
-            const isDestination = indirectTransfer.destinationIs(new CallSession({
-                callId: destinationId,
-            }));
-            expect(isDestination).toBeTruthy();
-        });
-        it('should NOT match when destination is the different', async () => {
-            const destinationId = 'destination-id';
-            const indirectTransfer = new IndirectTransfer({
-                sourceId: 'some-id',
-                destinationId: 'some-other-id',
-            });
-            const isDestination = indirectTransfer.destinationIs(new CallSession({
-                callId: destinationId,
-            }));
-            expect(isDestination).toBeFalsy();
-        });
-    });
-    describe('on check source', () => {
-        it('should match when source is the same', async () => {
-            const sourceId = 'source-id';
-            const indirectTransfer = new IndirectTransfer({
-                destinationId: 'some-id',
-                sourceId,
-            });
-            const isSource = indirectTransfer.sourceIs(new CallSession({
-                callId: sourceId,
-            }));
-            expect(isSource).toBeTruthy();
-        });
-        it('should NOT match when source is the different', async () => {
-            const sourceId = 'source-id';
-            const indirectTransfer = new IndirectTransfer({
-                sourceId: 'some-id',
-                destinationId: 'some-other-id',
-            });
-            const isSource = indirectTransfer.sourceIs(new CallSession({
-                callId: sourceId,
-            }));
-            expect(isSource).toBeFalsy();
-        });
-    });
-});

package/esm/domain/__tests__/Line.test.js

@@ -1,52 +0,0 @@
-import Line from '../Line';
-describe('Line domain', () => {
-    it('can parse a plain line to domain', () => {
-        const response = {
-            id: 8,
-            endpoint_sip: {
-                id: 19,
-                username: 'ipcor1pj',
-                links: [{
-                        href: 'https://stack.example.com/api/confd/1.1/endpoints/sip/19',
-                        rel: 'endpoint_sip',
-                    }],
-            },
-            endpoint_sccp: null,
-            endpoint_custom: null,
-            extensions: [{
-                    id: 59,
-                    exten: '8020',
-                    context: 'default',
-                    links: [{
-                            href: 'https://stack.example.com/api/confd/1.1/extensions/59',
-                            rel: 'extensions',
-                        }],
-                }],
-            links: [{
-                    href: 'https://stack.example.com/api/confd/1.1/lines/8',
-                    rel: 'lines',
-                }],
-        };
-        const line = Line.parse(response);
-        expect(line).toEqual(new Line({
-            id: 8,
-            extensions: [{
-                    id: 59,
-                    exten: '8020',
-                    context: 'default',
-                    links: [{
-                            href: 'https://stack.example.com/api/confd/1.1/extensions/59',
-                            rel: 'extensions',
-                        }],
-                }],
-            endpointSip: {
-                id: 19,
-                links: [{
-                        href: 'https://stack.example.com/api/confd/1.1/endpoints/sip/19',
-                        rel: 'endpoint_sip',
-                    }],
-                username: 'ipcor1pj',
-            },
-        }));
-    });
-});

package/esm/domain/__tests__/Meeting.test.js

@@ -1,77 +0,0 @@
-import moment from 'moment';
-import Meeting from '../Meeting';
-const rawCreationTime = '2021-12-21T15:56:42.880Z';
-describe('Meeting domain', () => {
-    it('should retain its values when parsed', () => {
-        const args = {
-            guest_sip_authorization: 'some-guest-sip-authorization',
-            ingress_http_uri: 'some-uri',
-            name: 'some-name',
-            owner_uuids: ['some-owner-uuid'],
-            port: 'some-port',
-            uuid: 'some-uuid',
-            exten: 'some-exten',
-            persistent: true,
-            creation_time: rawCreationTime,
-            require_authorization: true,
-        };
-        const meeting = Meeting.parse(args);
-        const { uri, uuid, name, port, extension, persistent, ownerUuids, creationTime, requireAuthorization, } = meeting;
-        expect(uri).toEqual(args.ingress_http_uri);
-        expect(uuid).toEqual(args.uuid);
-        expect(name).toEqual(args.name);
-        expect(port).toEqual(args.port);
-        expect(extension).toEqual(args.exten);
-        expect(persistent).toEqual(args.persistent);
-        expect(ownerUuids).toEqual(args.owner_uuids);
-        expect(creationTime).toEqual(moment(rawCreationTime).toDate());
-        expect(requireAuthorization).toEqual(args.require_authorization);
-    });
-    it('should retain its values when instantiated', () => {
-        const keys = ['uuid', 'name', 'guestSipAuthorization', 'ownerUuids', 'port', 'uri', 'extension', 'persistent', 'creationTime', 'requireAuthorization'];
-        const args = keys.reduce((acc, key) => {
-            acc[key] = `some-${key}`;
-            return acc;
-        }, {});
-        const meeting = new Meeting(args);
-        keys.forEach(key => expect(meeting[key]).toEqual(`some-${key}`));
-    });
-    it('can return username and secret from an base64 encrypted string', () => {
-        const USERNAME = 'username';
-        const SECRET = 'secret';
-        const args = {
-            guest_sip_authorization: Buffer.from(`${USERNAME}:${SECRET}`).toString('base64'),
-            creation_time: '',
-            ingress_http_uri: '',
-            name: '',
-            owner_uuids: [],
-            port: '',
-            uuid: '',
-            exten: '',
-            persistent: false,
-            require_authorization: false,
-        };
-        const meeting = Meeting.parse(args);
-        const { username, secret, } = meeting.getGuestSipCredentials();
-        expect(username).toEqual(USERNAME);
-        expect(secret).toEqual(SECRET);
-    });
-    it('should return a date from a string', () => {
-        const args = {
-            creation_time: rawCreationTime,
-            guest_sip_authorization: '',
-            ingress_http_uri: '',
-            name: '',
-            owner_uuids: [],
-            port: '',
-            uuid: '',
-            exten: '',
-            persistent: false,
-            require_authorization: false,
-        };
-        const { creationTime, } = Meeting.parse(args);
-        expect(creationTime.getDate()).toEqual(21);
-        expect(creationTime.getFullYear()).toEqual(2021);
-        expect(creationTime.getMonth()).toEqual(11);
-    });
-});

package/esm/domain/__tests__/MeetingAuthorization.test.js

@@ -1,49 +0,0 @@
-import MeetingAuthorization from '../MeetingAuthorization';
-describe('MeetingAuthorization', () => {
-    describe('parse', () => {
-        it('should parse a raw input', () => {
-            const rawAuthorization = {
-                created_at: 'today',
-                meeting_uuid: 'meeting_uuid',
-                uuid: 'uuid',
-                guest_uuid: 'guest_uuid',
-                guest_name: 'guest_name',
-            };
-            const authorization = {
-                meetingUuid: rawAuthorization.meeting_uuid,
-                uuid: rawAuthorization.uuid,
-                userUuid: rawAuthorization.guest_uuid,
-                userName: rawAuthorization.guest_name,
-                status: undefined,
-            };
-            const response = MeetingAuthorization.parse(rawAuthorization);
-            expect(response).toEqual(authorization);
-        });
-    });
-    describe('parseMany', () => {
-        it('should parse multiple raw inputs', () => {
-            const rawAuthorizations = [{
-                    created_at: 'today1',
-                    meeting_uuid: 'meeting_uuid1',
-                    uuid: 'uuid1',
-                    guest_uuid: 'guest_uuid1',
-                    guest_name: 'guest_name1',
-                }, {
-                    created_at: 'today2',
-                    meeting_uuid: 'meeting_uuid2',
-                    uuid: 'uuid2',
-                    guest_uuid: 'guest_uuid2',
-                    guest_name: 'guest_name2',
-                }];
-            const authorizations = rawAuthorizations.map(rawAuthorization => ({
-                meetingUuid: rawAuthorization.meeting_uuid,
-                uuid: rawAuthorization.uuid,
-                userUuid: rawAuthorization.guest_uuid,
-                userName: rawAuthorization.guest_name,
-                status: undefined,
-            }));
-            const response = MeetingAuthorization.parseMany(rawAuthorizations);
-            expect(response).toEqual(authorizations);
-        });
-    });
-});