Data-driven scenarios + tag filtering + parallel runs

Feature: TTACart login - multi user

  Background:
    Given I am on the TTACart login page

  Scenario Outline: <user> lands on <outcome>
    When I sign in as "<user>" with password "<password>"
    Then the outcome should be "<outcome>"

    Examples:
      | user                   | password   | outcome   |
      | standard_user          | tta_secret | products  |
      | locked_out_user        | tta_secret | rejected  |
      | problem_user           | tta_secret | products  |
      | performance_glitch_user| tta_secret | products  |

// Outline row:  | sku        | qty |  | sauce-labs-bike-light | 2  |

When('I add {string} to the cart {int} times', async function (this: CustomWorld, sku: string, qty: number) {
  for (let i = 0; i < qty; i++) {
    await this.inventoryPage.addToCart(sku);
  }
});

Then('the cart badge should read {int}', async function (this: CustomWorld, expected: number) {
  await expect(this.page.getByTestId('shopping-cart-badge')).toHaveText(String(expected));
});

@checkout
Feature: TTACart checkout

  @smoke
  Scenario: One-item checkout (happy path)
    Given I have a logged-in cart with 1 item
    When I complete the checkout form
    Then the order should be confirmed

  @regression @flaky
  Scenario: Checkout with shipping address validation
    Given I have a logged-in cart with 1 item
    When I submit an invalid postcode "0000A"
    Then I should see a postcode validation error

  @wip
  Scenario: Apply a coupon code
    Given I have a logged-in cart with 1 item
    When I apply the coupon "TTA10"
    Then the total should drop by 10%

# Smoke only
npx cucumber-js --tags "@smoke"

# Smoke without WIP
npx cucumber-js --tags "@smoke and not @wip"

# Anything except flaky
npx cucumber-js --tags "not @flaky"

# Checkout or search, but never WIP or flaky
npx cucumber-js --tags "(@checkout or @search) and not (@wip or @flaky)"

module.exports = {
  default: {
    requireModule: ['ts-node/register'],
    require: ['support/**/*.ts', 'step-definitions/**/*.ts'],
    paths: ['features/**/*.feature'],
    format: ['progress-bar', 'json:reports/cucumber.json', 'html:reports/cucumber.html'],
    parallel: 4
  }
};

Feature: TTACart products sort

  Background:
    Given I am signed in to TTACart as "standard_user"
    And I am on the products page

  @regression
  Scenario Outline: Sort by <option> orders products correctly
    When I sort the products by "<option>"
    Then the first product name should be "<firstName>"
    And the first product price should be <firstPrice>

    Examples:
      | option | firstName              | firstPrice |
      | az     | TTA Backpack           | 29.99      |
      | za     | TTA Wireless Mouse     | 49.99      |
      | lohi   | TTA Sticker Pack       | 7.99       |
      | hilo   | TTA Mechanical Keyboard| 129.99     |

When('I sort the products by {string}', async function (this: CustomWorld, key: string) {
  await this.inventoryPage.sortBy(key);
});

Then('the first product name should be {string}', async function (this: CustomWorld, name: string) {
  await expect(this.inventoryPage.firstItemName()).toHaveText(name);
});

Then('the first product price should be {float}', async function (this: CustomWorld, price: number) {
  const text = await this.inventoryPage.firstItemPrice().innerText();
  expect(parseFloat(text.replace(/[^\d.]/g, ''))).toBeCloseTo(price, 2);
});

[
  { "key": "az",   "firstName": "TTA Backpack",            "firstPrice": 29.99 },
  { "key": "za",   "firstName": "TTA Wireless Mouse",      "firstPrice": 49.99 },
  { "key": "lohi", "firstName": "TTA Sticker Pack",        "firstPrice":  7.99 },
  { "key": "hilo", "firstName": "TTA Mechanical Keyboard", "firstPrice": 129.99 }
]

import productData from '../data/products.json';

export class CustomWorld extends World {
  page!: Page;
  products = productData as Array<{ key: string; firstName: string; firstPrice: number }>;
  findProductRow(key: string) {
    const row = this.products.find((r) => r.key === key);
    if (!row) throw new Error('Unknown sort key: ' + key);
    return row;
  }
}