• Index
• Search by APIs
• Search by Words
• Project Search

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• linkedin-private-api-master
  • .github
    • dependabot.yml
    • workflows
      • ci.yml
      • codeql-analysis.yml
  • .eslintignore
  • src
    • scrollers
      • conversation.scroller.ts
      • index.ts
      • created-before-scroller.ts
      • company-search.scroller.ts
      • job-search.scroller.ts
      • invitation.scroller.ts
      • people-search.scroller.ts
      • message.scroller.ts
      • skip-limit-scroller.ts
    • utils
      • index.ts
      • paramsSerializer.ts
    • index.ts
    • repositories
      • profile.repository.ts
      • message.repository.ts
      • index.ts
      • search.repository.ts
      • invitation.repository.ts
      • conversation.repository.ts
    • responses
      • conversations.response.get.ts
      • own-profile.response.get.ts
      • message.response.post.ts
      • blended-search.reponse.get.ts
      • index.ts
      • conversation.response.get.ts
      • profile.response.get.ts
      • sent-invitations.response.get.ts
      • received-invitations.response.get.ts
      • messages.response.get.ts
      • jobs-search.reponse.get.ts
    • types
      • experience.enum.ts
      • contract-interest.enum.ts
      • language-code.enum.ts
      • job-search-filters.ts
      • auth-cookies.ts
      • index.ts
      • people-search-filters.ts
      • country-code.enum.ts
      • blended-search-filters.ts
      • client.interface.ts
      • anonymous-cookies.ts
      • search-result-type.enum.ts
      • job-type.enum.ts
      • search-type.enum.ts
      • network.enum.ts
    • core
      • linkedin-request.ts
      • login.ts
      • request.ts
      • index.ts
      • client.ts
    • entities
      • conversation.entity.ts
      • linkedin-mini-profile.entity.ts
      • message-event.entity.ts
      • linkedin-search-cluster.entity.ts
      • linkedin-text-view-model.entity.ts
      • invitation.entity.ts
      • linkedin-job-search-hit-entity.ts
      • linkedin-base-company.ts
      • linkedin-quick-replay-recommendation.entity.ts
      • job-search-hit.entity.ts
      • linkedin-vector-image.entity.ts
      • people-search-hit.entity.ts
      • index.ts
      • company-search-hit.entity.ts
      • message-create-response.entity.ts
      • linkedin-conversation.entity.ts
      • linkedin-image-view-model.entity.ts
      • linkedin-job-posting.ts
      • linkedin-invitation.entity.ts
      • linkedin-attribute-text.entity.ts
      • linkedin-search-hit-entity.ts
      • linkedin-collection-response.entity.ts
      • linkedin-event.entity.ts
      • linkedin-vector-artifact.entity.ts
      • linkedin-event-create-response.ts
      • linkedin-image-attribute.entity.ts
      • linkedin-search-hit-v2.entity.ts
      • mini-company.entity.ts
      • linkedin-mini-company.entity.ts
      • linkedin-company.entity.ts
      • mini-profile.entity.ts
      • linkedin-message-event.entity.ts
      • profile.entity.ts
      • linkedin-profile.entity.ts
      • linkedin-message.entity.ts
    • requests
      • profile.request.ts
      • invitation.request.ts
      • message.request.ts
      • auth.request.ts
      • search.request.ts
      • conversation.request.ts
  • jest.config.js
  • typedoc.json
  • .npmignore
  • examples
    • profile.ts
    • invitation.ts
    • conversation.ts
    • search.ts
    • message.ts
  • .prettierrc
  • index.ts
  • LICENSE
  • test
    • utils
      • defaultMocks.ts
      • mockAxios.ts
      • mockLogin.ts
    • setup.ts
    • search
      • search-repository.spec.ts
      • search-factories.ts
    • message
      • message-repository.spec.ts
      • message-factories.ts
    • conversation
      • conversation-factories.ts
      • conversation-repository.spec.ts
    • index.d.ts
    • profile
      • get-profiles-from-response.spec.ts
      • profile-repository.spec.ts
      • profile-factories.ts
    • .eslintrc.js
    • invitation
      • invitation-factories.ts
      • invitation-repository.spec.ts
    • login
      • login.spec.ts
  • commitlint.config.js
  • config
    • index.ts
  • tsconfig.build.json
  • README.md
  • package.json
  • .eslintrc.js
  • tsconfig.json
  • .gitignore
  • docs
    • classes
      • _src_scrollers_skip_limit_scroller_.skiplimitscroller.md
      • _src_scrollers_message_scroller_.messagescroller.md
      • _src_scrollers_company_search_scroller_.companysearchscroller.md
      • _src_scrollers_created_before_scroller_.createdbeforescroller.md
      • _src_repositories_search_repository_.searchrepository.md
      • _src_repositories_conversation_repository_.conversationrepository.md
      • _src_core_client_.client.md
      • _src_scrollers_invitation_scroller_.invitationscroller.md
      • _src_core_request_.request.md
      • _src_core_login_.login.md
      • _src_scrollers_people_search_scroller_.peoplesearchscroller.md
      • _src_repositories_invitation_repository_.invitationrepository.md
      • _src_scrollers_job_search_scroller_.jobsearchscroller.md
      • _src_repositories_profile_repository_.profilerepository.md
      • _src_scrollers_conversation_scroller_.conversationscroller.md
      • _src_core_linkedin_request_.linkedinrequest.md
      • _src_repositories_message_repository_.messagerepository.md
    • globals.md
    • enums
      • _src_entities_linkedin_conversation_entity_.featuredtype.md
    • README.md
    • interfaces
      • _src_entities_linkedin_job_posting_.linkedinjobposting.md
      • _src_entities_linkedin_text_view_model_entity_.linkedintextviewmodel.md
      • _src_entities_linkedin_search_hit_v2_entity_.linkedinsearchhitv2.md
      • _src_entities_linkedin_base_company_.linkedinbasecompany.md
      • _src_entities_job_search_hit_entity_.populatedjobhitinfo.md
      • _src_entities_linkedin_vector_artifact_entity_.linkedinvectorartifact.md
      • _src_entities_linkedin_search_hit_entity_.linkedinsearchhit.md
      • _src_entities_linkedin_mini_profile_entity_.linkedinminiprofile.md
      • _src_entities_linkedin_company_entity_.linkedincompany.md
      • _src_entities_linkedin_job_search_hit_entity_.linkedinjobsearchhit.md
      • _src_entities_message_create_response_entity_.messageeventcreateresponse.md
      • _src_entities_profile_entity_.profile.md
      • _src_entities_linkedin_image_attribute_entity_.linkedinimageattribute.md
      • _src_entities_linkedin_attribute_text_entity_.attributetext.md
      • _src_entities_linkedin_event_create_response_.linkedeventcreateresponse.md
      • _src_entities_linkedin_vector_image_entity_.linkedinvectorimage.md
      • _src_entities_linkedin_message_entity_.linkedinmessage.md
      • _src_entities_linkedin_profile_entity_.linkedinphotofilterpicture.md
      • _src_entities_linkedin_search_cluster_entity_.linkedinsearchcluster.md
      • _src_entities_job_search_hit_entity_.populatedjobposting.md
      • _src_entities_linkedin_event_entity_.linkedinevent.md
      • _src_entities_message_event_entity_.messageevent.md
      • _src_entities_company_search_hit_entity_.companysearchhit.md
      • _src_entities_linkedin_image_view_model_entity_.linkedinimageviewmodel.md
      • _src_entities_linkedin_job_posting_.linkedinjobpostingcompany.md
      • _src_entities_linkedin_invitation_entity_.linkedininvitation.md
      • _src_entities_people_search_hit_entity_.peoplesearchhit.md
      • _src_entities_mini_profile_entity_.miniprofile.md
      • _src_entities_mini_company_entity_.minicompany.md
      • _src_entities_linkedin_conversation_entity_.linkedinconversation.md
      • _src_entities_linkedin_conversation_entity_.linkedinparticipantreceipts.md
      • _src_entities_linkedin_collection_response_entity_.linkedincollectionresponse.md
      • _src_entities_linkedin_profile_entity_.linkedinprofile.md
      • _src_entities_linkedin_mini_company_entity_.linkedinminicompany.md
      • _src_entities_job_search_hit_entity_.populatedjobpostingcompany.md
      • _src_entities_invitation_entity_.invitation.md
      • _src_entities_linkedin_quick_replay_recommendation_entity_.quickreplayrecommendation.md
      • _src_entities_linkedin_message_event_entity_.linkedinmessageevent.md
      • _src_entities_conversation_entity_.conversation.md
    • modules
      • _src_entities_linkedin_vector_image_entity_.md
      • _src_entities_linkedin_search_hit_v2_entity_.md
      • _src_scrollers_conversation_scroller_.md
      • _src_repositories_conversation_repository_.md
      • _src_scrollers_people_search_scroller_.md
      • _src_entities_linkedin_quick_replay_recommendation_entity_.md
      • _src_core_linkedin_request_.md
      • _src_entities_linkedin_mini_company_entity_.md
      • _src_entities_profile_entity_.md
      • _src_core_request_.md
      • _src_repositories_profile_repository_.md
      • _src_entities_linkedin_invitation_entity_.md
      • _src_entities_linkedin_profile_entity_.md
      • _src_entities_linkedin_conversation_entity_.md
      • _src_entities_linkedin_job_posting_.md
      • _src_core_client_.md
      • _src_scrollers_skip_limit_scroller_.md
      • _src_core_login_.md
      • _src_scrollers_message_scroller_.md
      • _src_entities_linkedin_base_company_.md
      • _src_entities_linkedin_company_entity_.md
      • _src_entities_linkedin_mini_profile_entity_.md
      • _src_entities_linkedin_collection_response_entity_.md
      • _src_repositories_invitation_repository_.md
      • _src_index_.md
      • _src_core_index_.md
      • _src_entities_linkedin_text_view_model_entity_.md
      • _src_entities_invitation_entity_.md
      • _src_entities_job_search_hit_entity_.md
      • _src_repositories_index_.md
      • _src_entities_linkedin_image_attribute_entity_.md
      • _src_repositories_message_repository_.md
      • _src_entities_mini_profile_entity_.md
      • _src_entities_message_create_response_entity_.md
      • _src_entities_linkedin_message_event_entity_.md
      • _src_scrollers_company_search_scroller_.md
      • _src_scrollers_created_before_scroller_.md
      • _src_entities_linkedin_image_view_model_entity_.md
      • _src_entities_linkedin_event_create_response_.md
      • _src_scrollers_index_.md
      • _src_entities_message_event_entity_.md
      • _src_entities_company_search_hit_entity_.md
      • _src_entities_linkedin_search_hit_entity_.md
      • _src_entities_linkedin_message_entity_.md
      • _src_scrollers_job_search_scroller_.md
      • _src_entities_linkedin_search_cluster_entity_.md
      • _src_entities_linkedin_attribute_text_entity_.md
      • _src_entities_linkedin_vector_artifact_entity_.md
      • _src_repositories_search_repository_.md
      • _src_entities_index_.md
      • _src_entities_people_search_hit_entity_.md
      • _src_scrollers_invitation_scroller_.md
      • _src_entities_conversation_entity_.md
      • _src_entities_linkedin_job_search_hit_entity_.md
      • _src_entities_mini_company_entity_.md
      • _src_entities_linkedin_event_entity_.md

