Automated Testing Strategies for AEM Components: Reducing Bugs by 20%

<dependencies>
    <!-- AEM Mocks for unit testing -->
    <dependency>
        <groupId>io.wcm</groupId>
        <artifactId>io.wcm.testing.aem-mock.junit5</artifactId>
        <version>4.1.8</version>
        <scope>test</scope>
    </dependency>
    
    <!-- JUnit 5 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.8.2</version>
        <scope>test</scope>
    </dependency>
    
    <!-- Mockito for advanced mocking -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>4.6.1</version>
        <scope>test</scope>
    </dependency>
    
    <!-- AssertJ for fluent assertions -->
    <dependency>
        <groupId>org.assertj</groupId>
        <artifactId>assertj-core</artifactId>
        <version>3.23.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

@ExtendWith(AemContextExtension.class)
class HeroBannerModelTest {
    
    private final AemContext context = new AemContext();
    
    @BeforeEach
    void setUp() {
        // Register models and services
        context.addModelsForClasses(HeroBannerModel.class, CardItem.class);
        context.registerService(ContentService.class, new MockContentService());
        
        // Load test content
        context.load().json("/test-content/hero-banner-test.json", "/content/test");
        context.load().binaryFile("/test-assets/hero-image.jpg", "/content/dam/test/hero.jpg");
    }
    
    @Test
    @DisplayName("Should initialize fully configured component correctly")
    void testFullyConfiguredComponent() {
        // Given
        Resource resource = context.resourceResolver()
            .getResource("/content/test/hero-banner-full");
        
        // When
        HeroBannerModel model = resource.adaptTo(HeroBannerModel.class);
        
        // Then
        assertThat(model).isNotNull();
        assertThat(model.isConfigured()).isTrue();
        assertThat(model.getTitle()).isEqualTo("Enterprise Solutions");
        assertThat(model.getSubtitle()).isEqualTo("Transform Your Business");
        assertThat(model.getDescription()).contains("leading enterprise");
        assertThat(model.hasImage()).isTrue();
        assertThat(model.getImageUrl()).contains("/content/dam/test/hero.jpg");
        assertThat(model.getImageAlt()).isEqualTo("Enterprise solutions hero");
        assertThat(model.hasCta()).isTrue();
        assertThat(model.getCtaText()).isEqualTo("Learn More");
        assertThat(model.getCtaUrl()).isEqualTo("/solutions");
        assertThat(model.getCardItems()).hasSize(3);
    }
    
    @Test
    @DisplayName("Should handle empty component gracefully")
    void testEmptyComponent() {
        // Given
        Resource resource = context.resourceResolver()
            .getResource("/content/test/hero-banner-empty");
        
        // When
        HeroBannerModel model = resource.adaptTo(HeroBannerModel.class);
        
        // Then
        assertThat(model).isNotNull();
        assertThat(model.isConfigured()).isFalse();
        assertThat(model.getTitle()).isEmpty();
        assertThat(model.hasImage()).isFalse();
        assertThat(model.hasCta()).isFalse();
        assertThat(model.getCardItems()).isEmpty();
    }
    
    @Test
    @DisplayName("Should validate and sanitize user input")
    void testInputValidation() {
        // Given
        context.build()
            .resource("/content/test/hero-banner-malicious")
            .siblingsMode()
            .resource("jcr:content", 
                "title", "<script>alert('xss')</script>Malicious Title",
                "description", "javascript:void(0)",
                "ctaUrl", "javascript:alert('xss')")
            .commit();
        
        Resource resource = context.resourceResolver()
            .getResource("/content/test/hero-banner-malicious");
        
        // When
        HeroBannerModel model = resource.adaptTo(HeroBannerModel.class);
        
        // Then
        assertThat(model.getTitle()).doesNotContain("<script>");
        assertThat(model.getTitle()).isEqualTo("Malicious Title");
        assertThat(model.getCtaUrl()).doesNotContain("javascript:");
        assertThat(model.getCtaUrl()).isEmpty(); // Invalid URLs should be filtered
    }
    
