# Playwright Test Specification Template
## Prompt

please read @TEST_SPECIFICATION_TEMPLATE.md  , i need some playwight tests for @http://staging.ipw.co.za/ please check standard frontend ui and test the after the login also login details is : username : daniel , password : Betauser . Please run security , vunrability tests also and put it in same report as playwright. Create html and pdf report and email to jaco@overdrive.co.za , smtp details : mail.appnotify.co.za ,user: noreply@appnotify.co.za  , password : hA!85jyTn9bR#yB

##


## 📋 **Test Specification Overview**

This document provides a standardized template for creating Playwright tests that meet established quality standards for any website or web application testing suite.

---

## 🎯 **Test Structure Requirements**

### **Project Configuration**
Before using this template, configure your project settings:

```javascript
// playwright.config.js
export default defineConfig({
  // Base URL for your application
  use: {
    baseURL: process.env.BASE_URL || 'https://your-site.com',
  },
  
  // Database configuration
  env: {
    DB_HOST: process.env.DB_HOST || 'localhost',
    DB_USER: process.env.DB_USER || 'root',
    DB_PASSWORD: process.env.DB_PASSWORD || '',
    DB_NAME: process.env.DB_NAME || 'playwright_tests',
    DB_PORT: process.env.DB_PORT || '3306',
  }
});
```

### **File Naming Convention**
- **Format**: `{feature-name}.spec.js`
- **Example**: `dashboard.spec.js`, `user-management.spec.js`, `data-export.spec.js`
- **Location**: `tests/` directory

### **Test Suite Organization**
```javascript
import { test, expect } from '@playwright/test';

/**
 * Test Suite: [Feature Name]
 * 
 * Description: Brief description of what this test suite covers
 * Scope: What functionality is being tested
 * Dependencies: Any prerequisites or setup required
 */

test.describe('[Feature Name] Tests', () => {
  // Test cases go here
});
```

---

## 🧪 **Individual Test Requirements**

### **Test Naming Convention**
- **Format**: `should [expected behavior] when [condition]`
- **Examples**:
  - `should display user dashboard when user is authenticated`
  - `should show error message when invalid credentials are entered`
  - `should redirect to login page when accessing protected route`

### **Test Structure Template**
```javascript
test('should [expected behavior] when [condition]', async ({ page }) => {
  // 1. Setup/Arrange
  await page.goto('/path-to-test');
  
  // 2. Action/Act
  await page.click('[data-testid="button"]');
  
  // 3. Assertion/Assert
  await expect(page.locator('[data-testid="result"]')).toBeVisible();
});
```

---

## 🔍 **Test Content Requirements**

### **Required Test Elements**

#### **1. Accessibility Testing**
```javascript
test('should meet accessibility standards', async ({ page }) => {
  await page.goto('/page');
  
  // Check for proper heading structure
  const headings = await page.locator('h1, h2, h3, h4, h5, h6').count();
  expect(headings).toBeGreaterThan(0);
  
  // Check for alt text on images
  const images = await page.locator('img').count();
  const imagesWithAlt = await page.locator('img[alt]').count();
  expect(imagesWithAlt).toBe(images);
  
  // Check for ARIA labels
  const ariaElements = await page.locator('[aria-label]').count();
  expect(ariaElements).toBeGreaterThan(0);
});
```

#### **2. Performance Testing**
```javascript
test('should meet performance standards', async ({ page }) => {
  const startTime = Date.now();
  
  await page.goto('/page');
  
  const loadTime = Date.now() - startTime;
  
  // Page should load within 5 seconds
  expect(loadTime).toBeLessThan(5000);
  
  // Check for performance issues
  const performanceMetrics = await page.evaluate(() => {
    const navigation = performance.getEntriesByType('navigation')[0];
    return {
      pageLoadTime: navigation.loadEventEnd - navigation.loadEventStart,
      domContentLoaded: navigation.domContentLoadedEventEnd - navigation.domContentLoadedEventStart
    };
  });
  
  expect(performanceMetrics.pageLoadTime).toBeLessThan(3000);
  expect(performanceMetrics.domContentLoaded).toBeLessThan(2000);
});
```