import faker from 'faker';
import { keyBy, omit, orderBy } from 'lodash';
import { reset, verify, when } from 'testdouble';
import { URL } from 'url';

import { linkedinApiUrl } from '../../config';
import { defaultMocks } from '../utils/defaultMocks';
import { createGetMessagesResponse, createSendMessageResponse } from './message-factories';

const conversationId = faker.datatype.uuid();
const requestUrl = new URL(`messaging/conversations/${conversationId}/events`, linkedinApiUrl).toString();
const username = 'username';
const password = 'password';
let axios: any;
let Client: any;

beforeEach(async () => {
  ({ axios, Client } = await defaultMocks());
});

afterEach(() => {
  reset();
});

describe('getMessages', () => {
  const reqParams = {
    keyVersion: 'LEGACY_INBOX',
  };

  it('should fetch first page of messages', async () => {
    const { response, resultMessages } = createGetMessagesResponse(10);
    const keyedConversations = keyBy(resultMessages, 'entityUrn');

    when(axios.get(requestUrl, { params: reqParams })).thenResolve({ data: response });

    const client = await new Client().login.userPass({ username, password });
    const messagesScroller = client.message.getMessages({ conversationId });
    const messages = await messagesScroller.scrollNext();

    expect(messages.length).toEqual(10);
    messages.forEach((message: any) => {
      expect(omit(message, ['text', 'sentFrom'])).toEqual(keyedConversations[message.entityUrn]);
    });
  });

  it('should sort messages by createdAt descending', async () => {
    const { response } = createGetMessagesResponse(10);

    when(axios.get(requestUrl, { params: reqParams })).thenResolve({ data: response });

    const client = await new Client().login.userPass({ username, password });
    const messagesScroller = client.message.getMessages({ conversationId });
    const messages = await messagesScroller.scrollNext();

    expect(messages.length).toEqual(10);
    expect(messages).toEqual(orderBy(messages, 'createdAt', 'desc'));
  });

  it('should fetch first page of messages before specific date', async () => {
    const now = new Date();
    const { response, resultMessages } = createGetMessagesResponse(10);
    const keyedConversations = keyBy(resultMessages, 'entityUrn');

    when(axios.get(requestUrl, { params: { ...reqParams, createdBefore: now.getTime() } })).thenResolve({ data: response });

    const client = await new Client().login.userPass({ username, password });
    const messagesScroller = client.message.getMessages({ conversationId, createdBefore: now });
    const messages = await messagesScroller.scrollNext();

    expect(messages.length).toEqual(10);
    messages.forEach((message: any) => {
      expect(omit(message, ['text', 'sentFrom'])).toEqual(keyedConversations[message.entityUrn]);
    });
  });

  it('should add the text message in the root of the result ', async () => {
    const { response, resultMessages } = createGetMessagesResponse(1);
    const mockedResultMessage = resultMessages[0];

    when(axios.get(requestUrl, { params: reqParams })).thenResolve({ data: response });

    const client = await new Client().login.userPass({ username, password });
    const messagesScroller = client.message.getMessages({ conversationId });
    const messages = await messagesScroller.scrollNext();

    expect(messages.length).toEqual(1);
    expect(messages[0].text).toEqual(mockedResultMessage.eventContent?.attributedBody.text);
  });

  it('should add sentFrom on the result', async () => {
    const { response, resultMessages, resultProfiles } = createGetMessagesResponse(1);
    const profileId = resultProfiles[0].entityUrn.replace('urn:li:fs_miniProfile:', '');

    const participantId = `urn:li:fs_messagingMember:(${faker.datatype.number()},${profileId})`;
    resultMessages[0]['*from'] = participantId;

    when(axios.get(requestUrl, { params: reqParams })).thenResolve({ data: response });

    const client = await new Client().login.userPass({ username, password });
    const messagesScroller = client.message.getMessages({ conversationId });
    const messages = await messagesScroller.scrollNext();

    expect(messages[0].sentFrom.entityUrn).toEqual(resultProfiles[0].entityUrn);
    expect(messages[0].sentFrom.profileId).toEqual(profileId);
  });

  it('should be able to scroll messages using scroller', async () => {
    const { response: firstPageResponse, resultMessages: firstPageMockedMessages } = createGetMessagesResponse(10);
    const { response: secondPageResponse, resultMessages: secondPageMockedMessages } = createGetMessagesResponse(10);
    const { response: thirdPageResponse } = createGetMessagesResponse(10);

    when(axios.get(requestUrl, { params: reqParams })).thenResolve({
      data: firstPageResponse,
    });
    when(axios.get(requestUrl, { params: { ...reqParams, createdBefore: firstPageMockedMessages[9].createdAt } })).thenResolve({
      data: secondPageResponse,
    });
    when(axios.get(requestUrl, { params: { ...reqParams, createdBefore: secondPageMockedMessages[9].createdAt } })).thenResolve({
      data: thirdPageResponse,
    });

    const client = await new Client().login.userPass({ username, password });
    const messagesScroller = client.message.getMessages({ conversationId });
    const firstPageMessages = await messagesScroller.scrollNext();
    const secondPageMessages = await messagesScroller.scrollNext();
    const thirdPageMessages = await messagesScroller.scrollNext();

    expect(firstPageMessages.length).toEqual(10);
    expect(secondPageMessages.length).toEqual(10);
    expect(thirdPageMessages.length).toEqual(10);

    expect(firstPageMessages).not.toEqual(secondPageMessages);
    expect(firstPageMessages).not.toEqual(thirdPageMessages);
    expect(secondPageMessages).not.toEqual(thirdPageMessages);

    [...firstPageMessages, ...firstPageMessages, ...thirdPageMessages].forEach((p: any) => {
      expect(p.$type).toEqual('com.linkedin.voyager.messaging.Event');
    });
  });

  it('should be able to restart scroller position', async () => {
    const { response: firstPageResponse } = createGetMessagesResponse(10);

    when(axios.get(requestUrl, { params: reqParams })).thenResolve({
      data: firstPageResponse,
    });

    const client = await new Client().login.userPass({ username, password });
    const messagesScroller = client.message.getMessages({ conversationId });

    const firstPageMessages = await messagesScroller.scrollNext();

    messagesScroller.restart();

    const secondPageMessages = await messagesScroller.scrollNext();

    expect(firstPageMessages.length).toEqual(10);
    expect(firstPageMessages).toEqual(secondPageMessages);

    firstPageMessages.forEach((p: any) => {
      expect(p.$type).toEqual('com.linkedin.voyager.messaging.Event');
    });
  });

  it('should be able to override scroller starting point', async () => {
    const createdBefore = new Date();

    const { response: firstPageResponse, resultMessages: firstPageMockedMessages } = createGetMessagesResponse(10);
    const { response: secondPageResponse, resultMessages: secondPageMockedMessages } = createGetMessagesResponse(10);
    const { response: thirdPageResponse } = createGetMessagesResponse(10);

    when(axios.get(requestUrl, { params: { ...reqParams, createdBefore: createdBefore.getTime() } })).thenResolve({
      data: firstPageResponse,
    });
    when(axios.get(requestUrl, { params: { ...reqParams, createdBefore: firstPageMockedMessages[9].createdAt } })).thenResolve({
      data: secondPageResponse,
    });
    when(axios.get(requestUrl, { params: { ...reqParams, createdBefore: secondPageMockedMessages[9].createdAt } })).thenResolve({
      data: thirdPageResponse,
    });

    const client = await new Client().login.userPass({ username, password });
    const messagesScroller = client.message.getMessages({ conversationId, createdBefore });
    const firstPageMessages = await messagesScroller.scrollNext();
    const secondPageMessages = await messagesScroller.scrollNext();
    const thirdPageMessages = await messagesScroller.scrollNext();

    expect(firstPageMessages.length).toEqual(10);
    expect(secondPageMessages.length).toEqual(10);
    expect(thirdPageMessages.length).toEqual(10);

    expect(firstPageMessages).not.toEqual(secondPageMessages);
    expect(firstPageMessages).not.toEqual(thirdPageMessages);
    expect(secondPageMessages).not.toEqual(thirdPageMessages);

    [...firstPageMessages, ...firstPageMessages, ...thirdPageMessages].forEach((p: any) => {
      expect(p.$type).toEqual('com.linkedin.voyager.messaging.Event');
    });
  });

  it('should be able to scroll to previous response pages', async () => {
    const { response: firstPageResponse, resultMessages: firstPageMockedMessages } = createGetMessagesResponse(10);
    const { response: secondPageResponse, resultMessages: secondPageMockedMessages } = createGetMessagesResponse(10);
    const { response: thirdPageResponse } = createGetMessagesResponse(10);

    when(axios.get(requestUrl, { params: reqParams })).thenResolve({
      data: firstPageResponse,
    });
    when(
      axios.get(requestUrl, { params: { ...reqParams, createdBefore: firstPageMockedMessages[0].createdAt! + 1000 } }),
    ).thenResolve({
      data: firstPageResponse,
    });
    when(axios.get(requestUrl, { params: { ...reqParams, createdBefore: firstPageMockedMessages[9].createdAt } }), {
      times: 2,
    }).thenResolve({
      data: secondPageResponse,
    });
    when(axios.get(requestUrl, { params: { ...reqParams, createdBefore: secondPageMockedMessages[9].createdAt } })).thenResolve({
      data: thirdPageResponse,
    });

    const client = await new Client().login.userPass({ username, password });
    const messagesScroller = client.message.getMessages({ conversationId });
    const firstPageMessages = await messagesScroller.scrollNext();
    const secondPageMessages = await messagesScroller.scrollNext();
    const thirdPageMessages = await messagesScroller.scrollNext();
    const fourthPageMessages = await messagesScroller.scrollBack();
    const fifthPageMessages = await messagesScroller.scrollBack();

    expect(firstPageMessages.length).toEqual(10);
    expect(secondPageMessages.length).toEqual(10);
    expect(thirdPageMessages.length).toEqual(10);

    expect(firstPageMessages).not.toEqual(secondPageMessages);
    expect(firstPageMessages).not.toEqual(thirdPageMessages);
    expect(secondPageMessages).not.toEqual(thirdPageMessages);
    expect(fourthPageMessages).toEqual(secondPageMessages);
    expect(fifthPageMessages).toEqual(firstPageMessages);

    [...firstPageMessages, ...firstPageMessages, ...thirdPageMessages].forEach((p: any) => {
      expect(p.$type).toEqual('com.linkedin.voyager.messaging.Event');
    });
  });

  it('should be return empty array if trying to scroll back from the starting point', async () => {
    const { response: firstPageResponse } = createGetMessagesResponse(10);

    when(axios.get(requestUrl, { params: reqParams })).thenResolve({
      data: firstPageResponse,
    });

    const client = await new Client().login.userPass({ username, password });
    const messagesScroller = client.message.getMessages({ conversationId });
    await messagesScroller.scrollNext();
    const messages = await messagesScroller.scrollBack();

    expect(messages).toEqual([]);
  });
});

