react-code-dataset / spectrum /api /test /thread /queries /messageConnection.test.js

Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

6.16 kB

// @flow
import { request } from '../../utils';
import data from 'shared/testing/data';
import { toPlainText, toState } from 'shared/draft-utils';

const messageToPlainText = message =>
  toPlainText(toState(JSON.parse(message.content.body)));

// Get all messages in our test thread and sort them by time
const messages = data.messages
  .filter(({ threadId }) => threadId === 'thread-1')
  .sort((a, b) => a.timestamp - b.timestamp);

describe('messageConnection', () => {
  it('should fetch a threads messages', async () => {
    const query = /* GraphQL */ `
      {
        thread(id: "thread-1") {
          messageConnection(first: 999999) {
            edges {
              node {
                id
              }
            }
          }
        }
      }
    `;

    expect.hasAssertions();
    const result = await request(query);
    expect(result.data.thread.messageConnection.edges).toHaveLength(
      messages.length
    );
    expect(result).toMatchSnapshot();
  });

  it('should fetch the first message first', async () => {
    const query = /* GraphQL */ `
      {
        thread(id: "thread-1") {
          messageConnection(first: 1) {
            pageInfo {
              hasNextPage
              hasPreviousPage
            }
            edges {
              node {
                id
                content {
                  body
                }
              }
            }
          }
        }
      }
    `;

    expect.hasAssertions();
    const result = await request(query);

    expect(result.data.thread.messageConnection.edges).toHaveLength(1);

    expect(result.data.thread.messageConnection.pageInfo).toEqual({
      // This is true if there is more messages than this one
      hasNextPage: messages.length > 1,
      // This has to be false since it's the first message
      hasPreviousPage: false,
    });

    expect(
      messageToPlainText(result.data.thread.messageConnection.edges[0].node)
    ).toEqual(messageToPlainText(messages[0]));
  });

  it('should fetch the second message next', async () => {
    // Get the cursor of the first message
    const query = /* GraphQL */ `
      {
        thread(id: "thread-1") {
          messageConnection(first: 1) {
            edges {
              cursor
            }
          }
        }
      }
    `;

    expect.hasAssertions();
    const result = await request(query);
    const cursor = result.data.thread.messageConnection.edges[0].cursor;

    // Get one message after the cursor of the first message
    // i.e. the second message
    const nextQuery = /* GraphQL */ `
      {
        thread(id: "thread-1") {
          messageConnection(first: 1, after: "${cursor}") {
            pageInfo {
              hasNextPage
              hasPreviousPage
            }
            edges {
              node {
                content {
                  body
                }
              }
            }
          }
        }
      }
    `;

    const nextResult = await request(nextQuery);

    expect(nextResult.data.thread.messageConnection.edges).toHaveLength(1);

    expect(nextResult.data.thread.messageConnection.pageInfo).toEqual({
      hasNextPage: messages.length > 2,
      // We know this has a previous page
      hasPreviousPage: true,
    });

    expect(
      messageToPlainText(nextResult.data.thread.messageConnection.edges[0].node)
    ).toEqual(messageToPlainText(messages[1]));
  });

  it('should correctly set pageInfo when more messages are requested than are available', async () => {
    // Request more messages than there are
    const query = /* GraphQL */ `
      {
        thread(id: "thread-1") {
          messageConnection(first: ${messages.length + 1}) {
            pageInfo {
              hasNextPage
              hasPreviousPage
            }
            edges {
              cursor
            }
          }
        }
      }
    `;

    expect.hasAssertions();
    const result = await request(query);
    const { edges, pageInfo } = result.data.thread.messageConnection;

    expect(edges).toHaveLength(messages.length);

    expect(pageInfo).toEqual({
      hasNextPage: false,
      hasPreviousPage: false,
    });
  });

  it('should correctly set pageInfo when all messages are requested', async () => {
    // Request more messages than there are
    const query = /* GraphQL */ `
      {
        thread(id: "thread-1") {
          messageConnection(first: ${messages.length}) {
            pageInfo {
              hasNextPage
              hasPreviousPage
            }
            edges {
              cursor
            }
          }
        }
      }
    `;

    expect.hasAssertions();
    const result = await request(query);
    const { edges, pageInfo } = result.data.thread.messageConnection;

    expect(edges).toHaveLength(messages.length);

    expect(pageInfo).toEqual({
      hasNextPage: false,
      hasPreviousPage: false,
    });
  });

  it('should correctly set pageInfo when more messages are requested than are available after a cursor', async () => {
    // Get the cursor of the first message
    const query = /* GraphQL */ `
      {
        thread(id: "thread-1") {
          messageConnection(first: 1) {
            edges {
              cursor
            }
          }
        }
      }
    `;

    expect.hasAssertions();
    const result = await request(query);
    const cursor = result.data.thread.messageConnection.edges[0].cursor;

    // Get all messages after the cursor of the first message
    // but get more than are available
    const nextQuery = /* GraphQL */ `
      {
        thread(id: "thread-1") {
          messageConnection(first: ${messages.length}, after: "${cursor}") {
            pageInfo {
              hasNextPage
              hasPreviousPage
            }
            edges {
              cursor
            }
          }
        }
      }
    `;

    const nextResult = await request(nextQuery);
    const { edges, pageInfo } = nextResult.data.thread.messageConnection;

    expect(edges).toHaveLength(messages.length - 1);
    expect(pageInfo).toEqual({
      hasNextPage: false,
      hasPreviousPage: true,
    });
  });
});

	// @flow
	import { request } from '../../utils';
	import data from 'shared/testing/data';
	import { toPlainText, toState } from 'shared/draft-utils';

	const messageToPlainText = message =>
	toPlainText(toState(JSON.parse(message.content.body)));

	// Get all messages in our test thread and sort them by time
	const messages = data.messages
	.filter(({ threadId }) => threadId === 'thread-1')
	.sort((a, b) => a.timestamp - b.timestamp);

	describe('messageConnection', () => {
	it('should fetch a threads messages', async () => {
	const query = /* GraphQL */ `
	{
	thread(id: "thread-1") {
	messageConnection(first: 999999) {
	edges {
	node {
	id
	}
	}
	}
	}
	}
	`;

	expect.hasAssertions();
	const result = await request(query);
	expect(result.data.thread.messageConnection.edges).toHaveLength(
	messages.length
	);
	expect(result).toMatchSnapshot();
	});

	it('should fetch the first message first', async () => {
	const query = /* GraphQL */ `
	{
	thread(id: "thread-1") {
	messageConnection(first: 1) {
	pageInfo {
	hasNextPage
	hasPreviousPage
	}
	edges {
	node {
	id
	content {
	body
	}
	}
	}
	}
	}
	}
	`;

	expect.hasAssertions();
	const result = await request(query);

	expect(result.data.thread.messageConnection.edges).toHaveLength(1);

	expect(result.data.thread.messageConnection.pageInfo).toEqual({
	// This is true if there is more messages than this one
	hasNextPage: messages.length > 1,
	// This has to be false since it's the first message
	hasPreviousPage: false,
	});

	expect(
	messageToPlainText(result.data.thread.messageConnection.edges[0].node)
	).toEqual(messageToPlainText(messages[0]));
	});

	it('should fetch the second message next', async () => {
	// Get the cursor of the first message
	const query = /* GraphQL */ `
	{
	thread(id: "thread-1") {
	messageConnection(first: 1) {
	edges {
	cursor
	}
	}
	}
	}
	`;

	expect.hasAssertions();
	const result = await request(query);
	const cursor = result.data.thread.messageConnection.edges[0].cursor;

	// Get one message after the cursor of the first message
	// i.e. the second message
	const nextQuery = /* GraphQL */ `
	{
	thread(id: "thread-1") {
	messageConnection(first: 1, after: "${cursor}") {
	pageInfo {
	hasNextPage
	hasPreviousPage
	}
	edges {
	node {
	content {
	body
	}
	}
	}
	}
	}
	}
	`;

	const nextResult = await request(nextQuery);

	expect(nextResult.data.thread.messageConnection.edges).toHaveLength(1);

	expect(nextResult.data.thread.messageConnection.pageInfo).toEqual({
	hasNextPage: messages.length > 2,
	// We know this has a previous page
	hasPreviousPage: true,
	});

	expect(
	messageToPlainText(nextResult.data.thread.messageConnection.edges[0].node)
	).toEqual(messageToPlainText(messages[1]));
	});

	it('should correctly set pageInfo when more messages are requested than are available', async () => {
	// Request more messages than there are
	const query = /* GraphQL */ `
	{
	thread(id: "thread-1") {
	messageConnection(first: ${messages.length + 1}) {
	pageInfo {
	hasNextPage
	hasPreviousPage
	}
	edges {
	cursor
	}
	}
	}
	}
	`;

	expect.hasAssertions();
	const result = await request(query);
	const { edges, pageInfo } = result.data.thread.messageConnection;

	expect(edges).toHaveLength(messages.length);

	expect(pageInfo).toEqual({
	hasNextPage: false,
	hasPreviousPage: false,
	});
	});

	it('should correctly set pageInfo when all messages are requested', async () => {
	// Request more messages than there are
	const query = /* GraphQL */ `
	{
	thread(id: "thread-1") {
	messageConnection(first: ${messages.length}) {
	pageInfo {
	hasNextPage
	hasPreviousPage
	}
	edges {
	cursor
	}
	}
	}
	}
	`;

	expect.hasAssertions();
	const result = await request(query);
	const { edges, pageInfo } = result.data.thread.messageConnection;

	expect(edges).toHaveLength(messages.length);

	expect(pageInfo).toEqual({
	hasNextPage: false,
	hasPreviousPage: false,
	});
	});

	it('should correctly set pageInfo when more messages are requested than are available after a cursor', async () => {
	// Get the cursor of the first message
	const query = /* GraphQL */ `
	{
	thread(id: "thread-1") {
	messageConnection(first: 1) {
	edges {
	cursor
	}
	}
	}
	}
	`;

	expect.hasAssertions();
	const result = await request(query);
	const cursor = result.data.thread.messageConnection.edges[0].cursor;

	// Get all messages after the cursor of the first message
	// but get more than are available
	const nextQuery = /* GraphQL */ `
	{
	thread(id: "thread-1") {
	messageConnection(first: ${messages.length}, after: "${cursor}") {
	pageInfo {
	hasNextPage
	hasPreviousPage
	}
	edges {
	cursor
	}
	}
	}
	}
	`;

	const nextResult = await request(nextQuery);
	const { edges, pageInfo } = nextResult.data.thread.messageConnection;

	expect(edges).toHaveLength(messages.length - 1);
	expect(pageInfo).toEqual({
	hasNextPage: false,
	hasPreviousPage: true,
	});
	});
	});