Sdet Interview Preparation

Project Structure

interview-prep/
  coding/
    data-structures/
      arrays-strings.ts
      linked-lists.ts
      trees-graphs.ts
      hash-maps.ts
    algorithms/
      sorting-searching.ts
      dynamic-programming.ts
      recursion.ts
    testing-specific/
      test-case-generator.ts
      boundary-value-analysis.ts
      equivalence-partitioning.ts
  framework-design/
    page-object-model.ts
    data-driven-framework.ts
    keyword-driven-framework.ts
    hybrid-framework.ts
    api-test-framework.ts
  system-design/
    test-infrastructure.md
    distributed-test-runner.md
    test-data-management.md
    reporting-dashboard.md
  strategy/
    test-pyramid.md
    risk-based-testing.md
    shift-left-strategy.md
    microservices-testing.md
  behavioral/
    star-method-examples.md
    leadership-scenarios.md
    conflict-resolution.md
  mock-interviews/
    coding-round.ts
    system-design-round.md
    testing-strategy-round.md

Coding Challenge: Test Case Generator

// coding/testing-specific/test-case-generator.ts

/**
 * Interview Question: Design a function that generates boundary value test cases
 * for a given set of input constraints.
 */

interface InputConstraint {
  name: string;
  type: 'integer' | 'string' | 'float' | 'boolean' | 'enum';
  min?: number;
  max?: number;
  minLength?: number;
  maxLength?: number;
  enumValues?: string[];
  required: boolean;
}

interface TestCase {
  description: string;
  inputs: Record<string, any>;
  category: 'valid' | 'boundary' | 'invalid' | 'edge';
}

export function generateBoundaryTestCases(constraints: InputConstraint[]): TestCase[] {
  const testCases: TestCase[] = [];

  for (const constraint of constraints) {
    switch (constraint.type) {
      case 'integer':
        if (constraint.min !== undefined && constraint.max !== undefined) {
          // Boundary values
          testCases.push(
            createTestCase(`${constraint.name} at minimum`, constraint.name, constraint.min, 'boundary'),
            createTestCase(`${constraint.name} at maximum`, constraint.name, constraint.max, 'boundary'),
            createTestCase(`${constraint.name} below minimum`, constraint.name, constraint.min - 1, 'invalid'),
            createTestCase(`${constraint.name} above maximum`, constraint.name, constraint.max + 1, 'invalid'),
            createTestCase(`${constraint.name} at min+1`, constraint.name, constraint.min + 1, 'boundary'),
            createTestCase(`${constraint.name} at max-1`, constraint.name, constraint.max - 1, 'boundary'),
            createTestCase(`${constraint.name} at midpoint`, constraint.name, Math.floor((constraint.min + constraint.max) / 2), 'valid'),
          );
          // Edge cases
          testCases.push(
            createTestCase(`${constraint.name} as zero`, constraint.name, 0, 'edge'),
            createTestCase(`${constraint.name} as negative`, constraint.name, -1, 'edge'),
          );
        }
        break;

      case 'string':
        if (constraint.minLength !== undefined && constraint.maxLength !== undefined) {
          testCases.push(
            createTestCase(`${constraint.name} at min length`, constraint.name, 'a'.repeat(constraint.minLength), 'boundary'),
            createTestCase(`${constraint.name} at max length`, constraint.name, 'a'.repeat(constraint.maxLength), 'boundary'),
            createTestCase(`${constraint.name} below min length`, constraint.name, 'a'.repeat(Math.max(0, constraint.minLength - 1)), 'invalid'),
            createTestCase(`${constraint.name} above max length`, constraint.name, 'a'.repeat(constraint.maxLength + 1), 'invalid'),
            createTestCase(`${constraint.name} empty string`, constraint.name, '', 'edge'),
            createTestCase(`${constraint.name} with special chars`, constraint.name, '<script>alert("xss")</script>', 'edge'),
            createTestCase(`${constraint.name} with unicode`, constraint.name, '\u{1F600}\u{1F601}\u{1F602}', 'edge'),
          );
        }
        break;

      case 'boolean':
        testCases.push(
          createTestCase(`${constraint.name} is true`, constraint.name, true, 'valid'),
          createTestCase(`${constraint.name} is false`, constraint.name, false, 'valid'),
        );
        break;

      case 'enum':
        if (constraint.enumValues) {
          for (const value of constraint.enumValues) {
            testCases.push(
              createTestCase(`${constraint.name} = ${value}`, constraint.name, value, 'valid')
            );
          }
          testCases.push(
            createTestCase(`${constraint.name} invalid enum`, constraint.name, 'INVALID_VALUE', 'invalid')
          );
        }
        break;
    }

    // Null/undefined tests for all types
    if (constraint.required) {
      testCases.push(
        createTestCase(`${constraint.name} is null (required)`, constraint.name, null, 'invalid'),
        createTestCase(`${constraint.name} is undefined (required)`, constraint.name, undefined, 'invalid'),
      );
    } else {
      testCases.push(
        createTestCase(`${constraint.name} is null (optional)`, constraint.name, null, 'valid'),
        createTestCase(`${constraint.name} is undefined (optional)`, constraint.name, undefined, 'valid'),
      );
    }
  }

  return testCases;
}