describe('sendMessage', () => {
  const sendMessageRequestUrl = new URL('messaging/conversations', linkedinApiUrl).toString();
  const profileId = faker.datatype.uuid();
  const text = faker.lorem.sentence();
  const queryParams = {
    action: 'create',
  };
  const payload = {
    keyVersion: 'LEGACY_INBOX',
    conversationCreate: {
      eventCreate: {
        value: {
          'com.linkedin.voyager.messaging.create.MessageCreate': {
            attributedBody: {
              text,
              attributes: [],
            },
            attachments: [],
          },
        },
      },
      subtype: 'MEMBER_TO_MEMBER',
      recipients: [profileId],
    },
  };

  beforeEach(() => {});

  it('should send message to the correct profileId', async () => {
    const { response, resultCreationEvent } = createSendMessageResponse();

    when(axios.post(sendMessageRequestUrl, payload, { params: queryParams })).thenResolve({
      data: response,
    });

    const client = await new Client().login.userPass({ username, password });
    const createdMessage = await client.message.sendMessage({ profileId, text });

    expect(omit(createdMessage, 'text')).toEqual(resultCreationEvent);
  });

  it('should add text to the send message response', async () => {
    const { response } = createSendMessageResponse();

    when(axios.post(sendMessageRequestUrl, payload, { params: queryParams })).thenResolve({
      data: response,
    });

    const client = await new Client().login.userPass({ username, password });
    const createdMessage = await client.message.sendMessage({ profileId, text });

    expect(createdMessage.text).toEqual(text);
  });
});