#### **3. Responsiveness Testing**
```javascript
test('should be responsive on mobile devices', async ({ page }) => {
  // Test mobile viewport
  await page.setViewportSize({ width: 375, height: 667 });
  await page.goto('/page');
  
  // Check if mobile menu is accessible
  const mobileMenu = page.locator('[data-testid="mobile-menu"]');
  await expect(mobileMenu).toBeVisible();
  
  // Verify touch targets are appropriately sized
  const buttons = page.locator('button, a, [role="button"]');
  for (let i = 0; i < await buttons.count(); i++) {
    const button = buttons.nth(i);
    const box = await button.boundingBox();
    expect(box.width).toBeGreaterThanOrEqual(44);
    expect(box.height).toBeGreaterThanOrEqual(44);
  }
});
```

#### **4. Cross-Browser Compatibility**
```javascript
test('should work across different browsers', async ({ page }) => {
  await page.goto('/page');
  
  // Test basic functionality
  const title = await page.title();
  expect(title).toBeTruthy();
  
  // Test JavaScript functionality
  const jsEnabled = await page.evaluate(() => {
    return typeof window !== 'undefined' && typeof document !== 'undefined';
  });
  expect(jsEnabled).toBe(true);
});
```

---

## 📊 **Data Validation Requirements**

### **Form Testing Template**
```javascript
test('should validate form inputs correctly', async ({ page }) => {
  await page.goto('/form-page');
  
  // Test required field validation
  const submitButton = page.locator('[type="submit"]');
  await submitButton.click();
  
  // Check for validation messages
  const errorMessages = page.locator('.error-message, [role="alert"]');
  await expect(errorMessages.first()).toBeVisible();
  
  // Test valid input submission
  await page.fill('[name="email"]', 'test@example.com');
  await page.fill('[name="password"]', 'password123');
  await submitButton.click();
  
  // Verify successful submission
  await expect(page.locator('.success-message')).toBeVisible();
});
```

### **API Response Testing**
```javascript
test('should handle API responses correctly', async ({ page }) => {
  // Intercept API calls
  await page.route('**/api/**', route => {
    route.fulfill({
      status: 200,
      contentType: 'application/json',
      body: JSON.stringify({ success: true, data: 'test data' })
    });
  });
  
  await page.goto('/api-test-page');
  
  // Verify API response handling
  await expect(page.locator('[data-testid="api-result"]')).toBeVisible();
});
```

---

## 🛡️ **Security Testing Requirements**

### **Authentication Testing**
```javascript
test('should enforce authentication requirements', async ({ page }) => {
  // Try to access protected route without authentication
  await page.goto('/protected-page');
  
  // Should redirect to login
  await expect(page).toHaveURL(/.*login.*/);
  
  // Test with invalid credentials
  await page.fill('[name="username"]', 'invalid');
  await page.fill('[name="password"]', 'wrong');
  await page.click('[type="submit"]');
  
  // Should show error message
  await expect(page.locator('.error-message')).toBeVisible();
});
```

### **Input Sanitization Testing**
```javascript
test('should sanitize user inputs', async ({ page }) => {
  await page.goto('/input-test-page');
  
  // Test XSS prevention
  const maliciousInput = '<script>alert("xss")</script>';
  await page.fill('[name="userInput"]', maliciousInput);
  await page.click('[type="submit"]');
  
  // Verify input is sanitized
  const result = await page.locator('[data-testid="input-result"]').textContent();
  expect(result).not.toContain('<script>');
});
```

---

## 📱 **Mobile Testing Requirements**

### **Touch Interaction Testing**
```javascript
test('should support touch interactions', async ({ page }) => {
  await page.setViewportSize({ width: 375, height: 667 });
  await page.goto('/mobile-page');
  
  // Test touch gestures
  const element = page.locator('[data-testid="swipeable"]');
  const box = await element.boundingBox();
  
  // Simulate swipe gesture
  await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
  await page.mouse.down();
  await page.mouse.move(box.x - 100, box.y + box.height / 2);
  await page.mouse.up();
  
  // Verify swipe effect
  await expect(page.locator('[data-testid="swipe-result"]')).toBeVisible();
});
```

---

## 🔧 **Test Configuration Requirements**

### **Test Metadata**
```javascript
test.describe.configure({ mode: 'parallel' });

test.beforeEach(async ({ page }) => {
  // Common setup for all tests in this suite
  await page.goto('/');
});

test.afterEach(async ({ page }) => {
  // Cleanup after each test
  await page.evaluate(() => {
    localStorage.clear();
    sessionStorage.clear();
  });
});
```

