update gherkin etc, validate against cck

.gitignore

@@ -5,7 +5,9 @@
 @rerun.txt
 coverage/
 dist/browser-example.js
+html-formatter.html
 lib/
+messages.ndjson
 node_modules
 tmp/
 usage.txt

CHANGELOG.md

@@ -5,6 +5,8 @@ Please see [CONTRIBUTING.md](https://github.com/cucumber/cucumber/blob/master/CO
 #### New Features
 
 * Add support for Gherkin's [Rule/Example syntax](https://cucumber.io/docs/gherkin/reference/#rule)
+* Add `transpose` method to [data table interface](docs/support_files/data_table_interface.md)
+* Add `log` function to world, providing a shorthand to log plain text as [attachment(s)](docs/support_files/attachments.md)
 
 #### Breaking changes
 

compatibility/cck_spec.ts

@@ -0,0 +1,97 @@
+import { describe, it } from 'mocha'
+import { config, expect, use } from 'chai'
+import chaiExclude from 'chai-exclude'
+import glob from 'glob'
+import fs from 'fs'
+import ndjsonParse from 'ndjson-parse'
+import path from 'path'
+import { PassThrough } from 'stream'
+import { Cli } from '../lib'
+import toString from 'stream-to-string'
+import { doesHaveValue, doesNotHaveValue } from '../src/value_checker'
+import { normalizeMessageOutput } from '../features/support/formatter_output_helpers'
+
+const PROJECT_PATH = path.join(__dirname, '..')
+const CCK_FEATURES_PATH = 'node_modules/@cucumber/compatibility-kit/features'
+const CCK_IMPLEMENTATIONS_PATH = 'compatibility/features'
+
+config.truncateThreshold = 100
+use(chaiExclude)
+
+describe('Cucumber Compatibility Kit', () => {
+  glob.sync(`${CCK_FEATURES_PATH}/**/*.ndjson`).forEach((fixturePath) => {
+    const suiteName = /^.+\/(.+)\.ndjson$/.exec(fixturePath)[1]
+    it(`passes the cck suite for '${suiteName}'`, async () => {
+      const args = [
+        'node',
+        path.join(PROJECT_PATH, 'bin', 'cucumber-js'),
+      ].concat([
+        `${CCK_FEATURES_PATH}/${suiteName}/${suiteName}.feature`,
+        '--require',
+        `${CCK_IMPLEMENTATIONS_PATH}/${suiteName}/${suiteName}.ts`,
+        '--profile',
+        'cck',
+      ])
+      const stdout = new PassThrough()
+      try {
+        await new Cli({
+          argv: args,
+          cwd: PROJECT_PATH,
+          stdout,
+        }).run()
+      } catch (ignored) {
+        console.error(ignored)
+      }
+      stdout.end()
+
+      const rawOutput = await toString(stdout)
+      const actualMessages = normalize(ndjsonParse(rawOutput))
+      const expectedMessages = ndjsonParse(
+        fs.readFileSync(fixturePath, { encoding: 'utf-8' })
+      )
+      expect(actualMessages)
+        .excludingEvery([
+          'meta',
+          // sources
+          'uri',
+          'line',
+          // ids
+          'astNodeId',
+          'astNodeIds',
+          'hookId',
+          'id',
+          'pickleId',
+          'pickleStepId',
+          'stepDefinitionIds',
+          'testCaseId',
+          'testCaseStartedId',
+          'testStepId',
+          // time
+          'nanos',
+          'seconds',
+          // errors
+          'message',
+        ])
+        .to.deep.eq(expectedMessages)
+    })
+  })
+})
+
+function normalize(messages: any[]): any[] {
+  messages = normalizeMessageOutput(
+    messages,
+    path.join(PROJECT_PATH, 'compatibility')
+  )
+  const testCases: any[] = messages.filter((message) =>
+    doesHaveValue(message.testCase)
+  )
+  const everythingElse: any[] = messages.filter((message) =>
+    doesNotHaveValue(message.testCase)
+  )
+  const testRunStarted = everythingElse.findIndex((message) =>
+    doesHaveValue(message.testRunStarted)
+  )
+  // move all `testCase` messages to just after `testRunStarted`
+  everythingElse.splice(testRunStarted + 1, 0, ...testCases)
+  return everythingElse
+}

compatibility/features/attachments/attachments.ts

@@ -0,0 +1,75 @@
+import { Before, When, World } from '../../..'
+import { ReadableStreamBuffer } from 'stream-buffers'
+import fs from 'fs'
+import path from 'path'
+
+Before((): void => undefined)
+
+When('the string {string} is attached as {string}', async function (
+  this: World,
+  text: string,
+  mediaType: string
+) {
+  await this.attach(text, mediaType)
+})
+
+When('the string {string} is logged', async function (
+  this: World,
+  text: string
+) {
+  await this.log(text)
+})
+
+When('text with ANSI escapes is logged', async function (this: World) {
+  await this.log(
+    'This displays a \x1b[31mr\x1b[0m\x1b[91ma\x1b[0m\x1b[33mi\x1b[0m\x1b[32mn\x1b[0m\x1b[34mb\x1b[0m\x1b[95mo\x1b[0m\x1b[35mw\x1b[0m'
+  )
+})
+
+When('the following string is attached as {string}:', async function (
+  this: World,
+  mediaType: string,
+  text: string
+) {
+  await this.attach(text, mediaType)
+})
+
+When('an array with {int} bytes is attached as {string}', async function (
+  this: World,
+  size: number,
+  mediaType: string
+) {
+  const data = [...Array(size).keys()]
+  const buffer = Buffer.from(data)
+  await this.attach(buffer, mediaType)
+})
+
+When('a stream with {int} bytes are attached as {string}', async function (
+  this: World,
+  size: number,
+  mediaType: string
+) {
+  const data = [...Array(size).keys()]
+  const buffer = Buffer.from(data)
+  const stream = new ReadableStreamBuffer({ chunkSize: 1, frequency: 1 })
+  stream.put(buffer)
+  stream.stop()
+  await this.attach(stream, mediaType)
+})
+
+When('a JPEG image is attached', async function (this: World) {
+  await this.attach(
+    fs.createReadStream(
+      path.join(
+        process.cwd(),
+        'node_modules',
+        '@cucumber',
+        'compatibility-kit',
+        'features',
+        'attachments',
+        'cucumber-growing-on-vine.jpg'
+      )
+    ),
+    'image/jpg'
+  )
+})

compatibility/features/data-tables/data-tables.ts

@@ -0,0 +1,13 @@
+import { When, Then, DataTable } from '../../..'
+import { expect } from 'chai'
+
+When('the following table is transposed:', function (
+  this: any,
+  table: DataTable
+) {
+  this.transposed = table.transpose()
+})
+
+Then('it should be:', function (this: any, expected: DataTable) {
+  expect(this.transposed.raw()).to.deep.eq(expected.raw())
+})

compatibility/features/examples-tables/examples-tables.ts

@@ -0,0 +1,17 @@
+import assert from 'assert'
+import { Given, When, Then } from '../../..'
+
+Given('there are {int} cucumbers', function (this: any, initialCount: number) {
+  this.count = initialCount
+})
+
+When('I eat {int} cucumbers', function (this: any, eatCount: number) {
+  this.count -= eatCount
+})
+
+Then('I should have {int} cucumbers', function (
+  this: any,
+  expectedCount: number
+) {
+  assert.strictEqual(this.count, expectedCount)
+})

compatibility/features/hooks/hooks.ts

@@ -0,0 +1,21 @@
+import { When, Before, After } from '../../..'
+
+Before(function () {
+  // no-op
+})
+
+When('a step passes', function () {
+  // no-op
+})
+
+When('a step throws an exception', function () {
+  throw new Error('Exception in step')
+})
+
+After(function () {
+  throw new Error('Exception in hook')
+})
+
+After('@some-tag or @some-other-tag', function () {
+  throw new Error('Exception in conditional hook')
+})

compatibility/features/minimal/minimal.ts

@@ -0,0 +1,6 @@
+import assert from 'assert'
+import { Given } from '../../..'
+
+Given('I have {int} cukes in my belly', function (cukeCount: number) {
+  assert(cukeCount)
+})

compatibility/features/parameter-types/parameter-types.ts

@@ -0,0 +1,22 @@
+import { Given, defineParameterType } from '../../..'
+import { expect } from 'chai'
+
+class Flight {
+  constructor(public readonly from: string, public readonly to: string) {}
+}
+
+defineParameterType({
+  name: 'flight',
+  regexp: /([A-Z]{3})-([A-Z]{3})/,
+  transformer(from: string, to: string) {
+    return new Flight(from, to)
+  },
+})
+
+Given('{flight} has been delayed {int} minutes', function (
+  flight: Flight,
+  delay: number
+) {
+  expect(flight.from).to.eq('LHR')
+  expect(flight.to).to.eq('CDG')
+})

compatibility/features/rules/rules.ts

@@ -0,0 +1,42 @@
+import assert from 'assert'
+import { Given, When, Then } from '../../..'
+
+Given('there are {int} {float} coins inside', function (
+  count: number,
+  denomination: number
+) {
+  // TODO: implement this
+  assert(count)
+  assert(denomination)
+})
+
+Given('there are no chocolates inside', function () {
+  // TODO: implement this
+})
+
+Given('there are {int} chocolates inside', function (chocolateCount: number) {
+  // TODO: implement this
+  assert(chocolateCount)
+})
+
+When(
+  'the customer tries to buy a {float} chocolate with a {float} coin',
+  function (price: number, paid: number) {
+    // TODO: implement this
+    assert(price)
+    assert(paid)
+  }
+)
+
+Then('the sale should not happen', function () {
+  // TODO: implement this
+})
+
+Then("the customer's change should be {int} {float} coin(s)", function (
+  count: number,
+  denomination: number
+) {
+  // TODO: implement this
+  assert(count)
+  assert(denomination)
+})

compatibility/features/stack-traces/stack-traces.ts

@@ -0,0 +1,5 @@
+import { When } from '../../..'
+
+When('a step throws an exception', function () {
+  throw new Error('BOOM')
+})

compatibility/features/unknown-parameter-type/unknown-parameter-type.ts

@@ -0,0 +1,6 @@
+import { Given } from '../../..'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+Given('{airport} is closed because of a strike', function (airport: any) {
+  throw new Error('Should not be called because airport type not defined')
+})

cucumber.js

@@ -1,13 +1,45 @@
-var common = [
+const feature = [
   '--require-module ts-node/register',
   '--require features/**/*.ts',
   `--format ${
     process.env.CI || !process.stdout.isTTY ? 'progress' : 'progress-bar'
   }`,
   '--format rerun:@rerun.txt',
   '--format usage:usage.txt',
+  '--format message:messages.ndjson',
+].join(' ')
+
+const cck = [
+  '--require-module',
+  'ts-node/register',
+  '--format',
+  'message',
+].join(' ')
+
+const FORMATTERS_INCLUDE = [
+  'attachments',
+  'data-tables',
+  'examples-tables',
+  'minimal',
+  'parameter-types',
+  'rules',
+  'stack-traces',
+]
+
+const formatters = [
+  `node_modules/@cucumber/compatibility-kit/features/{${FORMATTERS_INCLUDE.join(
+    ','
+  )}}/*.feature`,
+  '--require-module',
+  'ts-node/register',
+  '--require',
+  `compatibility/features/{${FORMATTERS_INCLUDE.join(',')}}/*.ts`,
+  '--format',
+  'message',
 ].join(' ')
 
 module.exports = {
-  default: common,
+  default: feature,
+  cck,
+  formatters,
 }

dependency-lint.yml

@@ -21,6 +21,7 @@ ignoreErrors:
   shouldBeDependency: []
   shouldBeDevDependency: []
   unused:
+    - '@cucumber/compatibility-kit' # files dynamically loaded in cck test, not require'd
     - '@typescript-eslint/eslint-plugin' # peer dependency of standard-with-typescript
     - '@typescript-eslint/parser' # peer dependency of @typescript-eslint/eslint-plugin
     - '@types/*' # type definitions
@@ -40,7 +41,7 @@ ignoreErrors:
 requiredModules:
   files:
     dev:
-      - '{features,scripts,test}/**/*'
+      - '{compatibility,features,scripts,test}/**/*'
       - '**/*_spec.ts'
       - 'example/index.ts'
       - '**/test_helpers.ts'