@wazo/sdk 0.43.15 → 0.44.0

package/src/domain/__tests__/Contact.test.ts

@@ -1,407 +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/src/domain/__tests__/IndirectTransfer.test.ts

@@ -1,68 +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,
-      } as any), new CallSession({
-        callId: destinationId,
-      } as any));
-      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,
-      } as any));
-      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,
-      } as any));
-      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,
-      } as any));
-      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,
-      } as any));
-      expect(isSource).toBeFalsy();
-    });
-  });
-});

package/src/domain/__tests__/Line.test.ts

@@ -1,53 +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/src/domain/__tests__/Meeting.test.ts

@@ -1,93 +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: any, key) => {
-      acc[key] = `some-${key}`;
-      return acc;
-    }, {});
-    const meeting = new Meeting(args) as any;
-    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/src/domain/__tests__/MeetingAuthorization.test.ts

@@ -1,50 +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);
-    });
-  });
-});