playwright/tests/playwright-test/reporter-raw.spec.ts

/**
 * 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 fs from 'fs';
import path from 'path';
import { test, expect } from './playwright-test-fixtures';

const kRawReporterPath = path.join(__dirname, '..', '..', 'packages', 'playwright-test', 'lib', 'reporters', 'raw.js');

test('should generate raw report', async ({ runInlineTest }, testInfo) => {
  const result = await runInlineTest({
    'a.test.js': `
      const { test } = pwt;
      test('passes', async ({ page }, testInfo) => {});
    `,
  }, { reporter: 'dot,' + kRawReporterPath }, {}, { usesCustomOutputDir: true });
  const json = JSON.parse(fs.readFileSync(testInfo.outputPath('test-results', 'report', 'project.report'), 'utf-8'));
  expect(json.config).toBeTruthy();
  expect(json.project).toBeTruthy();
  expect(result.exitCode).toBe(0);
});

test('should use project name', async ({ runInlineTest }, testInfo) => {
  const result = await runInlineTest({
    'playwright.config.ts': `
      module.exports = {
        projects: [{
          name: 'project-name',
          outputDir: 'output'
        }]
      }
    `,
    'a.test.js': `
      const { test } = pwt;
      test('passes', async ({ page }, testInfo) => {});
    `,
  }, { reporter: 'dot,' + kRawReporterPath }, {}, { usesCustomOutputDir: true });
  const json = JSON.parse(fs.readFileSync(testInfo.outputPath('output', 'report', 'project-name.report'), 'utf-8'));
  expect(json.project.name).toBe('project-name');
  expect(result.exitCode).toBe(0);
});

test('should save stdio', async ({ runInlineTest }, testInfo) => {
  await runInlineTest({
    'a.test.js': `
      const { test } = pwt;
      test('passes', async ({ page }, testInfo) => {
        console.log('STDOUT');
        process.stdout.write(Buffer.from([1, 2, 3]));
        console.error('STDERR');
        process.stderr.write(Buffer.from([4, 5, 6]));
      });
    `,
  }, { reporter: 'dot,' + kRawReporterPath }, {}, { usesCustomOutputDir: true });
  const json = JSON.parse(fs.readFileSync(testInfo.outputPath('test-results', 'report', 'project.report'), 'utf-8'));
  const result = json.suites[0].tests[0].results[0];
  expect(result.attachments).toEqual([
    { name: 'stdout', contentType: 'text/plain', body: 'STDOUT\n' },
    {
      name: 'stdout',
      contentType: 'application/octet-stream',
      body: { data: [1, 2, 3], type: 'Buffer' }
    },
    { name: 'stderr', contentType: 'text/plain', body: 'STDERR\n' },
    {
      name: 'stderr',
      contentType: 'application/octet-stream',
      body: { data: [4, 5, 6], type: 'Buffer' }
    }
  ]);
});

test('should save attachments', async ({ runInlineTest }, testInfo) => {
  await runInlineTest({
    'a.test.js': `
      const { test } = pwt;
      test('passes', async ({ page }, testInfo) => {
        testInfo.attachments.push({
          name: 'binary',
          contentType: 'application/octet-stream',
          body: Buffer.from([1,2,3])
        });
        testInfo.attachments.push({
          name: 'text',
          contentType: 'text/plain',
          path: 'dummy-path'
        });
      });
    `,
  }, { reporter: 'dot,' + kRawReporterPath }, {}, { usesCustomOutputDir: true });
  const json = JSON.parse(fs.readFileSync(testInfo.outputPath('test-results', 'report', 'project.report'), 'utf-8'));
  const result = json.suites[0].tests[0].results[0];
  expect(result.attachments[0].name).toBe('binary');
  expect(Buffer.from(result.attachments[0].body, 'base64')).toEqual(Buffer.from([1,2,3]));
  expect(result.attachments[1].name).toBe('text');
  const path2 = result.attachments[1].path;
  expect(path2).toBe('dummy-path');
});

test(`testInfo.attach should save attachments via path`, async ({ runInlineTest }, testInfo) => {
  await runInlineTest({
    'a.test.js': `
      const path = require('path');
      const fs = require('fs');
      const { test } = pwt;
      test('infer contentType from path', async ({}, testInfo) => {
        const tmpPath = testInfo.outputPath('example.json');
        await fs.promises.writeFile(tmpPath, 'We <3 Playwright!');
        await testInfo.attach('foo', { path: tmpPath });
        // Forcibly remove the tmp file to ensure attach is actually automagically copying it
        await fs.promises.unlink(tmpPath);
      });

      test('explicit contentType (over extension)', async ({}, testInfo) => {
        const tmpPath = testInfo.outputPath('example.json');
        await fs.promises.writeFile(tmpPath, 'We <3 Playwright!');
        await testInfo.attach('foo', { path: tmpPath, contentType: 'image/png' });
        // Forcibly remove the tmp file to ensure attach is actually automagically copying it
        await fs.promises.unlink(tmpPath);
      });

      test('explicit contentType (over extension and name)', async ({}, testInfo) => {
        const tmpPath = testInfo.outputPath('example.json');
        await fs.promises.writeFile(tmpPath, 'We <3 Playwright!');
        await testInfo.attach('example.png', { path: tmpPath, contentType: 'x-playwright/custom' });
        // Forcibly remove the tmp file to ensure attach is actually automagically copying it
        await fs.promises.unlink(tmpPath);
      });

      test('fallback contentType', async ({}, testInfo) => {
        const tmpPath = testInfo.outputPath('example.this-extension-better-not-map-to-an-actual-mimetype');
        await fs.promises.writeFile(tmpPath, 'We <3 Playwright!');
        await testInfo.attach('foo', { path: tmpPath });
        // Forcibly remove the tmp file to ensure attach is actually automagically copying it
        await fs.promises.unlink(tmpPath);
      });
    `,
  }, { reporter: 'dot,' + kRawReporterPath, workers: 1 }, {}, { usesCustomOutputDir: true });
  const json = JSON.parse(fs.readFileSync(testInfo.outputPath('test-results', 'report', 'project.report'), 'utf-8'));
  {
    const result = json.suites[0].tests[0].results[0];
    expect(result.attachments[0].name).toBe('foo');
    expect(result.attachments[0].contentType).toBe('application/json');
    const p = result.attachments[0].path;
    expect(p).toMatch(/[/\\]attachments[/\\][0-9a-f]+\.json$/);
    const contents = fs.readFileSync(p);
    expect(contents.toString()).toBe('We <3 Playwright!');
  }
  {
    const result = json.suites[0].tests[1].results[0];
    expect(result.attachments[0].name).toBe('foo');
    expect(result.attachments[0].contentType).toBe('image/png');
    const p = result.attachments[0].path;
    expect(p).toMatch(/[/\\]attachments[/\\][0-9a-f]+\.json$/);
    const contents = fs.readFileSync(p);
    expect(contents.toString()).toBe('We <3 Playwright!');
  }
  {
    const result = json.suites[0].tests[2].results[0];
    expect(result.attachments[0].name).toBe('example.png');
    expect(result.attachments[0].contentType).toBe('x-playwright/custom');
    const p = result.attachments[0].path;
    expect(p).toMatch(/[/\\]attachments[/\\][0-9a-f]+\.json$/);
    const contents = fs.readFileSync(p);
    expect(contents.toString()).toBe('We <3 Playwright!');
  }
  {
    const result = json.suites[0].tests[3].results[0];
    expect(result.attachments[0].name).toBe('foo');
    expect(result.attachments[0].contentType).toBe('application/octet-stream');
    const p = result.attachments[0].path;
    expect(p).toMatch(/[/\\]attachments[/\\][0-9a-f]+\.this-extension-better-not-map-to-an-actual-mimetype$/);
    const contents = fs.readFileSync(p);
    expect(contents.toString()).toBe('We <3 Playwright!');
  }
});

test(`testInfo.attach should save attachments via inline attachment`, async ({ runInlineTest }, testInfo) => {
  await runInlineTest({
    'a.test.js': `
      const path = require('path');
      const fs = require('fs');
      const { test } = pwt;
      test('default contentType - string', async ({}, testInfo) => {
        await testInfo.attach('example.json', { body: 'We <3 Playwright!' });
      });

      test('default contentType - Buffer', async ({}, testInfo) => {
        await testInfo.attach('example.json', { body: Buffer.from('We <3 Playwright!') });
      });

      test('explicit contentType - string', async ({}, testInfo) => {
        await testInfo.attach('example.json', { body: 'We <3 Playwright!', contentType: 'x-playwright/custom' });
      });

      test('explicit contentType - Buffer', async ({}, testInfo) => {
        await testInfo.attach('example.json', { body: Buffer.from('We <3 Playwright!'), contentType: 'x-playwright/custom' });
      });
  `,
  }, { reporter: 'dot,' + kRawReporterPath, workers: 1 }, {}, { usesCustomOutputDir: true });
  const json = JSON.parse(fs.readFileSync(testInfo.outputPath('test-results', 'report', 'project.report'), 'utf-8'));
  {
    const result = json.suites[0].tests[0].results[0];
    expect(result.attachments[0].name).toBe('example.json');
    expect(result.attachments[0].contentType).toBe('text/plain');
    expect(Buffer.from(result.attachments[0].body, 'base64')).toEqual(Buffer.from('We <3 Playwright!'));
  }
  {
    const result = json.suites[0].tests[1].results[0];
    expect(result.attachments[0].name).toBe('example.json');
    expect(result.attachments[0].contentType).toBe('application/octet-stream');
    expect(Buffer.from(result.attachments[0].body, 'base64')).toEqual(Buffer.from('We <3 Playwright!'));
  }
  {
    const result = json.suites[0].tests[2].results[0];
    expect(result.attachments[0].name).toBe('example.json');
    expect(result.attachments[0].contentType).toBe('x-playwright/custom');
    expect(Buffer.from(result.attachments[0].body, 'base64')).toEqual(Buffer.from('We <3 Playwright!'));
  }
  {
    const result = json.suites[0].tests[3].results[0];
    expect(result.attachments[0].name).toBe('example.json');
    expect(result.attachments[0].contentType).toBe('x-playwright/custom');
    expect(Buffer.from(result.attachments[0].body, 'base64')).toEqual(Buffer.from('We <3 Playwright!'));
  }
});

test(`GlobalInfo.attach works`, async ({ runInlineTest }, testInfo) => {
  const result = await runInlineTest({
    'globalSetup.ts': `
      import fs from 'fs';
      import { FullConfig, GlobalInfo } from '@playwright/test';

      async function globalSetup(config: FullConfig, globalInfo: GlobalInfo) {
        const external = 'external.txt';
        await fs.promises.writeFile(external, 'external');
        await globalInfo.attach('inline.txt', { body: Buffer.from('inline'), contentType: 'text/plain' });
        await globalInfo.attach('external.txt', { path: external, contentType: 'text/plain' });
        // The attach call above should have saved it to a safe place
        await fs.promises.unlink(external);
      };

      export default globalSetup;
    `,
    'playwright.config.ts': `
      import path from 'path';
      const config = {
        globalSetup: path.join(__dirname, './globalSetup'),
      }

      export default config;
    `,
    'example.spec.ts': `
      const { test } = pwt;
      test('sample', async ({}) => { expect(2).toBe(2); });
    `,
  }, { reporter: 'dot,' + kRawReporterPath, workers: 1 }, {}, { usesCustomOutputDir: true });

  expect(result.exitCode).toBe(0);
  const outputPath = testInfo.outputPath('test-results', 'report', 'project.report');
  const json = JSON.parse(fs.readFileSync(outputPath, 'utf-8'));
  {
    const attachment = json.attachments[0];
    expect(attachment.name).toBe('inline.txt');
    expect(attachment.contentType).toBe('text/plain');
    expect(attachment.path).toBeUndefined();
    expect(Buffer.from(attachment.body, 'base64').toString()).toEqual('inline');
  }
  {
    const attachment = json.attachments[1];
    expect(attachment.name).toBe('external.txt');
    expect(attachment.contentType).toBe('text/plain');
    const contents = fs.readFileSync(attachment.path);
    expect(attachment.path.startsWith(path.join(testInfo.outputDir, 'attachments')), 'Attachment should be in our output directory.').toBeTruthy();
    expect(contents.toString()).toEqual('external');
    expect(attachment.body).toBeUndefined();
  }
});

test('dupe project names', async ({ runInlineTest }, testInfo) => {
  await runInlineTest({
    'playwright.config.ts': `
      module.exports = {
        projects: [
          { name: 'project-name' },
          { name: 'project-name' },
          { name: 'project-name' },
        ]
      }
    `,
    'a.test.js': `
      const { test } = pwt;
      test('passes', async ({ page }, testInfo) => {});
    `,
  }, { reporter: 'dot,' + kRawReporterPath }, {}, { usesCustomOutputDir: true });
  const files = fs.readdirSync(testInfo.outputPath('test-results', 'report'));
  expect(new Set(files)).toEqual(new Set(['project-name.report', 'project-name-1.report', 'project-name-2.report']));
});