    @Test
    @DisplayName("Should generate correct JSON export")
    void testJsonExport() {
        // Given
        Resource resource = context.resourceResolver()
            .getResource("/content/test/hero-banner-full");
        HeroBannerModel model = resource.adaptTo(HeroBannerModel.class);
        
        // When
        String jsonConfig = model.getJsonConfig();
        
        // Then
        assertThat(jsonConfig).isNotEmpty();
        assertThat(jsonConfig).contains(""hasImage":true");
        assertThat(jsonConfig).contains(""hasCta":true");
        assertThat(jsonConfig).contains(""cardCount":3");
        
        // Verify it&apos;s valid JSON
        assertThatCode(() -> new ObjectMapper().readTree(jsonConfig))
            .doesNotThrowAnyException();
    }
    
    @Test
    @DisplayName("Should handle asset references correctly")
    void testAssetHandling() {
        // Given - Create test asset
        context.build()
            .resource("/content/dam/test/hero.jpg", 
                "jcr:primaryType", "dam:Asset")
            .resource("jcr:content", 
                "jcr:primaryType", "dam:AssetContent")
            .resource("metadata", 
                "dc:title", "Hero Image",
                "dam:scene7ID", "enterprise/hero-2024")
            .commit();
        
        Resource resource = context.resourceResolver()
            .getResource("/content/test/hero-banner-full");
        
        // When
        HeroBannerModel model = resource.adaptTo(HeroBannerModel.class);
        
        // Then
        assertThat(model.getImageUrl()).contains("/content/dam/test/hero.jpg");
        assertThat(model.getResponsiveImageSrcset()).isNotEmpty();
        assertThat(model.getResponsiveImageSizes()).contains("(max-width: 768px)");
    }
    
    @Test
    @DisplayName("Should cache expensive operations")
    void testCachingBehavior() {
        // Given
        Resource resource = context.resourceResolver()
            .getResource("/content/test/hero-banner-full");
        HeroBannerModel model = resource.adaptTo(HeroBannerModel.class);
        
        // When - Call expensive operation multiple times
        long start1 = System.nanoTime();
        List<CardItem> cards1 = model.getCardItems();
        long duration1 = System.nanoTime() - start1;
        
        long start2 = System.nanoTime();
        List<CardItem> cards2 = model.getCardItems();
        long duration2 = System.nanoTime() - start2;
        
        // Then
        assertThat(cards1).isEqualTo(cards2);
        assertThat(duration2).isLessThan(duration1 / 2); // Second call should be much faster
    }
}

@ExtendWith(AemContextExtension.class)
class HeroBannerIntegrationTest {
    
    private final AemContext context = new AemContext(ResourceResolverType.JCR_OAK);
    
    @BeforeEach
    void setUp() throws Exception {
        // Set up AEM context with real Oak repository
        context.registerInjectActivateService(new ContentServiceImpl());
        context.registerInjectActivateService(new AssetTransformationService());
        context.addModelsForClasses(HeroBannerModel.class, CardItem.class);
        
        // Load complete page structure
        context.load().json("/test-content/integration/full-page.json", "/content/test");
        context.load().json("/test-content/integration/content-fragments.json", "/content/dam/fragments");
    }
    
    @Test
    @DisplayName("Should render component HTML correctly")
    void testComponentRendering() throws Exception {
        // Given
        Resource pageResource = context.resourceResolver()
            .getResource("/content/test/homepage");
        context.currentResource(pageResource.getChild("jcr:content/root/hero-banner"));
        
        // When
        String renderedHtml = context.render().component().getOutput();
        
        // Then
        assertThat(renderedHtml)
            .contains("class="hero-banner"")
            .contains("Enterprise Solutions")
            .contains("hero-banner__image")
            .contains("data-analytics-event="hero-banner-view"")
            .contains("src="/content/dam/test/hero.jpg"")
            .doesNotContain("<script>"); // Security check
    }
    
    @Test
    @DisplayName("Should integrate with content fragments")
    void testContentFragmentIntegration() {
        // Given
        Resource fragmentResource = context.resourceResolver()
            .getResource("/content/dam/fragments/hero-content");
        
        // When
        context.build()
            .resource("/content/test/cf-hero")
            .resource("jcr:content", 
                "sling:resourceType", "enterprise/components/content/hero-banner",
                "contentFragment", "/content/dam/fragments/hero-content")
            .commit();
        
        Resource componentResource = context.resourceResolver()
            .getResource("/content/test/cf-hero");
        HeroBannerModel model = componentResource.adaptTo(HeroBannerModel.class);
        
        // Then
        assertThat(model).isNotNull();
        assertThat(model.getTitle()).isEqualTo("Fragment Title");
        assertThat(model.getDescription()).contains("fragment content");
    }
    
