Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

12.4 KB
Raw Blame
/**
 * Copyright (c) Microsoft Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { test, expect } from './fixtures';

test('browser_cookie_list unavailable without storage capability', async ({ startClient, server }) => {
  const { client } = await startClient();
  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.HELLO_WORLD },
  });

  expect(await client.callTool({
    name: 'browser_cookie_list',
  })).toHaveResponse({
    error: 'Tool "browser_cookie_list" not found',
    isError: true,
  });
});

test('browser_cookie_list shows no cookies when empty', async ({ startClient, server, mcpBrowser }) => {
  test.skip(mcpBrowser === 'msedge', 'Edge is leaking some internal cookies');
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });

  const result = await client.callTool({
    name: 'browser_cookie_list',
    arguments: {},
  });

  expect(result).toHaveResponse({
    result: 'No cookies found',
  });
});

test('browser_cookie_set and browser_cookie_get', async ({ startClient, server }) => {
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  // A blank page has no host to take the cookie domain from.
  expect(await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'testCookie', value: 'testValue' },
  })).toHaveResponse({
    isError: true,
    error: expect.stringContaining(`Cannot infer the cookie domain from the page URL "about:blank", specify "domain".`),
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });

  // Set a cookie
  await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'testCookie', value: 'testValue' },
  });

  // Get the cookie
  const getResult = await client.callTool({
    name: 'browser_cookie_get',
    arguments: { name: 'testCookie' },
  });

  expect(getResult).toHaveResponse({
    result: expect.stringContaining('testCookie=testValue'),
  });
});

test('browser_cookie_list shows cookies', async ({ startClient, server }) => {
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });

  await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'cookie1', value: 'value1' },
  });

  await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'cookie2', value: 'value2' },
  });

  const result = await client.callTool({
    name: 'browser_cookie_list',
    arguments: {},
  });

  expect(result).toHaveResponse({
    result: expect.stringContaining('cookie1=value1'),
  });

  expect(result).toHaveResponse({
    result: expect.stringContaining('cookie2=value2'),
  });
});

test('browser_cookie_list filters by domain', async ({ startClient, server }) => {
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });

  await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'localCookie', value: 'localValue' },
  });

  const result = await client.callTool({
    name: 'browser_cookie_list',
    arguments: { domain: 'localhost' },
  });

  expect(result).toHaveResponse({
    result: expect.stringContaining('localCookie=localValue'),
  });

  const noResult = await client.callTool({
    name: 'browser_cookie_list',
    arguments: { domain: 'nonexistent.com' },
  });

  expect(noResult).toHaveResponse({
    result: 'No cookies found',
  });

  // The domain matches itself and its subdomains, not other domains that end with it.
  for (const [name, domain] of [['apex', 'example.com'], ['sub', 'sub.example.com'], ['other', 'my-example.com']]) {
    await client.callTool({
      name: 'browser_cookie_set',
      arguments: { name, value: 'value', domain },
    });
  }
  const exampleResult = await client.callTool({
    name: 'browser_cookie_list',
    arguments: { domain: 'example.com' },
  });
  expect(exampleResult).toHaveResponse({
    result: expect.stringContaining('apex=value'),
  });
  expect(exampleResult).toHaveResponse({
    result: expect.stringContaining('sub=value'),
  });
  expect(exampleResult).toHaveResponse({
    result: expect.not.stringContaining('other=value'),
  });
});

test('browser_cookie_list filters by path', async ({ startClient, server }) => {
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });

  // The path matches itself and its sub-paths, not other paths that start with it.
  for (const [name, path] of [['exact', '/api'], ['sub', '/api/users'], ['other', '/apikeys']]) {
    await client.callTool({
      name: 'browser_cookie_set',
      arguments: { name, value: 'value', path },
    });
  }
  const apiResult = await client.callTool({
    name: 'browser_cookie_list',
    arguments: { path: '/api' },
  });
  expect(apiResult).toHaveResponse({
    result: expect.stringContaining('exact=value'),
  });
  expect(apiResult).toHaveResponse({
    result: expect.stringContaining('sub=value'),
  });
  expect(apiResult).toHaveResponse({
    result: expect.not.stringContaining('other=value'),
  });
});

test('browser_cookie_get returns not found for missing cookie', async ({ startClient, server }) => {
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });

  const result = await client.callTool({
    name: 'browser_cookie_get',
    arguments: { name: 'nonexistent' },
  });

  expect(result).toHaveResponse({
    result: expect.stringContaining('not found'),
  });
});

test('browser_cookie_set with all options', async ({ startClient, server, mcpBrowser }) => {
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });

  const futureTime = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now

  await client.callTool({
    name: 'browser_cookie_set',
    arguments: {
      name: 'fullCookie',
      value: 'fullValue',
      path: '/test',
      expires: futureTime,
      httpOnly: true,
      secure: false,
      sameSite: 'Lax',
    },
  });

  // Verify the cookie with detailed info
  const getResult = await client.callTool({
    name: 'browser_cookie_get',
    arguments: { name: 'fullCookie' },
  });

  expect(getResult).toHaveResponse({
    result: expect.stringContaining('fullCookie=fullValue'),
  });

  expect(getResult).toHaveResponse({
    result: expect.stringContaining('httpOnly: true'),
  });

  const sameSite = process.platform === 'win32' && mcpBrowser === 'webkit' ? 'None' : 'Lax';
  expect(getResult).toHaveResponse({
    result: expect.stringContaining(`sameSite: ${sameSite}`),
  });
});

test('browser_cookie_delete removes cookie', async ({ startClient, server }) => {
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });

  await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'toDelete', value: 'deleteMe' },
  });

  // Verify it exists
  const beforeDelete = await client.callTool({
    name: 'browser_cookie_get',
    arguments: { name: 'toDelete' },
  });

  expect(beforeDelete).toHaveResponse({
    result: expect.stringContaining('toDelete=deleteMe'),
  });

  // Delete the cookie
  await client.callTool({
    name: 'browser_cookie_delete',
    arguments: { name: 'toDelete' },
  });

  // Verify it's gone
  const afterDelete = await client.callTool({
    name: 'browser_cookie_get',
    arguments: { name: 'toDelete' },
  });

  expect(afterDelete).toHaveResponse({
    result: expect.stringContaining('not found'),
  });

  // Domain and path narrow it down to one of the same-named cookies.
  for (const domain of ['a.example', 'b.example']) {
    await client.callTool({
      name: 'browser_cookie_set',
      arguments: { name: 'session', value: domain, domain },
    });
  }
  expect(await client.callTool({
    name: 'browser_cookie_delete',
    arguments: { name: 'session', domain: 'a.example', path: '/' },
  })).toHaveResponse({
    code: `await page.context().clearCookies({ name: 'session', domain: 'a.example', path: '/' });`,
  });
  expect(await client.callTool({
    name: 'browser_cookie_get',
    arguments: { name: 'session' },
  })).toHaveResponse({
    result: expect.stringContaining('session=b.example (domain: b.example'),
  });
});

test('browser_cookie_delete for nonexistent cookie does not error', async ({ startClient, server }) => {
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });

  // Set a cookie to verify delete of nonexistent doesn't affect existing cookies
  await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'existing', value: 'value' },
  });

  // Deleting nonexistent cookie should not throw
  await client.callTool({
    name: 'browser_cookie_delete',
    arguments: { name: 'nonexistent' },
  });

  // Existing cookie should still be there
  const result = await client.callTool({
    name: 'browser_cookie_get',
    arguments: { name: 'existing' },
  });

  expect(result).toHaveResponse({
    result: expect.stringContaining('existing=value'),
  });
});

test('browser_cookie_clear removes all cookies', async ({ startClient, server }) => {
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });

  // Set multiple cookies
  await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'cookie1', value: 'value1' },
  });

  await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'cookie2', value: 'value2' },
  });

  // Verify they exist
  const beforeClear = await client.callTool({
    name: 'browser_cookie_list',
    arguments: {},
  });

  expect(beforeClear).toHaveResponse({
    result: expect.stringContaining('cookie1'),
  });

  // Clear all cookies
  await client.callTool({
    name: 'browser_cookie_clear',
    arguments: {},
  });

  // Verify they're all gone
  const afterClear = await client.callTool({
    name: 'browser_cookie_list',
    arguments: {},
  });

  expect(afterClear).toHaveResponse({
    result: 'No cookies found',
  });
});

test('browser_cookie_set and browser_cookie_get use the current tab context', async ({ startClient, server }) => {
  const { client } = await startClient({
    config: { capabilities: ['storage'] },
  });

  await client.callTool({
    name: 'browser_navigate',
    arguments: { url: server.EMPTY_PAGE },
  });
  await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'user', value: 'default' },
  });

  await client.callTool({
    name: 'browser_tabs',
    arguments: { action: 'new', url: server.EMPTY_PAGE, isolatedContext: 'alice' },
  });
  await client.callTool({
    name: 'browser_cookie_set',
    arguments: { name: 'user', value: 'alice' },
  });
  expect(await client.callTool({
    name: 'browser_cookie_get',
    arguments: { name: 'user' },
  })).toHaveResponse({
    result: expect.stringContaining('user=alice'),
  });

  await client.callTool({
    name: 'browser_tabs',
    arguments: { action: 'select', index: 0 },
  });
  expect(await client.callTool({
    name: 'browser_cookie_get',
    arguments: { name: 'user' },
  })).toHaveResponse({
    result: expect.stringContaining('user=default'),
  });
});