# Initialize a test automation repository
git init test-automation-project
cd test-automation-project

# Create initial test structure
mkdir -p tests/ui tests/api tests/integration
touch tests/ui/login.test.js tests/api/users.test.js

# Initial commit
git add .
git commit -m "Initial test structure"

# Create a feature branch for new login tests
git checkout -b feature/enhanced-login-tests

# Add new test file
cat > tests/ui/login-security.test.js << 'EOF'
const { test, expect } = require('@playwright/test');

test.describe('Login Security Tests', () => {
  test('should lock account after failed attempts', async ({ page }) => {
    await page.goto('https://practiceautomatedtesting.com/login');
    
    // Attempt login 5 times with wrong password
    for (let i = 0; i < 5; i++) {
      await page.fill('#username', 'testuser');
      await page.fill('#password', 'wrongpassword');
      await page.click('#login-button');
    }
    
    // Verify account locked message
    await expect(page.locator('.error-message'))
      .toContainText('Account locked');
  });
  
  test('should enforce password complexity', async ({ page }) => {
    await page.goto('https://practiceautomatedtesting.com/register');
    
    await page.fill('#password', 'weak');
    await page.blur('#password');
    
    await expect(page.locator('.password-strength'))
      .toContainText('Password too weak');
  });
});
EOF

git add tests/ui/login-security.test.js
git commit -m "Add enhanced login security tests"

# Fast-forward merge (only if main hasn't changed)
git checkout main
git merge --ff-only feature/enhanced-login-tests

# Preview diff between branches
git diff main..feature/enhanced-login-tests

# Preview specific test files
git diff main..feature/enhanced-login-tests -- tests/ui/

# Show statistics of changes
git diff --stat main..feature/enhanced-login-tests

# Create two parallel feature branches
git checkout -b feature/api-tests main
cat > tests/api/products.test.js << 'EOF'
const axios = require('axios');
const { expect } = require('chai');

describe('Products API Tests', () => {
  const BASE_URL = 'https://practiceautomatedtesting.com/api';
  
  it('should retrieve all products', async () => {
    const response = await axios.get(`${BASE_URL}/products`);
    expect(response.status).to.equal(200);
    expect(response.data).to.be.an('array');
    expect(response.data.length).to.be.greaterThan(0);
  });
  
  it('should filter products by category', async () => {
    const response = await axios.get(`${BASE_URL}/products?category=electronics`);
    expect(response.status).to.equal(200);
    response.data.forEach(product => {
      expect(product.category).to.equal('electronics');
    });
  });
});
EOF

git add tests/api/products.test.js
git commit -m "Add products API tests"

# Meanwhile, another developer creates integration tests
git checkout -b feature/integration-tests main
cat > tests/integration/checkout.test.js << 'EOF'
const { test, expect } = require('@playwright/test');

test.describe('Checkout Integration Tests', () => {
  test('should complete full purchase flow', async ({ page }) => {
    await page.goto('https://practiceautomatedtesting.com');
    
    // Add product to cart
    await page.click('.product-item:first-child .add-to-cart');
    await expect(page.locator('.cart-badge')).toContainText('1');
    
    // Navigate to checkout
    await page.click('.cart-icon');
    await page.click('#checkout-button');
    
    // Fill shipping details
    await page.fill('#shipping-name', 'Test User');
    await page.fill('#shipping-address', '123 Test St');
    await page.fill('#shipping-city', 'Test City');
    
    // Complete payment
    await page.fill('#card-number', '4111111111111111');
    await page.fill('#card-expiry', '12/25');
    await page.fill('#card-cvv', '123');
    
    await page.click('#place-order');
    
    // Verify order confirmation
    await expect(page.locator('.order-confirmation'))
      .toBeVisible();
  });
});
EOF

git add tests/integration/checkout.test.js
git commit -m "Add checkout integration tests"

# Merge both features into main
git checkout main
git merge feature/api-tests
git merge feature/integration-tests  # Three-way merge

# Create feature branch with multiple commits
git checkout -b feature/ui-improvements main

# Multiple small commits
echo "// Test utilities" > tests/utils/helpers.js
git add tests/utils/helpers.js
git commit -m "Add test helpers file"

echo "export const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));" >> tests/utils/helpers.js
git commit -am "Add wait helper"

echo "export const randomString = () => Math.random().toString(36).substring(7);" >> tests/utils/helpers.js
git commit -am "Add randomString helper"

# Preview all commits that will be squashed
git log main..feature/ui-improvements --oneline

# Squash merge to consolidate commits
git checkout main
git merge --squash feature/ui-improvements
git commit -m "Add test utility helpers (consolidated)"

# Simulate merge without committing
git checkout main
git merge --no-commit --no-ff feature/ui-improvements

# Preview the merged state
git diff --cached

# Check for conflicts
git status

# Abort if issues found
git merge --abort

# Or proceed with commit
git commit -m "Merge feature/ui-improvements"