function createTestCase(
  description: string,
  inputName: string,
  value: any,
  category: TestCase['category']
): TestCase {
  return { description, inputs: { [inputName]: value }, category };
}

Framework Design: Page Object Model

// framework-design/page-object-model.ts

/**
 * Interview Question: Design a Page Object Model framework
 * that supports multiple browsers and environments.
 */

// Base page with common functionality
abstract class BasePage {
  constructor(protected page: any) {}

  async waitForPageLoad(): Promise<void> {
    await this.page.waitForLoadState('networkidle');
  }

  async getTitle(): Promise<string> {
    return this.page.title();
  }

  async screenshot(name: string): Promise<void> {
    await this.page.screenshot({ path: `screenshots/${name}.png` });
  }

  async scrollToBottom(): Promise<void> {
    await this.page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
  }

  protected async safeClick(selector: string, timeout = 5000): Promise<void> {
    const element = this.page.locator(selector);
    await element.waitFor({ state: 'visible', timeout });
    await element.click();
  }

  protected async safeFill(selector: string, value: string): Promise<void> {
    const element = this.page.locator(selector);
    await element.waitFor({ state: 'visible' });
    await element.clear();
    await element.fill(value);
  }
}

// Concrete page object
class LoginPage extends BasePage {
  // Locators as readonly properties
  private readonly emailInput = '[data-testid="email-input"]';
  private readonly passwordInput = '[data-testid="password-input"]';
  private readonly submitButton = '[data-testid="login-button"]';
  private readonly errorMessage = '[data-testid="error-message"]';
  private readonly forgotPasswordLink = '[data-testid="forgot-password"]';

  async navigate(): Promise<void> {
    await this.page.goto('/login');
    await this.waitForPageLoad();
  }

  async login(email: string, password: string): Promise<void> {
    await this.safeFill(this.emailInput, email);
    await this.safeFill(this.passwordInput, password);
    await this.safeClick(this.submitButton);
  }

  async getErrorMessage(): Promise<string> {
    return this.page.locator(this.errorMessage).textContent();
  }

  async isErrorVisible(): Promise<boolean> {
    return this.page.locator(this.errorMessage).isVisible();
  }

  async clickForgotPassword(): Promise<void> {
    await this.safeClick(this.forgotPasswordLink);
  }
}

// Page factory pattern
class PageFactory {
  constructor(private page: any) {}

  getLoginPage(): LoginPage {
    return new LoginPage(this.page);
  }

  getDashboardPage(): any {
    // Return dashboard page object
  }
}

System Design: Distributed Test Runner

// system-design/distributed-test-runner-design.ts