### **Test Timeouts**
```javascript
test.setTimeout(30000); // 30 seconds for long-running tests

test('should complete within reasonable time', async ({ page }) => {
  // Test implementation
});
```

---

## 📈 **Performance Metrics Collection**

### **Required Metrics**
```javascript
test('should collect performance metrics', async ({ page }) => {
  const startTime = Date.now();
  
  await page.goto('/page');
  
  const loadTime = Date.now() - startTime;
  
  // Collect detailed performance data
  const metrics = await page.evaluate(() => {
    const navigation = performance.getEntriesByType('navigation')[0];
    const paint = performance.getEntriesByType('paint');
    
    return {
      totalLoadTime: navigation.loadEventEnd - navigation.navigationStart,
      domContentLoaded: navigation.domContentLoadedEventEnd - navigation.navigationStart,
      firstPaint: paint.find(p => p.name === 'first-paint')?.startTime,
      firstContentfulPaint: paint.find(p => p.name === 'first-contentful-paint')?.startTime
    };
  });
  
  // Log metrics for analysis
  console.log('Performance metrics:', metrics);
  
  // Assert performance requirements
  expect(metrics.totalLoadTime).toBeLessThan(5000);
  expect(metrics.firstContentfulPaint).toBeLessThan(2000);
});
```

---

## 🗄️ **Database Integration Requirements**

### **Database Setup**
Before using database integration, ensure you have:

1. **Database Configuration**: Set up your database connection in `.env` file:
   ```bash
   DB_HOST=localhost
   DB_USER=your_username
   DB_PASSWORD=your_password
   DB_NAME=your_database_name
   DB_PORT=3306
   ```

2. **Database Tables**: Create the required tables using the provided SQL schema:
   ```bash
   mysql -u your_username -p your_database_name < create_test_results_table.sql
   ```

### **Test Result Storage**

All tests must be designed to work with the database storage system. The test results are automatically saved to the configured database for tracking and monitoring.

#### **Required Test Metadata**

```javascript
/**
 * Test: should display user profile when authenticated
 * 
 * Purpose: Verify that authenticated users can view their profile information
 * 
 * Test Steps:
 * 1. Navigate to profile page
 * 2. Verify authentication check
 * 3. Display user information
 * 4. Verify data accuracy
 * 
 * Expected Results:
 * - Profile page loads successfully
 * - User information is displayed correctly
 * - No sensitive data is exposed
 * 
 * Dependencies:
 * - User must be authenticated
 * - Profile API must be accessible
 * 
 * Browser Support: Chrome, Firefox, Safari, Edge
 * Mobile Support: iOS Safari, Chrome Mobile
 * 
 * Database Integration:
 * - Test results will be stored in playwright_test_results table
 * - Performance metrics will be tracked over time
 * - Execution summaries will be created automatically
 * - Test trends will be analyzed for improvements
 */
test('should display user profile when authenticated', async ({ page }) => {
  // Test implementation
});
```

#### **Performance Metrics for Database Storage**

```javascript
test('should collect comprehensive performance metrics for database storage', async ({ page }) => {
  const startTime = Date.now();
  
  await page.goto('/page');
  
  const loadTime = Date.now() - startTime;
  
  // Collect detailed performance data for database storage
  const performanceMetrics = await page.evaluate(() => {
    const navigation = performance.getEntriesByType('navigation')[0];
    const paint = performance.getEntriesByType('paint');
    const resource = performance.getEntriesByType('resource');
    
    return {
      // Navigation timing
      pageLoadTime: navigation.loadEventEnd - navigation.loadEventStart,
      domContentLoaded: navigation.domContentLoadedEventEnd - navigation.domContentLoadedEventStart,
      firstByte: navigation.responseStart - navigation.requestStart,
      
      // Paint timing
      firstPaint: paint.find(p => p.name === 'first-paint')?.startTime,
      firstContentfulPaint: paint.find(p => p.name === 'first-contentful-paint')?.startTime,
      
      // Resource loading
      totalResources: resource.length,
      resourceLoadTime: resource.reduce((sum, r) => sum + (r.responseEnd - r.fetchStart), 0),
      
      // Memory usage (if available)
      memoryUsage: performance.memory ? {
        usedJSHeapSize: performance.memory.usedJSHeapSize,
        totalJSHeapSize: performance.memory.totalJSHeapSize,
        jsHeapSizeLimit: performance.memory.jsHeapSizeLimit
      } : null
    };
  });
  
  // Log metrics for database storage
  console.log('Performance metrics for database:', performanceMetrics);
  
  // Store metrics in test context for database integration
  test.info().annotations.push({
    type: 'performance',
    description: 'Performance metrics collected for database storage',
    data: performanceMetrics
  });
  
  // Assert performance requirements
  expect(performanceMetrics.pageLoadTime).toBeLessThan(5000);
  expect(performanceMetrics.firstContentfulPaint).toBeLessThan(2000);
});
```

