# features/api/[entity]/crud.feature

@api @crud
Feature: Discovery Session API

  Background:
    Given the API server is running
    And I have a valid authentication token

  @smoke @create
  Scenario: Create session with valid data
    Given I have a discovery session payload:
      | field          | value                    |
      | title          | Product Ideation         |
      | description    | Initial brainstorm       |
      | organizationId | 1                        |
    When I send a POST request to "/api/discovery-sessions"
    Then the response status should be 201
    And the response should contain:
      | field  | type   |
      | id     | string |
      | title  | string |
      | status | string |

  @negative @validation
  Scenario: Reject session with missing required fields
    Given I have an incomplete payload missing "title"
    When I send a POST request to "/api/discovery-sessions"
    Then the response status should be 400
    And the response should contain validation errors
    And the error should mention "title is required"

  @edge-case
  Scenario: Handle extremely long title
    Given I have a session with title exceeding 500 characters
    When I send a POST request to "/api/discovery-sessions"
    Then the response status should be 400
    And the error should mention "title too long"

# features/ui/forms/session-form.feature

@ui @forms
Feature: Discovery Session Form

  @validation @positive
  Scenario: Submit valid discovery session
    Given I am on the landing page
    When I fill in "Project Title" with "AI Analytics Platform"
    And I fill in "Description" with "Next-gen analytics"
    And I click "Start Discovery Process"
    Then I should see "Session created successfully"
    And I should be redirected to "/sessions"

  @validation @negative
  Scenario: Display validation errors for empty form
    Given I am on the landing page
    When I click "Start Discovery Process"
    Then I should see "Title is required"
    And I should see "Description is required"
    And the form should not be submitted

  @edge-case
  Scenario: Preserve form data on validation failure
    Given I am on the landing page
    When I fill in "Project Title" with "Test"
    And I submit with an empty description
    Then I should see "Description is required"
    But "Project Title" should still contain "Test"

# features/e2e/discovery-flow.feature

@e2e @critical-path
Feature: Complete Discovery Flow

  @smoke
  Scenario: User creates and manages discovery session
    Given I am a logged-in user
    When I navigate to the homepage
    And I submit a new project idea "E-commerce Platform"
    Then I should see my idea in the sessions list
    When I click on my session
    Then I should see the session details
    And I should be able to update the status to "in_progress"
    When I add AI chat messages to the session
    Then the messages should appear in the chat history
    And the session should show "updated" timestamp

  @workflow
  Scenario: Complete discovery to proposal workflow
    Given I have an active discovery session
    When I complete the AI chat conversation
    And I click "Generate Proposal"
    Then a proposal should be created
    And I should see the proposal linked to the session
    And the session status should be "completed"

Feature: [Feature Name]
  As a [user type]
  I want [action/capability]
  So that [business value]

  Background:
    Given [shared context for all scenarios]

  @layer @priority @feature
  Scenario: [Specific test case]
    Given [initial state]
    When [user action]
    Then [expected outcome]
    And [additional validations]

// tests/step-definitions/session-steps.ts
import { Given, When, Then, Before, After } from '@cucumber/cucumber';
import { expect } from 'chai';
import axios from 'axios';

let response: any;
let context: any = {};

Before(function() {
  context = {
    baseUrl: 'http://localhost:3001',
    headers: { 'Content-Type': 'application/json' }
  };
});

Given('I have a discovery session payload:', function(dataTable) {
  const data = dataTable.rowsHash();
  context.payload = {
    title: data.title,
    description: data.description,
    organizationId: parseInt(data.organizationId)
  };
});

When('I send a {string} request to {string}', async function(method, endpoint) {
  try {
    response = await axios({
      method: method.toLowerCase(),
      url: `${context.baseUrl}${endpoint}`,
      data: context.payload,
      headers: context.headers
    });
  } catch (error: any) {
    response = error.response;
  }
});

Then('the response status should be {int}', function(statusCode) {
  expect(response.status).to.equal(statusCode);
});

Then('the response should contain:', function(dataTable) {
  const fields = dataTable.hashes();
  fields.forEach(({ field, type }) => {
    expect(response.data).to.have.property(field);
    expect(typeof response.data[field]).to.equal(type);
  });
});

After(function() {
  response = null;
  context = {};
});

// cucumber.config.js
module.exports = {
  default: {
    requireModule: ['ts-node/register'],
    require: ['tests/step-definitions/**/*.ts'],
    format: [
      'progress',
      'html:reports/cucumber.html',
      'json:reports/cucumber.json'
    ],
    parallel: 2,
    retry: 1
  }
}

{
  "scripts": {
    "test": "cucumber-js",
    "test:api": "cucumber-js --tags '@api'",
    "test:ui": "cucumber-js --tags '@ui'",
    "test:e2e": "cucumber-js --tags '@e2e'",
    "test:smoke": "cucumber-js --tags '@smoke'",
    "test:coverage": "cucumber-js --format json:reports/coverage.json"
  }
}

# Run all tests
npm test

# Run specific layer
npm test -- --tags "@api"
npm test -- --tags "@ui"
npm test -- --tags "@e2e"

# Run by priority
npm test -- --tags "@smoke"      # Critical paths only
npm test -- --tags "@critical"   # High priority
npm test -- --tags "@regression" # Full suite

# Run specific feature
npm test features/api/auth/login.feature

# Parallel execution
npm test -- --parallel 4

# With detailed output
npm test -- --format pretty

# Generate HTML report
npm test -- --format html:reports/test-report.html

# .github/workflows/test.yml
name: Test Suite

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Install dependencies
        run: npm install

      - name: Run smoke tests
        run: npm test -- --tags "@smoke"

      - name: Run API tests
        run: npm test -- --tags "@api"

      - name: Run UI tests
        run: npm test -- --tags "@ui"

      - name: Run E2E tests
        run: npm test -- --tags "@e2e"

      - name: Upload test reports
        uses: actions/upload-artifact@v3
        with:
          name: test-reports
          path: reports/

## Feature: Discovery Session Management

### Task: TASK-123 - Implement session CRUD

**Acceptance Criteria:**
- AC-1: Users can create sessions with title and description
- AC-2: System validates required fields
- AC-3: Sessions are scoped to organizations

**Test Coverage:**
- `features/api/sessions/crud.feature`
  - ✅ Create session with valid data (AC-1)
  - ✅ Reject missing required fields (AC-2)
  - ✅ Verify organization isolation (AC-3)
- `features/ui/forms/session-form.feature`
  - ✅ Submit valid form (AC-1)
  - ✅ Show validation errors (AC-2)
- `features/e2e/discovery-flow.feature`
  - ✅ Complete creation workflow (AC-1, AC-3)

**Coverage:** 8 scenarios across 3 layers = 100%

@api @crud
Feature: [Entity] Management

  Scenario: Create [entity]
  Scenario: Get [entity] by ID
  Scenario: Update [entity]
  Scenario: Delete [entity]
  Scenario: List [entities] with pagination
  Scenario: Filter [entities] by field
  Scenario: Handle duplicate creation
  Scenario: Validate required fields

@ui @forms @validation
Feature: [Form Name]

  Scenario: Submit with valid data
  Scenario: Display errors for missing fields
  Scenario: Display errors for invalid formats
  Scenario: Preserve data on validation failure
  Scenario: Clear form after successful submission
  Scenario: Handle server errors gracefully

@api @auth
Feature: User Authentication

  Scenario: Successful login
  Scenario: Failed login with wrong password
  Scenario: Account lockout after failed attempts
  Scenario: Session expiration
  Scenario: Logout
  Scenario: Refresh token