// preview-tests.js - Run tests before merging
const { execSync } = require('child_process');

function previewMerge(sourceBranch, targetBranch) {
  console.log(`\n=== Previewing merge: ${sourceBranch} → ${targetBranch} ===\n`);
  
  try {
    // Save current branch
    const currentBranch = execSync('git branch --show-current').toString().trim();
    
    // Check diff statistics
    console.log('📊 Changes summary:');
    const diffStat = execSync(`git diff --stat ${targetBranch}..${sourceBranch}`).toString();
    console.log(diffStat);
    
    // Simulate merge
    console.log('\n🔄 Simulating merge...');
    execSync(`git checkout ${targetBranch}`);
    execSync(`git merge --no-commit --no-ff ${sourceBranch}`, { stdio: 'inherit' });
    
    // Run tests on merged code
    console.log('\n🧪 Running tests on merged code...');
    const testResult = execSync('npm test', { stdio: 'inherit' });
    
    // Abort merge
    execSync('git merge --abort');
    
    // Return to original branch
    execSync(`git checkout ${currentBranch}`);
    
    console.log('\n✅ Merge preview successful! Safe to merge.');
    return true;
    
  } catch (error) {
    console.error('\n❌ Merge preview failed!');
    
    // Cleanup
    execSync('git merge --abort');
    execSync(`git checkout ${currentBranch}`);
    
    return false;
  }
}

// Usage
previewMerge('feature/enhanced-login-tests', 'main');

# .github/merge-config.yml
merge:
  strategy: squash  # Options: merge, squash, rebase
  
  preview:
    required: true
    run_tests: true
    require_approval: 2
    
  rules:
    - pattern: "tests/**"
      strategy: merge  # Preserve test history
      reviewers: ["qa-team"]
      
    - pattern: "docs/**"
      strategy: squash  # Clean doc updates
      
    - pattern: "package.json"
      strategy: merge
      require_manual_review: true

  auto_merge:
    enabled: true
    conditions:
      - all_tests_pass
      - approvals >= 2
      - no_conflicts

// playwright.config.js - Configuration for merge previews
module.exports = {
  testDir: './tests',
  timeout: 30000,
  retries: process.env.CI ? 2 : 0,
  
  // Run different test suites based on branch
  projects: [
    {
      name: 'main-branch',
      testMatch: '**/*.test.js',
      use: {
        baseURL: 'https://practiceautomatedtesting.com',
        screenshot: 'only-on-failure',
        video: 'retain-on-failure'
      }
    },
    {
      name: 'feature-preview',
      testMatch: '**/*.test.js',
      use: {
        baseURL: process.env.PREVIEW_URL || 'https://practiceautomatedtesting.com',
        screenshot: 'on',  // Capture all for comparison
        video: 'on'
      }
    }
  ],
  
  // Reporter for merge preview comparison
  reporter: [
    ['html', { outputFolder: 'test-results-preview' }],
    ['json', { outputFile: 'test-results-preview.json' }]
  ]
};

# ❌ Wrong - Direct merge without review
git checkout main
git merge feature/new-tests

# ✅ Correct - Preview first
git diff main..feature/new-tests
git log main..feature/new-tests --oneline
npm test  # Run tests before merging
git merge feature/new-tests

# ❌ Wrong - Loses feature context
git merge --ff-only feature/major-refactor

# ✅ Correct - Preserve merge history for major changes
git merge --no-ff feature/major-refactor -m "Merge major test refactor"

# When conflicts occur in tests:
# ❌ Wrong - Using 'ours' or 'theirs' blindly
git checkout --ours tests/critical.test.js

# ✅ Correct - Manual review and test execution
git diff
# Manually resolve conflicts
npm test  # Verify tests still work
git add tests/critical.test.js
git commit

# ✅ Correct approach - Check dependencies before merge
git diff main..feature/new-tests -- package.json
npm install  # Update dependencies
npm test  # Verify compatibility
git merge feature/new-tests

# View merge conflicts
git status
git diff

# See which commits conflict
git log --merge

# Use merge tool for visual resolution
git mergetool

# Check test files specifically
git diff --name-only --diff-filter=U | grep test

# Abort and retry if needed
git merge --abort

# starter_code.py
from enum import Enum
from typing import Dict, List, Any
from copy import deepcopy

class MergeStrategy(Enum):
    OURS = "ours"
    THEIRS = "theirs"
    UNION = "union"
    MANUAL = "manual"

class ConfigMerger:
    def __init__(self):
        self.conflicts = []
        self.preview = {}
    
    # TODO: Implement merge_configs method
    def merge_configs(self, base: Dict, incoming: Dict, strategy: MergeStrategy) -> Dict:
        pass
    
    # TODO: Implement preview_merge method
    def preview_merge(self, base: Dict, incoming: Dict, strategy: MergeStrategy) -> Dict:
        pass
    
    # TODO: Implement detect_conflicts method
    def detect_conflicts(self, base: Dict, incoming: Dict) -> List[str]:
        pass