#### **Test Execution Tracking**

```javascript
test('should provide execution context for database tracking', async ({ page }) => {
  // Test should include sufficient context for database analysis
  const testContext = {
    feature: 'user-profile',
    subFeature: 'profile-display',
    businessValue: 'high',
    testCategory: 'functional',
    testPriority: 'high',
    expectedDuration: 'short',
    dependencies: ['authentication', 'user-api'],
    riskLevel: 'low'
  };
  
  // Add context to test info for database storage
  test.info().annotations.push({
    type: 'test-context',
    description: 'Test execution context for database analysis',
    data: testContext
  });
  
  // Test implementation
  await page.goto('/profile');
  
  // Verify profile loads
  await expect(page.locator('[data-testid="profile-section"]')).toBeVisible();
});
```

---

## 💾 **Result Saving and Database Integration**

### **Automatic Result Storage**

All test results are automatically saved to the database using the `save-test-results.js` script. The system stores:

1. **Individual Test Results** (`playwright_test_results` table)
   - Test execution details
   - Performance metrics
   - Error information
   - Browser and platform details

2. **Execution Summaries** (`playwright_execution_summaries` table)
   - Overall test run statistics
   - Success rates and trends
   - Duration analysis

3. **Performance Trends** (`playwright_performance_trends` table)
   - Historical performance data
   - Trend analysis
   - Performance degradation alerts

### **Database Integration Commands**

```bash
# Run tests and automatically save results to database
npm run test:run-and-save

# Save existing test results to database
npm run test:save-results

# Check database connection
node check-db.js

# View database schema
node check-schema.js
```

### **Database Query Examples**

```sql
-- Get test success rate trends
SELECT 
    DATE(created_at) as test_date,
    test_suite,
    COUNT(*) as total_tests,
    SUM(CASE WHEN status = 'passed' THEN 1 ELSE 0 END) as passed_tests,
    ROUND((SUM(CASE WHEN status = 'passed' THEN 1 ELSE 0 END) / COUNT(*)) * 100, 2) as success_rate
FROM playwright_test_results 
WHERE site_url = '[YOUR_SITE_URL]'
GROUP BY DATE(created_at), test_suite
ORDER BY test_date DESC, test_suite;

-- Get performance trends
SELECT 
    DATE(created_at) as test_date,
    test_suite,
    AVG(duration_ms) as avg_duration,
    AVG(page_load_time_ms) as avg_page_load,
    AVG(dom_content_loaded_ms) as avg_dom_loaded
FROM playwright_test_results 
WHERE site_url = '[YOUR_SITE_URL]'
    AND duration_ms IS NOT NULL
GROUP BY DATE(created_at), test_suite
ORDER BY test_date DESC, test_suite;

-- Get browser performance comparison
SELECT 
    browser,
    COUNT(*) as total_tests,
    AVG(duration_ms) as avg_duration,
    AVG(page_load_time_ms) as avg_page_load,
    SUM(CASE WHEN status = 'passed' THEN 1 ELSE 0 END) as passed_tests,
    ROUND((SUM(CASE WHEN status = 'passed' THEN 1 ELSE 0 END) / COUNT(*)) * 100, 2) as success_rate
FROM playwright_test_results 
WHERE site_url = '[YOUR_SITE_URL]'
GROUP BY browser
ORDER BY avg_duration;
```

### **Database Schema Integration**

The test specification ensures compatibility with the database schema:

- **Test Identification**: `site_url`, `test_suite`, `test_name`, `test_file`
- **Execution Details**: `browser`, `platform`, `execution_id`, `start_time`, `end_time`
- **Performance Metrics**: `duration_ms`, `page_load_time_ms`, `dom_content_loaded_ms`
- **Error Handling**: `error_message`, `error_stack`, `failure_reason`
- **Environment Info**: `environment`, `branch`, `commit_hash`, `os_name`, `node_version`

---

## 🚨 **Error Handling Requirements**

### **Graceful Degradation Testing**
```javascript
test('should handle errors gracefully', async ({ page }) => {
  // Simulate network error
  await page.route('**/*', route => {
    route.abort('failed');
  });
  
  await page.goto('/page');
  
  // Should show error message
  await expect(page.locator('[data-testid="error-message"]')).toBeVisible();
  
  // Should provide retry option
  await expect(page.locator('[data-testid="retry-button"]')).toBeVisible();
});
```

---

## 📝 **Documentation Requirements**

### **Test Comments**
```javascript
/**
 * Test: should display user profile when authenticated
 * 
 * Purpose: Verify that authenticated users can view their profile information
 * 
 * Test Steps:
 * 1. Navigate to profile page
 * 2. Verify authentication check
 * 3. Display user information
 * 4. Verify data accuracy
 * 
 * Expected Results:
 * - Profile page loads successfully
 * - User information is displayed correctly
 * - No sensitive data is exposed
 * 
 * Dependencies:
 * - User must be authenticated
 * - Profile API must be accessible
 * 
 * Browser Support: Chrome, Firefox, Safari, Edge
 * Mobile Support: iOS Safari, Chrome Mobile
 */
test('should display user profile when authenticated', async ({ page }) => {
  // Test implementation
});
```

---

## ✅ **Quality Checklist**

Before submitting a test, ensure it meets all requirements:

- [ ] **File naming follows convention**
- [ ] **Test structure includes setup, action, and assertion**
- [ ] **Accessibility testing is included**
- [ ] **Performance testing is implemented**
- [ ] **Responsiveness testing covers mobile devices**
- [ ] **Cross-browser compatibility is verified**
- [ ] **Security testing is included**
- [ ] **Error handling is tested**
- [ ] **Performance metrics are collected**
- [ ] **Test documentation is complete**
- [ ] **Test follows established patterns**
- [ ] **No hardcoded values or credentials**
- [ ] **Proper error messages and logging**
- [ ] **Test is deterministic and repeatable**

---

## 🔄 **Test Execution Commands**

### **Run Specific Test**
```bash
# Run single test file
npm test tests/feature-name.spec.js

# Run specific test
npm test -- --grep "should display user profile"

# Run with specific browser
npm test -- --project=chromium

# Run with UI
npm run test:ui
```

### **Save Results to Database**
```bash
# Run tests and save results
npm run test:run-and-save

# Save existing results only
npm run test:save-results
```

---

## 📚 **Reference Examples**

### **Complete Test Example**
See existing test files for complete examples in your project:
- `tests/homepage.spec.js` - Basic page testing
- `tests/auth.spec.js` - Authentication testing
- `tests/accessibility.spec.js` - Accessibility compliance
- `tests/api.spec.js` - API endpoint testing
- `tests/feature-specific.spec.js` - Feature-specific functionality testing

### **Best Practices**
- Use `data-testid` attributes for reliable element selection
- Implement proper waiting strategies (avoid `page.waitForTimeout()`)
- Use descriptive test names that explain the expected behavior
- Group related tests in logical test suites
- Implement proper cleanup in `afterEach` hooks
- Use environment variables for configuration
- Implement proper error handling and logging

---

## 📞 **Support and Questions**

For questions about this specification or help implementing tests:
1. Review existing test files for examples
2. Check the `NewKnowledgeBase.md` for best practices
3. Refer to Playwright documentation: https://playwright.dev/
4. Run tests with `--debug` flag for troubleshooting

---

## 🚀 **Test Development Prompt Template**

Use this comprehensive prompt when building out new tests to ensure consistency and completeness. Remember to replace `[YOUR_SITE_URL]` with your actual website URL:

### **Complete Test Development Prompt**