/**
 * Interview Question: Design a distributed test execution system
 * that can run 10,000 tests across multiple machines in under 30 minutes.
 *
 * Key Components:
 * 1. Test Orchestrator - Receives test suite, partitions work, distributes
 * 2. Worker Pool - Scalable workers that execute test batches
 * 3. Result Aggregator - Collects results, detects flaky tests, generates reports
 * 4. Test Prioritizer - Orders tests by risk, failure history, and execution time
 * 5. Resource Manager - Manages test environments, databases, external services
 */

interface TestSuite {
  tests: TestDefinition[];
  config: ExecutionConfig;
}

interface TestDefinition {
  id: string;
  file: string;
  estimatedDuration: number;
  tags: string[];
  dependencies: string[];
  priority: number;
  lastFailedAt?: string;
  flakyScore: number;
}

interface ExecutionConfig {
  maxParallel: number;
  timeout: number;
  retryCount: number;
  shardCount: number;
  priorityWeights: {
    recentFailure: number;
    executionTime: number;
    riskScore: number;
  };
}

interface WorkerResult {
  workerId: string;
  testId: string;
  status: 'passed' | 'failed' | 'skipped' | 'error';
  duration: number;
  error?: string;
  retryCount: number;
}

// Test partitioning algorithm
function partitionTests(tests: TestDefinition[], shardCount: number): TestDefinition[][] {
  // Sort by priority (highest first) then by estimated duration (longest first)
  const sorted = [...tests].sort((a, b) => {
    if (b.priority !== a.priority) return b.priority - a.priority;
    return b.estimatedDuration - a.estimatedDuration;
  });

  // Greedy bin packing: assign each test to the shard with least total duration
  const shards: TestDefinition[][] = Array.from({ length: shardCount }, () => []);
  const shardDurations = new Array(shardCount).fill(0);

  for (const test of sorted) {
    const minIndex = shardDurations.indexOf(Math.min(...shardDurations));
    shards[minIndex].push(test);
    shardDurations[minIndex] += test.estimatedDuration;
  }

  return shards;
}

Testing Strategy Template

<!-- strategy/microservices-testing.md -->
# Microservices Testing Strategy

## Interview Answer Template

### Question: How would you test a microservices architecture?

**Framework:**
1. **Unit Tests (70%)** - Test individual service logic in isolation
2. **Integration Tests (20%)** - Test service-to-service communication
3. **E2E Tests (10%)** - Test critical user journeys across services

**Key Patterns:**
- Contract testing with Pact for API compatibility
- Consumer-driven contracts between services
- Service virtualization for dependent services
- Chaos engineering for resilience testing
- Distributed tracing for debugging cross-service issues

**Data Strategy:**
- Each service owns its test data
- Use database-per-service in test environments
- Implement test data factories per service
- Clean up test data after each test suite

**CI/CD Integration:**
- Run unit tests on every commit (< 5 minutes)
- Run integration tests on PR merge (< 15 minutes)
- Run E2E tests on staging deployment (< 30 minutes)
- Run performance tests nightly

Behavioral Interview Preparation

<!-- behavioral/star-method-examples.md -->
# STAR Method Interview Answers

## Situation: Flaky Test Investigation

**S:** Our CI pipeline had a 30% failure rate due to flaky E2E tests.
**T:** I was tasked with identifying and fixing the flaky tests.
**A:** I analyzed 2 weeks of test results, categorized failures by root cause
(timing issues 60%, data dependencies 25%, environment 15%), then:
1. Replaced all sleep() calls with explicit wait conditions
2. Introduced test data factories for independent test data
3. Added retry logic with exponential backoff for network-dependent tests
**R:** Flaky test rate dropped from 30% to under 2% in 3 weeks.

## Situation: Test Automation Framework Selection

**S:** The team was manually testing 500+ test cases per release.
**T:** Select and implement a test automation framework.
**A:** Evaluated 4 frameworks (Selenium, Playwright, Cypress, TestCafe) against