title: Testing Strategy & QA Checklist date: 2025-10-15 status: Planning tags: [testing, qa, quality-assurance, sprint4, sprint5]

Testing Strategy & QA Checklist

Purpose: Comprehensive testing strategy and quality assurance procedures for Sprint 4 and Sprint 5.

Scope: Frontend, Backend, Integration, Performance, Security, and User Acceptance Testing

🏗️ Testing Pyramid

           /\
          /  \
         / E2E \          10% - End-to-End Tests
        /______\
       /        \
      /Integration\       30% - Integration Tests
     /____________\
    /              \
   /  Unit Tests    \     60% - Unit Tests
  /__________________\

Philosophy

60% Unit Tests: Fast, isolated, test single components/functions
30% Integration Tests: Test component interactions, API integration
10% E2E Tests: Critical user flows only (login, application submission, etc.)

🧪 Backend Testing

1. Unit Tests (JUnit 5 + Mockito)

Current Status: 97.8% pass rate (390/399 tests passing)

Test Coverage Targets

Services: ≥90% coverage
Controllers: ≥85% coverage
Repositories: ≥80% coverage
Utilities: ≥95% coverage

Running Backend Tests

cd backend
./mvnw test
./mvnw test -Dtest=ArticleServiceTest  # Run specific test
./mvnw verify                          # Run all tests + integration tests

Example Test Structure

@SpringBootTest
@TestPropertySource(locations = "classpath:application-test.properties")
class ArticleServiceTest {

    @Autowired
    private ArticleService articleService;

    @MockBean
    private ArticleRepository articleRepository;

    @Test
    @DisplayName("Should create article with valid data")
    void shouldCreateArticleWithValidData() {
        // Given
        Article article = Article.builder()
            .title("Test Article")
            .content("Content")
            .category(ArticleCategory.CV_TIPS)
            .build();

        when(articleRepository.save(any(Article.class))).thenReturn(article);

        // When
        Article created = articleService.createArticle(article);

        // Then
        assertNotNull(created);
        assertEquals("Test Article", created.getTitle());
        assertNotNull(created.getSlug());
        verify(articleRepository, times(1)).save(any(Article.class));
    }

    @Test
    @DisplayName("Should throw exception when title is null")
    void shouldThrowExceptionWhenTitleIsNull() {
        // Given
        Article article = Article.builder()
            .content("Content")
            .build();

        // When & Then
        assertThrows(ValidationException.class, () -> {
            articleService.createArticle(article);
        });
    }
}

2. Controller Tests (MockMvc)