    @Test
    @DisplayName("Should handle workflow integration")
    void testWorkflowIntegration() {
        // Given
        WorkflowSession workflowSession = context.resourceResolver()
            .adaptTo(WorkflowSession.class);
        assertThat(workflowSession).isNotNull();
        
        // When - Create content that triggers workflow
        Resource newContent = context.build()
            .resource("/content/test/workflow-content")
            .resource("jcr:content",
                "sling:resourceType", "enterprise/components/content/hero-banner",
                "title", "Workflow Test",
                "cq:workflowInstanceId", "test-workflow-instance")
            .commit();
        
        // Then
        HeroBannerModel model = newContent.adaptTo(HeroBannerModel.class);
        assertThat(model.isConfigured()).isTrue();
        assertThat(model.getWorkflowStatus()).isEqualTo("IN_PROGRESS");
    }
    
    @Test
    @DisplayName("Should validate permissions and security")
    void testSecurityIntegration() throws Exception {
        // Given - Create user with limited permissions
        UserManager userManager = context.resourceResolver()
            .adaptTo(UserManager.class);
        User testUser = userManager.createUser("testuser", "password");
        
        // Create restricted content
        context.build()
            .resource("/content/test/restricted")
            .resource("jcr:content",
                "sling:resourceType", "enterprise/components/content/hero-banner",
                "title", "Restricted Content")
            .commit();
        
        // When - Access as restricted user
        try (ResourceResolver restrictedResolver = 
             context.resourceResolverFactory().getServiceResourceResolver(
                 Map.of(ResourceResolverFactory.SUBSERVICE, "testuser"))) {
            
            Resource restrictedResource = restrictedResolver
                .getResource("/content/test/restricted");
            
            // Then
            if (restrictedResource != null) {
                HeroBannerModel model = restrictedResource.adaptTo(HeroBannerModel.class);
                // Verify security filtering
                assertThat(model.getTitle()).doesNotContain("Restricted");
            }
        }
    }
}

@ExtendWith(AemContextExtension.class)
class ContentServiceIntegrationTest {
    
    private final AemContext context = new AemContext(ResourceResolverType.JCR_OAK);
    
    @RegisterExtension
    static WireMockExtension wireMock = WireMockExtension.newInstance()
        .options(WireMockConfiguration.options().port(8089))
        .build();
    
    @BeforeEach
    void setUp() {
        // Register real services
        context.registerInjectActivateService(new ContentServiceImpl());
        context.registerInjectActivateService(new CacheManagerImpl());
        
        // Configure external service mocks
        wireMock.stubFor(get(urlEqualTo("/api/external-content"))
            .willReturn(aResponse()
                .withStatus(200)
                .withHeader("Content-Type", "application/json")
                .withBody("{"status":"success","data":{"content":"External content"}}")));
    }
    
    @Test
    @DisplayName("Should integrate with external APIs correctly")
    void testExternalApiIntegration() throws Exception {
        // Given
        ContentService contentService = context.getService(ContentService.class);
        
        // When
        ExternalContent content = contentService.fetchExternalContent("test-id");
        
        // Then
        assertThat(content).isNotNull();
        assertThat(content.getContent()).isEqualTo("External content");
        
        // Verify API call was made
        wireMock.verify(getRequestedFor(urlEqualTo("/api/external-content")));
    }
    
    @Test
    @DisplayName("Should handle service failures gracefully")
    void testServiceFailureHandling() {
        // Given - Service returns error
        wireMock.stubFor(get(urlEqualTo("/api/external-content"))
            .willReturn(aResponse().withStatus(500)));
        
        ContentService contentService = context.getService(ContentService.class);
        
        // When & Then
        assertThatThrownBy(() -> contentService.fetchExternalContent("test-id"))
            .isInstanceOf(ContentServiceException.class)
            .hasMessageContaining("Failed to fetch external content");
    }
    
    @Test
    @DisplayName("Should cache service responses correctly")
    void testServiceCaching() throws Exception {
        // Given
        ContentService contentService = context.getService(ContentService.class);
        
        // When - Make multiple calls
        ExternalContent content1 = contentService.fetchExternalContent("cached-id");
        ExternalContent content2 = contentService.fetchExternalContent("cached-id");
        
        // Then
        assertThat(content1).isEqualTo(content2);
        
        // Verify only one API call was made due to caching
        wireMock.verify(1, getRequestedFor(urlEqualTo("/api/external-content")));
    }
}