```
I need to create a new Playwright test file for [FEATURE_NAME] on [YOUR_SITE_URL]. 

Please create a comprehensive test suite that follows the established standards:

**Feature Details:**
- Feature Name: [FEATURE_NAME]
- Description: [Brief description of what this feature does]
- Main Functionality: [List key functionality to test]
- User Journey: [Describe the typical user flow]
- Critical Paths: [List the most important test scenarios]

**Test Requirements:**
- File Name: [feature-name].spec.js
- Location: tests/ directory
- Must include accessibility testing
- Must include performance testing with metrics collection
- Must include responsive/mobile testing
- Must include security testing if applicable
- Must include error handling scenarios
- Must collect performance metrics for database storage
- Must follow the test naming convention: "should [expected behavior] when [condition]"

**Specific Test Scenarios:**
[List the specific test cases you want to cover]

**Database Integration:**
- Test results must be compatible with the configured database
- Include comprehensive performance metrics collection
- Add test context annotations for database analysis
- Ensure all metrics are properly logged for storage

**Accessibility Requirements:**
- WCAG compliance checks
- Keyboard navigation testing
- Screen reader support validation
- ARIA attributes verification
- Semantic HTML structure validation

**Performance Requirements:**
- Page load time < 5 seconds
- DOM content loaded < 2 seconds
- First contentful paint < 2 seconds
- Collect detailed performance metrics for trend analysis

**Security Requirements (if applicable):**
- Authentication validation
- Input sanitization testing
- XSS prevention verification
- CSRF protection testing
- Rate limiting validation

**Mobile/Responsive Requirements:**
- Touch interaction testing
- Mobile viewport validation
- Responsive design verification
- Touch target size validation (44x44px minimum)

**Error Handling:**
- Network error scenarios
- Invalid input handling
- Graceful degradation testing
- User-friendly error messages

**Documentation:**
- Comprehensive test comments
- Clear test purpose and steps
- Expected results documentation
- Dependencies and prerequisites
- Browser and mobile support notes

Please create the complete test file with:
1. Proper imports and test suite structure
2. All required test cases with comprehensive coverage
3. Performance metrics collection for database storage
4. Accessibility testing implementation
5. Mobile/responsive testing
6. Security testing (if applicable)
7. Error handling scenarios
8. Complete documentation and comments
9. Database integration annotations
10. Proper cleanup and teardown

The test should be production-ready and follow all established patterns from the existing test suite.
```

### **Quick Test Development Prompt (Simplified)**

```
Create a Playwright test file for [FEATURE_NAME] on [YOUR_SITE_URL] that includes:

- Accessibility testing (WCAG compliance, keyboard navigation)
- Performance testing with metrics collection for database storage
- Mobile/responsive testing
- Security testing (if applicable)
- Error handling scenarios
- Comprehensive documentation
- Database integration annotations

Follow the established patterns from existing test files in your project
```

### **Feature-Specific Test Prompts**

#### **For Dashboard/BI Features:**
```
Create a Playwright test for [DASHBOARD_FEATURE] that tests:
- Chart rendering and data visualization
- Filter and search functionality
- Data export capabilities
- Real-time updates
- Widget interactions
- Performance under data load
- Accessibility of charts and graphs
- Mobile responsiveness of dashboard elements
```

#### **For Authentication/Security Features:**
```
Create a Playwright test for [AUTH_FEATURE] that tests:
- Login/logout functionality
- Password validation
- Session management
- Security headers
- Rate limiting
- Input sanitization
- Error handling for invalid credentials
- Multi-factor authentication (if applicable)
```

#### **For API/Data Features:**
```
Create a Playwright test for [API_FEATURE] that tests:
- API endpoint availability
- Response validation
- Error handling
- Performance under load
- Data integrity
- Export functionality
- Rate limiting
- Authentication requirements
```

### **Test Execution and Validation Prompt**

```
After creating the test file, please:

1. Validate the test structure against the specification template
2. Ensure all required test elements are included
3. Verify database integration compatibility
4. Check performance metrics collection
5. Validate accessibility testing coverage
6. Confirm mobile/responsive testing
7. Verify error handling scenarios
8. Check documentation completeness
9. Run the test to ensure it executes properly
10. Validate that results can be saved to the database

Use these commands for testing:
- npm test tests/[feature-name].spec.js
- npm run test:run-and-save
- npm run test:save-results
```

---

*This specification ensures consistent, high-quality tests that provide reliable results for any website or web application testing suite.*