@WebMvcTest(ArticleController.class)
@Import(SecurityConfig.class)
class ArticleControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private ArticleService articleService;

    @Test
    @DisplayName("GET /api/kb/articles should return paginated articles")
    void shouldReturnPaginatedArticles() throws Exception {
        // Given
        Page<Article> articles = new PageImpl<>(List.of(
            createTestArticle(1L, "Article 1"),
            createTestArticle(2L, "Article 2")
        ));

        when(articleService.getPublishedArticles(any(Pageable.class)))
            .thenReturn(articles);

        // When & Then
        mockMvc.perform(get("/api/kb/articles")
                .param("page", "0")
                .param("size", "10"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.content").isArray())
            .andExpect(jsonPath("$.content.length()").value(2))
            .andExpect(jsonPath("$.content[0].title").value("Article 1"));
    }

    @Test
    @WithMockUser(roles = "ADMIN")
    @DisplayName("POST /api/admin/kb/articles should require admin role")
    void shouldRequireAdminRoleForCreate() throws Exception {
        // Given
        String articleJson = """
            {
                "title": "New Article",
                "content": "Content",
                "category": "CV_TIPS"
            }
            """;

        // When & Then
        mockMvc.perform(post("/api/admin/kb/articles")
                .contentType(MediaType.APPLICATION_JSON)
                .content(articleJson))
            .andExpect(status().isCreated());
    }
}

3. Repository Tests

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class ArticleRepositoryTest {

    @Autowired
    private ArticleRepository articleRepository;

    @Test
    @DisplayName("Should find article by slug")
    void shouldFindArticleBySlug() {
        // Given
        Article article = createTestArticle("test-article");
        articleRepository.save(article);

        // When
        Optional<Article> found = articleRepository.findBySlug("test-article");

        // Then
        assertTrue(found.isPresent());
        assertEquals("test-article", found.get().getSlug());
    }

    @Test
    @DisplayName("Should search articles by query")
    void shouldSearchArticlesByQuery() {
        // Given
        articleRepository.saveAll(List.of(
            createTestArticle("Java Developer Tips"),
            createTestArticle("Spring Boot Guide"),
            createTestArticle("React Tutorial")
        ));

        // When
        Page<Article> results = articleRepository.searchPublished(
            "java",
            PageRequest.of(0, 10)
        );

        // Then
        assertEquals(1, results.getTotalElements());
        assertEquals("Java Developer Tips", results.getContent().get(0).getTitle());
    }
}

4. Backend Testing Checklist

Sprint 4

[ ] Fix 9 failing tests (390/399 currently passing)
[ ] Add tests for SCSS optimization utilities (if any backend changes)
[ ] Verify all existing tests still pass after refactoring

Sprint 5 - Knowledge Base Backend

[ ] Article Entity Tests
- [ ] Test slug generation
- [ ] Test reading time calculation
- [ ] Test validation (title, content, category required)
- [ ] Test cascading operations (ratings, bookmarks)
[ ] Article Service Tests
- [ ] Test createArticle
- [ ] Test updateArticle
- [ ] Test deleteArticle
- [ ] Test publishArticle (status change)
- [ ] Test getArticleBySlug
- [ ] Test searchArticles (full-text search)
- [ ] Test getArticlesByCategory
- [ ] Test getRelatedArticles algorithm
[ ] Article Controller Tests
- [ ] Test GET /api/kb/articles (pagination)
- [ ] Test GET /api/kb/articles/{slug}
- [ ] Test GET /api/kb/articles/search?q={query}
- [ ] Test POST /api/kb/articles/{id}/view (track view)
- [ ] Test POST /api/kb/articles/{id}/rate (authenticated)
- [ ] Test POST /api/kb/articles/{id}/bookmark (authenticated)
[ ] Admin Controller Tests
- [ ] Test POST /api/admin/kb/articles (admin only)
- [ ] Test PUT /api/admin/kb/articles/{id} (admin only)
- [ ] Test DELETE /api/admin/kb/articles/{id} (admin only)
- [ ] Test POST /api/admin/kb/articles/{id}/publish (admin only)
- [ ] Test GET /api/admin/kb/analytics (admin only)
[ ] Repository Tests
- [ ] Test findBySlug (unique constraint)
- [ ] Test findByPublishedTrue
- [ ] Test findByCategoryAndPublishedTrue
- [ ] Test searchPublished (full-text search)
- [ ] Test custom queries for analytics

🎨 Frontend Testing

1. Component Tests (Angular Testing Library)

Framework: Jasmine + Karma (default Angular setup)

Running Frontend Tests

cd frontend/recruitment-portal
npm test                    # Run all tests
npm test -- --include='**/kb-home.component.spec.ts'  # Run specific test
npm run test:coverage       # Generate coverage report

Example Component Test

import { ComponentFixture, TestBed } from '@angular/core/testing';
import { HttpClientTestingModule } from '@angular/common/http/testing';
import { of, throwError } from 'rxjs';
import { KbHomeComponent } from './kb-home.component';
import { KbService } from '../../../services/kb.service';
import { ArticleCategory } from '../../../models/article-category.enum';

describe('KbHomeComponent', () => {
  let component: KbHomeComponent;
  let fixture: ComponentFixture<KbHomeComponent>;
  let kbService: jasmine.SpyObj<KbService>;

  beforeEach(async () => {
    const kbServiceSpy = jasmine.createSpyObj('KbService', [
      'getCategories',
      'getArticles'
    ]);

    await TestBed.configureTestingModule({
      imports: [KbHomeComponent, HttpClientTestingModule],
      providers: [
        { provide: KbService, useValue: kbServiceSpy }
      ]
    }).compileComponents();

    kbService = TestBed.inject(KbService) as jasmine.SpyObj<KbService>;
    fixture = TestBed.createComponent(KbHomeComponent);
    component = fixture.componentInstance;
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });

  it('should load categories on init', () => {
    // Given
    const mockCategories = [
      { category: ArticleCategory.CV_TIPS, count: 10 },
      { category: ArticleCategory.FAQ, count: 20 }
    ];
    kbService.getCategories.and.returnValue(of(mockCategories));

    // When
    fixture.detectChanges(); // triggers ngOnInit

    // Then
    expect(component.categories.length).toBe(2);
    expect(component.categories[0].count).toBe(10);
    expect(kbService.getCategories).toHaveBeenCalled();
  });

  it('should handle error when loading categories fails', () => {
    // Given
    kbService.getCategories.and.returnValue(
      throwError(() => new Error('API Error'))
    );

    // When
    fixture.detectChanges();

    // Then
    expect(component.error).toBe('Kon categorieën niet laden.');
  });

  it('should navigate to search on search submit', () => {
    // Given
    component.searchQuery = 'java developer';
    spyOn(component['router'], 'navigate');

    // When
    component.onSearch();

    // Then
    expect(component['router'].navigate).toHaveBeenCalledWith(
      ['/kennisbank/zoeken'],
      { queryParams: { q: 'java developer' } }
    );
  });
});

2. Service Tests

import { TestBed } from '@angular/core/testing';
import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
import { KbService } from './kb.service';
import { Article } from '../models/article.model';
import { ArticleCategory } from '../models/article-category.enum';

describe('KbService', () => {
  let service: KbService;
  let httpMock: HttpTestingController;

  beforeEach(() => {
    TestBed.configureTestingModule({
      imports: [HttpClientTestingModule],
      providers: [KbService]
    });
    service = TestBed.inject(KbService);
    httpMock = TestBed.inject(HttpTestingController);
  });

  afterEach(() => {
    httpMock.verify(); // Ensure no outstanding HTTP requests
  });

  it('should fetch articles', () => {
    // Given
    const mockResponse = {
      articles: [
        { id: 1, title: 'Article 1', slug: 'article-1' },
        { id: 2, title: 'Article 2', slug: 'article-2' }
      ],
      totalElements: 2,
      totalPages: 1,
      currentPage: 0
    };

    // When
    service.getArticles(0, 10).subscribe(result => {
      // Then
      expect(result.articles.length).toBe(2);
      expect(result.totalElements).toBe(2);
    });

    const req = httpMock.expectOne(req =>
      req.url.includes('/api/kb/articles') &&
      req.params.get('page') === '0'
    );
    expect(req.request.method).toBe('GET');
    req.flush(mockResponse);
  });

  it('should search articles with query parameter', () => {
    // Given
    const query = 'java';

    // When
    service.searchArticles(query, 0, 10).subscribe();

    // Then
    const req = httpMock.expectOne(req =>
      req.url.includes('/api/kb/articles/search') &&
      req.params.get('q') === query
    );
    expect(req.request.method).toBe('GET');
    req.flush({ articles: [], totalElements: 0, totalPages: 0, currentPage: 0 });
  });

  it('should rate article', () => {
    // Given
    const articleId = 1;
    const rating = 5;

    // When
    service.rateArticle(articleId, rating).subscribe();

    // Then
    const req = httpMock.expectOne(`${service['apiUrl']}/articles/${articleId}/rate`);
    expect(req.request.method).toBe('POST');
    expect(req.request.body).toEqual({ rating: 5 });
    req.flush({ id: 1, articleId, rating, userId: 1, createdAt: new Date() });
  });
});

3. Frontend Testing Checklist

Sprint 4

[ ] CV Upload Button Component
- [ ] Test button renders
- [ ] Test click handler for authenticated users
- [ ] Test redirect for unauthenticated users
- [ ] Test disabled state during upload
- [ ] Test error handling
[ ] CV Upload Modal Component
- [ ] Test modal opens/closes
- [ ] Test file selection
- [ ] Test file validation (size, type)
- [ ] Test upload progress
- [ ] Test success message
- [ ] Test error message
[ ] SCSS Optimization
- [ ] Verify no visual regressions after refactoring
- [ ] Test shared styles applied correctly
- [ ] Verify build succeeds without budget warnings

Sprint 5 - Knowledge Base Frontend

[ ] KB Home Component
- [ ] Test categories load and display
- [ ] Test search input and submission
- [ ] Test featured articles render
- [ ] Test popular articles render
- [ ] Test loading state
- [ ] Test error state
[ ] Article Detail Component
- [ ] Test article loads by slug
- [ ] Test markdown rendering
- [ ] Test view tracking
- [ ] Test rating widget (authenticated)
- [ ] Test bookmark button (authenticated)
- [ ] Test share buttons
- [ ] Test related articles
- [ ] Test 404 for invalid slug
[ ] Article List Component
- [ ] Test articles filtered by category
- [ ] Test pagination
- [ ] Test search within category
- [ ] Test tag filtering
- [ ] Test empty state
[ ] Search Results Component
- [ ] Test search results display
- [ ] Test search query highlighting
- [ ] Test no results message
- [ ] Test pagination
[ ] Admin KB Editor Component
- [ ] Test form validation
- [ ] Test markdown editor
- [ ] Test live preview
- [ ] Test create article
- [ ] Test update article
- [ ] Test publish toggle
- [ ] Test image upload
- [ ] Test save and cancel

🔗 Integration Testing

1. API Integration Tests

Tools: Postman or REST Assured (Java)

Example REST Assured Test

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ArticleIntegrationTest {

    @LocalServerPort
    private int port;

    @Autowired
    private ArticleRepository articleRepository;

    private String baseUrl;

    @BeforeEach
    void setUp() {
        baseUrl = "http://localhost:" + port;
        articleRepository.deleteAll();
    }

    @Test
    @DisplayName("Should create, retrieve, and update article via API")
    void shouldPerformFullArticleCRUD() {
        // Create article
        String createJson = """
            {
                "title": "Integration Test Article",
                "summary": "Test summary",
                "content": "Test content",
                "category": "CV_TIPS",
                "tags": ["test", "integration"]
            }
            """;

        Article created = given()
            .contentType(ContentType.JSON)
            .body(createJson)
            .when()
            .post(baseUrl + "/api/admin/kb/articles")
            .then()
            .statusCode(201)
            .extract()
            .as(Article.class);

        assertNotNull(created.getId());
        assertNotNull(created.getSlug());

        // Retrieve article
        Article retrieved = given()
            .when()
            .get(baseUrl + "/api/kb/articles/" + created.getSlug())
            .then()
            .statusCode(200)
            .extract()
            .as(Article.class);

        assertEquals(created.getId(), retrieved.getId());
        assertEquals("Integration Test Article", retrieved.getTitle());

        // Update article
        String updateJson = """
            {
                "title": "Updated Integration Test Article",
                "content": "Updated content"
            }
            """;

        given()
            .contentType(ContentType.JSON)
            .body(updateJson)
            .when()
            .put(baseUrl + "/api/admin/kb/articles/" + created.getId())
            .then()
            .statusCode(200);

        // Verify update
        Article updated = given()
            .when()
            .get(baseUrl + "/api/kb/articles/" + created.getSlug())
            .then()
            .statusCode(200)
            .extract()
            .as(Article.class);

        assertEquals("Updated Integration Test Article", updated.getTitle());
    }
}

2. Integration Testing Checklist

[ ] Authentication Flow
- [ ] Login with valid credentials
- [ ] Login with invalid credentials
- [ ] JWT token generation
- [ ] JWT token validation
- [ ] Token expiration handling
- [ ] Refresh token flow
[ ] Application Submission Flow
- [ ] Submit application with CV
- [ ] Upload CV to MinIO
- [ ] Store application in database
- [ ] Send confirmation email
- [ ] Admin can view application
- [ ] Admin can update status
[ ] Knowledge Base Flow
- [ ] Admin creates article
- [ ] Article slug generated
- [ ] Article published
- [ ] User views article
- [ ] View count incremented
- [ ] User rates article
- [ ] Average rating updated
- [ ] User bookmarks article
- [ ] Search returns correct results

⚡ Performance Testing

1. Backend Performance

Tools: JMeter or Gatling

Key Metrics

Response Time: <500ms for 95th percentile
Throughput: ≥100 requests/second
Error Rate: <1%

Test Scenarios

Scenario 1: Article List API
- 100 concurrent users
- Duration: 5 minutes
- Requests: GET /api/kb/articles?page=0&size=10
- Expected: <200ms average response time

Scenario 2: Article Search API
- 50 concurrent users
- Duration: 5 minutes
- Requests: GET /api/kb/articles/search?q=java
- Expected: <500ms average response time

Scenario 3: Article Detail API
- 200 concurrent users
- Duration: 5 minutes
- Requests: GET /api/kb/articles/{slug}
- Expected: <150ms average response time

2. Frontend Performance

Tools: Lighthouse, WebPageTest

Performance Targets

First Contentful Paint (FCP): <1.8s
Largest Contentful Paint (LCP): <2.5s
Time to Interactive (TTI): <3.8s
Cumulative Layout Shift (CLS): <0.1
Total Blocking Time (TBT): <200ms
Lighthouse Score: ≥90

Bundle Size Targets

Initial Bundle: <500 kB
Lazy-loaded Routes: <200 kB each
SCSS per Component: <8 kB (already fixed in Sprint 4)

3. Performance Testing Checklist

[ ] Backend Performance
- [ ] Load test article list API
- [ ] Load test search API
- [ ] Load test article detail API
- [ ] Load test authentication API
- [ ] Database query optimization (indexes)
- [ ] Connection pool tuning
- [ ] Cache hit rate monitoring (Redis)
[ ] Frontend Performance
- [ ] Run Lighthouse audit (desktop)
- [ ] Run Lighthouse audit (mobile)
- [ ] Measure bundle sizes
- [ ] Test lazy loading
- [ ] Test image optimization
- [ ] Test code splitting
- [ ] Monitor network waterfall

🔒 Security Testing

1. Security Checklist

Authentication & Authorization

[ ] Test login with SQL injection attempts
[ ] Test XSS in input fields
[ ] Test CSRF protection
[ ] Test JWT token tampering
[ ] Test expired token handling
[ ] Test role-based access control (USER, RECRUITER, ADMIN)
[ ] Test unauthorized API access

Input Validation

[ ] Test article title with special characters
[ ] Test article content with script tags
[ ] Test file upload with malicious files
[ ] Test SQL injection in search queries
[ ] Test path traversal in file uploads
[ ] Test maximum input lengths

API Security

[ ] Test rate limiting
[ ] Test CORS configuration
[ ] Test HTTPS enforcement
[ ] Test sensitive data exposure in responses
[ ] Test API versioning
[ ] Test error message information disclosure

Dependencies

[ ] Run npm audit (frontend)
[ ] Run ./mvnw dependency-check:check (backend)
[ ] Update vulnerable dependencies
[ ] Verify no hardcoded secrets

2. OWASP Top 10 Testing

# Backend dependency check
cd backend
./mvnw org.owasp:dependency-check-maven:check

# Frontend audit
cd frontend/recruitment-portal
npm audit
npm audit fix

♿ Accessibility Testing

1. WCAG 2.1 AA Compliance

Tools: axe DevTools, WAVE, Lighthouse Accessibility Audit

2. Accessibility Checklist

Keyboard Navigation

[ ] All interactive elements accessible via Tab
[ ] Focus visible on all elements
[ ] Modal dialogs trap focus correctly
[ ] Escape key closes modals
[ ] Enter key activates buttons
[ ] Arrow keys work in menus/lists

Screen Readers

[ ] Test with NVDA (Windows)
[ ] Test with JAWS (Windows)
[ ] Test with VoiceOver (macOS)
[ ] All images have alt text
[ ] Form inputs have labels
[ ] Buttons have descriptive text
[ ] Links have descriptive text
[ ] ARIA labels where needed

Visual

[ ] Color contrast ratio ≥4.5:1 (normal text)
[ ] Color contrast ratio ≥3:1 (large text)
[ ] Information not conveyed by color alone
[ ] Text resizable to 200% without loss of content
[ ] No horizontal scrolling at 320px width

Forms

[ ] All inputs have associated labels
[ ] Required fields marked with aria-required
[ ] Error messages linked with aria-describedby
[ ] Success messages announced to screen readers

🌐 Cross-Browser Testing

1. Browser Matrix

| Browser | Version | Desktop | Mobile | |---------|---------|---------|--------| | Chrome | Latest | ✅ | ✅ | | Firefox | Latest | ✅ | ✅ | | Safari | Latest | ✅ | ✅ | | Edge | Latest | ✅ | N/A |

2. Cross-Browser Checklist

[ ] Chrome (Desktop)
- [ ] Layout renders correctly
- [ ] All interactions work
- [ ] Performance acceptable
- [ ] Console has no errors
[ ] Firefox (Desktop)
- [ ] Layout renders correctly
- [ ] All interactions work
- [ ] Performance acceptable
- [ ] Console has no errors
[ ] Safari (Desktop)
- [ ] Layout renders correctly
- [ ] All interactions work
- [ ] Performance acceptable
- [ ] Console has no errors
[ ] Edge (Desktop)
- [ ] Layout renders correctly
- [ ] All interactions work
- [ ] Performance acceptable
- [ ] Console has no errors

📱 Mobile Testing

1. Device Matrix

| Device Category | Viewport | Test Devices | |----------------|----------|--------------| | Small Mobile | 320px | iPhone SE | | Medium Mobile | 375px | iPhone 12 | | Large Mobile | 414px | iPhone 14 Pro Max | | Tablet | 768px | iPad | | Large Tablet | 1024px | iPad Pro |

2. Mobile Testing Checklist

Layout

[ ] No horizontal scrolling
[ ] All content visible
[ ] Text readable without zooming
[ ] Images scale properly
[ ] Buttons large enough to tap (minimum 44x44px)

Touch Interactions

[ ] All buttons tappable
[ ] Swipe gestures work (if applicable)
[ ] Form inputs focus properly
[ ] Modal dialogs work on mobile
[ ] Dropdown menus accessible

Performance

[ ] Fast initial load on 3G
[ ] Smooth scrolling
[ ] No jank during animations
[ ] Images lazy-loaded

👥 User Acceptance Testing (UAT)

1. Test Scenarios

Scenario 1: Job Application (Candidate)

Browse job listings
View job detail
Upload CV
Fill application form
Submit application
Receive confirmation

Acceptance Criteria:

Application submitted successfully
CV uploaded to profile
Confirmation email received
Application visible in "My Applications"

Scenario 2: Knowledge Base Search (Visitor)

Visit Knowledge Base home
Search for "CV tips"
View search results
Click on article
Read article
Rate article (if logged in)

Acceptance Criteria:

Search returns relevant results
Article renders correctly
Markdown formatting displays properly
Rating saved successfully

Scenario 3: Article Management (Admin)

Login as admin
Navigate to KB admin
Create new article
Add markdown content
Preview article
Publish article
Verify published on public site

Acceptance Criteria:

Article created successfully
Markdown rendered correctly
Article visible to public
Slug generated automatically

2. UAT Checklist

[ ] Test all user scenarios with real users
[ ] Collect feedback on usability
[ ] Document pain points
[ ] Verify all acceptance criteria met
[ ] Sign-off from stakeholders

🗃️ Test Data Management

1. Test Database Setup

-- Create test database
CREATE DATABASE interimplaza_test;

-- Seed test data
INSERT INTO articles (title, slug, content, category, published) VALUES
  ('Test Article 1', 'test-article-1', '# Test Content', 'CV_TIPS', true),
  ('Test Article 2', 'test-article-2', '# Test Content', 'FAQ', true);

INSERT INTO users (email, password, role) VALUES
  ('test@example.com', '$2a$10$...', 'USER'),
  ('admin@interimplaza.nl', '$2a$10$...', 'ADMIN');

2. Test Data Checklist

[ ] Create test users (USER, RECRUITER, ADMIN roles)
[ ] Create test articles (all categories)
[ ] Create test job listings
[ ] Create test applications
[ ] Create test ratings/bookmarks
[ ] Reset test database before each test run

🐛 Bug Reporting Workflow

1. Bug Report Template

**Title:** [Component] Brief description

**Severity:** Critical | High | Medium | Low

**Environment:**
- Browser: Chrome 120
- OS: macOS 14.0
- Device: Desktop

**Steps to Reproduce:**
1. Navigate to /kennisbank
2. Click on "CV Tips" category
3. Observe error

**Expected Result:**
Should display list of CV tip articles

**Actual Result:**
Page shows 500 error

**Screenshots:**
[Attach screenshot]

**Console Errors:**

Error: Cannot read property 'articles' of undefined


**Additional Context:**
Only happens when user is not logged in

2. Bug Severity Levels

Critical: Application crashes, data loss, security vulnerability
High: Major feature broken, blocking workflow
Medium: Minor feature broken, workaround exists
Low: Cosmetic issue, typo, minor UX improvement

✅ Final QA Sign-Off Checklist

Sprint 4 Completion Criteria

[ ] Build succeeds without SCSS budget warnings
[ ] All backend tests passing (399/399)
[ ] All frontend tests passing
[ ] CV upload button functional
[ ] Admin navigation implemented
[ ] Mobile responsive (320px+)
[ ] Cross-browser compatibility verified
[ ] Performance targets met
[ ] Accessibility audit passed (≥90 score)
[ ] Security audit passed
[ ] UAT sign-off received

Sprint 5 Completion Criteria

[ ] Knowledge Base backend deployed
[ ] All KB API endpoints tested
[ ] 20+ articles published
[ ] KB frontend fully functional
[ ] Search returns accurate results (<1s)
[ ] Admin can manage articles
[ ] Rating/bookmark system working
[ ] All 6 categories populated
[ ] Mobile responsive KB interface
[ ] Performance targets met
[ ] Accessibility audit passed
[ ] Security audit passed
[ ] UAT sign-off received

Last Updated: 2025-10-15 Status: Ready for Implementation Testing Framework: JUnit 5, Jasmine/Karma, Playwright (E2E)

Reacties

Nog geen reacties

Athena — mahmoud-consultancy/archive/old-docs/setup/TESTING_STRATEGY_QA_CHECKLIST.md

title: Testing Strategy & QA Checklist date: 2025-10-15 status: Planning tags: [testing, qa, quality-assurance, sprint4, sprint5]

Testing Strategy & QA Checklist

📋 Table of Contents

🏗️ Testing Pyramid

Philosophy

🧪 Backend Testing

1. Unit Tests (JUnit 5 + Mockito)

Test Coverage Targets

Running Backend Tests

Example Test Structure

2. Controller Tests (MockMvc)

3. Repository Tests

4. Backend Testing Checklist

Sprint 4

Sprint 5 - Knowledge Base Backend

🎨 Frontend Testing

1. Component Tests (Angular Testing Library)

Running Frontend Tests

Example Component Test

2. Service Tests

3. Frontend Testing Checklist

Sprint 4

Sprint 5 - Knowledge Base Frontend

🔗 Integration Testing

1. API Integration Tests

Example REST Assured Test

2. Integration Testing Checklist

⚡ Performance Testing

1. Backend Performance

Key Metrics

Test Scenarios

2. Frontend Performance

Performance Targets

Bundle Size Targets

3. Performance Testing Checklist

🔒 Security Testing

1. Security Checklist

Authentication & Authorization

Input Validation

API Security

Dependencies

2. OWASP Top 10 Testing

♿ Accessibility Testing

1. WCAG 2.1 AA Compliance

2. Accessibility Checklist

Keyboard Navigation

Screen Readers

Visual

Forms

🌐 Cross-Browser Testing

1. Browser Matrix

2. Cross-Browser Checklist

📱 Mobile Testing

1. Device Matrix

2. Mobile Testing Checklist

Layout

Touch Interactions

Performance

👥 User Acceptance Testing (UAT)

1. Test Scenarios

Scenario 1: Job Application (Candidate)

Scenario 2: Knowledge Base Search (Visitor)

Scenario 3: Article Management (Admin)

2. UAT Checklist

🗃️ Test Data Management

1. Test Database Setup

2. Test Data Checklist

🐛 Bug Reporting Workflow

1. Bug Report Template

2. Bug Severity Levels

✅ Final QA Sign-Off Checklist

Sprint 4 Completion Criteria

Sprint 5 Completion Criteria

Reacties