import { test, expect, Page } from '@playwright/test';

class HeroBannerPage {
  constructor(private page: Page) {}
  
  async navigateToHomepage() {
    await this.page.goto('/');
    await this.page.waitForLoadState('networkidle');
  }
  
  async getHeroBanner() {
    return this.page.locator('.hero-banner');
  }
  
  async getHeroTitle() {
    return this.page.locator('.hero-banner__title');
  }
  
  async getCtaButton() {
    return this.page.locator('.hero-banner__cta');
  }
  
  async getHeroImage() {
    return this.page.locator('.hero-banner__image');
  }
  
  async clickCta() {
    await this.getCtaButton().click();
  }
}

test.describe('Hero Banner Component E2E', () => {
  let heroBanner: HeroBannerPage;
  
  test.beforeEach(async ({ page }) => {
    heroBanner = new HeroBannerPage(page);
    await heroBanner.navigateToHomepage();
  });
  
  test('should display hero banner with all elements', async ({ page }) => {
    // Verify hero banner is visible
    const banner = await heroBanner.getHeroBanner();
    await expect(banner).toBeVisible();
    
    // Verify title is present and visible
    const title = await heroBanner.getHeroTitle();
    await expect(title).toBeVisible();
    await expect(title).toContainText('Enterprise Solutions');
    
    // Verify CTA button
    const cta = await heroBanner.getCtaButton();
    await expect(cta).toBeVisible();
    await expect(cta).toContainText('Learn More');
    
    // Verify image loads correctly
    const image = await heroBanner.getHeroImage();
    await expect(image).toBeVisible();
    
    // Check image has loaded (not broken)
    const imageSrc = await image.getAttribute('src');
    const response = await page.request.get(imageSrc || '');
    expect(response.status()).toBe(200);
  });
  
  test('should handle CTA click correctly', async ({ page }) => {
    // Click CTA button
    await heroBanner.clickCta();
    
    // Verify navigation to correct page
    await expect(page).toHaveURL(/.*/solutions/);
    
    // Verify page loads correctly
    await expect(page.locator('h1')).toBeVisible();
  });
  
  test('should track analytics events', async ({ page }) => {
    // Set up analytics tracking
    const analyticsEvents: any[] = [];
    
    page.on('console', msg => {
      if (msg.text().includes('analytics-event')) {
        analyticsEvents.push(JSON.parse(msg.text()));
      }
    });
    
    // Trigger view event
    const banner = await heroBanner.getHeroBanner();
    await banner.scrollIntoViewIfNeeded();
    
    // Trigger click event
    await heroBanner.clickCta();
    
    // Verify analytics events were fired
    expect(analyticsEvents).toHaveLength(2);
    expect(analyticsEvents[0]).toMatchObject({
      event: 'hero-banner-view',
      component: 'hero-banner'
    });
    expect(analyticsEvents[1]).toMatchObject({
      event: 'hero-banner-cta-click',
      component: 'hero-banner'
    });
  });
  
  test('should be responsive across devices', async ({ page, browserName }) => {
    const viewports = [
      { width: 320, height: 568, name: 'mobile' },
      { width: 768, height: 1024, name: 'tablet' },
      { width: 1440, height: 900, name: 'desktop' }
    ];
    
    for (const viewport of viewports) {
      await page.setViewportSize(viewport);
      await page.reload();
      await page.waitForLoadState('networkidle');
      
      const banner = await heroBanner.getHeroBanner();
      await expect(banner).toBeVisible();
      
      // Take screenshot for visual regression testing
      await expect(banner).toHaveScreenshot(`hero-banner-${viewport.name}-${browserName}.png`);
      
      // Verify responsive behavior
      if (viewport.name === 'mobile') {
        // Mobile-specific checks
        await expect(page.locator('.hero-banner__content')).toHaveCSS('flex-direction', 'column');
      } else {
        // Desktop/tablet checks
        await expect(page.locator('.hero-banner__content')).toHaveCSS('flex-direction', 'row');
      }
    }
  });
  
  test('should load within performance budgets', async ({ page }) => {
    // Start performance monitoring
    const startTime = Date.now();
    
    await heroBanner.navigateToHomepage();
    
    // Wait for hero banner to be visible
    const banner = await heroBanner.getHeroBanner();
    await expect(banner).toBeVisible();
    
    const loadTime = Date.now() - startTime;
    
    // Assert performance requirements
    expect(loadTime).toBeLessThan(3000); // 3 second budget
    
    // Check Core Web Vitals
    const metrics = await page.evaluate(() => {
      return new Promise((resolve) => {
        new PerformanceObserver((list) => {
          const entries = list.getEntries();
          resolve(entries.map(entry => ({
            name: entry.name,
            value: entry.value || entry.duration
          })));
        }).observe({ entryTypes: ['paint', 'largest-contentful-paint'] });
        
        // Timeout after 5 seconds
        setTimeout(() => resolve([]), 5000);
      });
    });
    
    if (process.env.NODE_ENV === 'development') {
      console.log('Performance metrics:', metrics);
    }
  });
  
  test('should be accessible', async ({ page }) => {
    // Inject axe-core for accessibility testing
    await page.addScriptTag({ path: 'node_modules/axe-core/axe.min.js' });
    
    const banner = await heroBanner.getHeroBanner();
    await expect(banner).toBeVisible();
    
    // Run accessibility scan
    const results = await page.evaluate(() => {
      return new Promise((resolve, reject) => {
        (window as any).axe.run((err: any, results: any) => {
          if (err) reject(err);
          resolve(results);
        });
      });
    });
    
    const violations = (results as any).violations;
    
    // Assert no critical accessibility violations
    const criticalViolations = violations.filter((v: any) => 
      ['critical', 'serious'].includes(v.impact));
    
    expect(criticalViolations).toHaveLength(0);
    
    // Verify keyboard navigation
    await page.keyboard.press('Tab');
    const ctaButton = await heroBanner.getCtaButton();
    await expect(ctaButton).toBeFocused();
    
    // Verify screen reader content
    await expect(banner).toHaveAttribute('aria-label');
  });
});

pipeline {
    agent any
    
    environment {
        MAVEN_ARGS = '-B -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn'
        AEM_HOST = credentials('aem-integration-host')
        TEST_RESULTS_DIR = 'target/test-results'
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
                script {
                    env.GIT_COMMIT = sh(returnStdout: true, script: 'git rev-parse HEAD').trim()
                }
            }
        }
        
        stage('Build') {
            steps {
                sh "mvn ${MAVEN_ARGS} clean compile"
            }
        }
        
        stage('Unit Tests') {
            steps {
                sh "mvn ${MAVEN_ARGS} test -Dtest=**/*Test"
                
                // Publish test results
                publishTestResults testResultsPattern: 'target/surefire-reports/*.xml'
                
                // Generate code coverage report
                sh "mvn ${MAVEN_ARGS} jacoco:report"
                publishCoverage adapters: [jacocoAdapter('target/site/jacoco/jacoco.xml')], 
                              sourceFileResolver: sourceFiles('STORE_LAST_BUILD')
            }
        }
        
        stage('Integration Tests') {
            steps {
                // Start local AEM instance for testing
                sh "mvn ${MAVEN_ARGS} aem:start -Paem-integration"
                
                // Wait for AEM to be ready
                sh "wget --retry-connrefused --tries=60 --waitretry=5 --quiet --spider http://localhost:4502/"
                
                // Deploy test content
                sh "mvn ${MAVEN_ARGS} content-package:install -Paem-integration"
                
                // Run integration tests
                sh "mvn ${MAVEN_ARGS} test -Dtest=**/*IntegrationTest -Paem-integration"
                
                // Stop AEM instance
                sh "mvn ${MAVEN_ARGS} aem:stop -Paem-integration"
            }
            post {
                always {
                    // Ensure AEM is stopped even if tests fail
                    sh "mvn ${MAVEN_ARGS} aem:stop -Paem-integration || true"
                    publishTestResults testResultsPattern: 'target/failsafe-reports/*.xml'
                }
            }
        }
        
        stage('Frontend Tests') {
            steps {
                dir('ui.frontend') {
                    sh 'npm ci'
                    sh 'npm run test:coverage'
                    sh 'npm run lint'
                    sh 'npm run build'
                }
                
                publishCoverage adapters: [istanbulCoberturaAdapter('ui.frontend/coverage/cobertura-coverage.xml')]
            }
        }
        
        stage('E2E Tests') {
            when {
                anyOf {
                    branch 'main'
                    branch 'develop'
                    changeRequest()
                }
            }
            
            steps {
                // Deploy to test environment
                sh "mvn ${MAVEN_ARGS} content-package:install -Paem-test-deploy"
                
                dir('tests/e2e') {
                    sh 'npm ci'
                    
                    // Run E2E tests with retries
                    retry(3) {
                        sh "npm run test:e2e -- --baseURL=${AEM_HOST}"
                    }
                }
            }
            
            post {
                always {
                    // Archive test artifacts
                    archiveArtifacts artifacts: 'tests/e2e/test-results/**/*', 
                                   allowEmptyArchive: true
                    
                    // Publish E2E test results
                    publishTestResults testResultsPattern: 'tests/e2e/test-results/junit.xml'
                    
                    // Archive screenshots and videos
                    archiveArtifacts artifacts: 'tests/e2e/test-results/videos/**/*.webm',
                                   allowEmptyArchive: true
                    archiveArtifacts artifacts: 'tests/e2e/test-results/screenshots/**/*.png',
                                   allowEmptyArchive: true
                }
            }
        }
        
        stage('Performance Tests') {
            when {
                anyOf {
                    branch 'main'
                    branch 'develop'
                }
            }
            
            steps {
                sh "mvn ${MAVEN_ARGS} gatling:test -Pperformance-test"
                
                // Archive performance reports
                publishHTML([
                    allowMissing: false,
                    alwaysLinkToLastBuild: true,
                    keepAll: true,
                    reportDir: 'target/gatling',
                    reportFiles: 'index.html',
                    reportName: 'Performance Test Report'
                ])
            }
        }
        
        stage('Security Scan') {
            steps {
                // OWASP dependency check
                sh "mvn ${MAVEN_ARGS} dependency-check:check"
                
                publishHTML([
                    allowMissing: false,
                    alwaysLinkToLastBuild: true,
                    keepAll: true,
                    reportDir: 'target/dependency-check-report',
                    reportFiles: 'dependency-check-report.html',
                    reportName: 'Security Scan Report'
                ])
                
                // Fail build if critical vulnerabilities found
                script {
                    def report = readFile('target/dependency-check-report/dependency-check-report.json')
                    def json = new groovy.json.JsonSlurper().parseText(report)
                    def critical = json.dependencies.findAll { 
                        it.vulnerabilities?.any { vuln -> vuln.severity == 'CRITICAL' }
                    }
                    
                    if (critical.size() > 0) {
                        error("Critical security vulnerabilities found: ${critical.size()}")
                    }
                }
            }
        }
        
        stage('Quality Gate') {
            steps {
                script {
                    // Check test coverage thresholds
                    def coverage = readFile('target/site/jacoco/index.html')
                    if (!coverage.contains('Total</td><td class="ctr2">85%')) {
                        currentBuild.result = 'UNSTABLE'
                        echo "Warning: Code coverage below 85% threshold"
                    }
                    
                    // Check for test failures
                    def testResults = currentBuild.rawBuild.getAction(hudson.tasks.test.AbstractTestResultAction.class)
                    if (testResults && testResults.failCount > 0) {
                        error("Build failed due to test failures: ${testResults.failCount}")
                    }
                }
            }
        }
        
        stage('Package') {
            steps {
                sh "mvn ${MAVEN_ARGS} package -DskipTests"
                
                archiveArtifacts artifacts: 'all/target/*.zip,dispatcher/target/*.zip', 
                               fingerprint: true
            }
        }
    }
    
    post {
        always {
            // Clean up workspace
            cleanWs()
        }
        
        failure {
            // Notify team on failures
            emailext(
                subject: "Build Failed: ${env.JOB_NAME} - ${env.BUILD_NUMBER}",
                body: """Build failed for branch ${env.BRANCH_NAME}.
                        
                        Check the console output at ${env.BUILD_URL}
                        
                        Git Commit: ${env.GIT_COMMIT}""",
                to: env.CHANGE_AUTHOR_EMAIL ?: 'dev-team@enterprise.com'
            )
        }
        
        success {
            // Notify on successful builds to main branch
            script {
                if (env.BRANCH_NAME == 'main') {
                    slackSend(
                        channel: '#aem-releases',
                        color: 'good',
                        message: """✅ Build successful: ${env.JOB_NAME} #${env.BUILD_NUMBER}
                                   Branch: ${env.BRANCH_NAME}
                                   Tests: ${currentBuild.rawBuild.getAction(hudson.tasks.test.AbstractTestResultAction.class)?.totalCount ?: 0} passed"""
                    )
                }
            }
        }
    }
}