9.2 Automated Testing: Pega Unit Test Cases & Scenario Testing

9.2 Automated Testing: Pega Unit Test Cases & Scenario Testing

CSA Exam Focus: Enterprise applications require continuous, automated quality verification to prevent regression defects as business requirements evolve. The Certified Pega System Architect exam tests candidates on the Pega Automated Testing Framework, specifically the architectural distinctions between Pega Unit testing (rule-level unit tests) and Scenario Testing (UI-level end-to-end workflow tests), the creation of setup/tear-down routines, assertion configuration, and code coverage measurement.

---

The Pega Automated Testing Pyramid

Pega implements an enterprise testing strategy modeled after the standard industry Testing Pyramid. A balanced automated testing portfolio optimizes defect detection efficiency, minimizes test maintenance overhead, and accelerates CI/CD release cycles.

                               /\ 
                              /  \ 
                             / E2E\       End-to-End & External Integration Testing
                            /System\      - Validates complete multi-system integration
                           /--------\     - Top of pyramid: Slower, highest maintenance
                          / Scenario \    Scenario Testing (App Studio)
                         /  Testing   \   - UI-driven end-to-end case journeys
                        /--------------\  - Middle tier: Multi-persona approval paths
                       /   Pega Unit    \ Pega Unit Testing (Dev Studio)
                      /   Test Cases     \- Rule-level logic validation (AUT)
                     /--------------------\- Broad base: Fastest, deterministic, lowest cost

1. Unit Testing (The Foundation)

• Volume: Represents the vast majority of all automated tests in the application.
• Focus: Validates individual, isolated business rules (such as a single Decision Table, Data Transform, or Declare Expression).
• Characteristics: Executes in milliseconds directly within the Pega engine clipboard memory without rendering UI components or relying on network browser drivers. Highly deterministic and resilient to interface redesigns.

2. Scenario Testing (The Middle Layer)

• Volume: A moderate collection of targeted business journeys.
• Focus: Validates end-to-end case workflows, step navigation, and user interface interactions from the perspective of real end-user personas.
• Characteristics: Authored codelessly in App Studio; executes through the browser DOM or headless browser drivers. Validates UI controls, action sets, stage transitions, and assignment routing.

3. Integration & System Testing (The Peak)

• Volume: A focused set of critical regression flows.
• Focus: Validates live integrations with external Systems of Record (live ERPs, mainframe connectors, external databases) and end-to-end enterprise network connectivity.
• Characteristics: Slower execution speed, higher maintenance overhead, and sensitive to external test environment downtime.

---

Pega Unit: Automated Rule Testing (Rule-Test-Case)

Pega Unit (historically referred to as Automated Unit Testing / AUT, represented internally by the rule type Rule-Test-Case) enables system architects to create, maintain, and execute automated unit tests for individual rules directly within Dev Studio.

Supported Rule Types for Pega Unit

Pega Unit test cases can be created for all core procedural, declarative, and decisioning rules:

• Decision Tables & Decision Trees: Validates complex branching logic, threshold boundaries, and default output values.
• Data Transforms: Validates property mapping, conditional logic (When), appending page lists, and data sanitization.
• Declare Expressions: Tests forward and backward chaining mathematical calculations and declarative networks.
• Case Types: Validates end-to-end case instantiation, default property initialization, and initial stage routing.
• Activities & Flow Rules: Tests programmatic utility routines and sub-process routing paths.

Anatomy of a Pega Unit Test Case

A complete Pega Unit test case consists of three distinct phases: Setup, Execution, and Assertions & Cleanup.

+-----------------------------------------------------------------------------------+
|                         PEGA UNIT TEST EXECUTION LIFECYCLE                        |
+-----------------------------------------------------------------------------------+
| 1. SETUP PHASE      : Execute Setup Data Transform to populate test clipboard     |
|                       pages (e.g., mock applicant credit score and income).       |
|                             |
|                             v
| 2. EXECUTION PHASE  : Pega engine runs the target rule using the setup data.      |
|                             |
|                             v
| 3. ASSERTION PHASE  : Evaluate configured assertions against target output:       |
|                       - Property Value Assertions (.Status == 'Approved')         |
|                       - Run Time Assertions (Elapsed Time < 200 ms)               |
|                       - Rule Status Assertions (Status == Good)                   |
|                             |
|                             v
| 4. CLEANUP PHASE    : Execute Tear-Down action; remove temporary test pages from   |
|                       clipboard to prevent test contamination.                    |
+-----------------------------------------------------------------------------------+

Configuring Assertions

Assertions define the expected outcome criteria that determine whether the unit test passes or fails. Pega Unit provides three primary assertion types:

A. Property Value Assertions

Compares the runtime value of a target property on the output clipboard page against an expected constant, calculation, or expression:

• Comparator Operators: Equal, Not Equal, Greater Than, Less Than, Contains.
• Example: In a loan underwriting decision table, assert that .UnderwritingResult equals "PreApproved" and .InterestRate equals 4.25.

B. Run Time (Execution Time) Assertions

Enforces non-functional performance service level agreements by asserting that the target rule completes execution within a maximum allowed duration:

• Measurement: Milliseconds (ms).
• Example: Assert that a high-volume pricing calculation Data Transform executes in less than 150 ms. If the rule takes 320 ms due to an unoptimized loop, the assertion fails, warning architects of performance regressions.

C. Rule Status Assertions

Verifies that the target rule finishes with a specific execution status or error condition:

• Expected Status: Good (normal completion) or Fail (expected exception).
• Message Verification: Asserts whether specific page-set error messages (e.g., .pxMessage) were attached to clipboard properties during input validation tests.

Test Suites and Automated Code Coverage

• Test Suites (Rule-Test-Suite): Architects group individual Pega Unit test cases into logical suites (e.g., AllUnderwritingTests or NightlyRegressionSuite). Test suites can be executed manually on demand or triggered automatically via REST APIs in CI/CD deployment pipelines.
• Code Coverage: Pega includes a built-in Rule Coverage tool. An architect starts a coverage session, executes unit test suites, and stops the session. The platform calculates the exact percentage of executable application rules exercised by the tests. Enterprise standards generally mandate 80%+ code coverage across all business rules before approving production release packages.

---

Scenario Testing: Codeless End-to-End UI Testing

While Pega Unit verifies individual rules in memory, Scenario Testing provides end-to-end automated functional testing through the user interface. Authored directly in App Studio, scenario tests simulate real user interactions within application portals.

Key Characteristics of Scenario Testing

• Codeless Creation: Authored entirely by recording clicks, form entries, and button submissions directly in the running application interface.
• Resilient UI Identifiers: Unlike brittle Selenium scripts that rely on volatile CSS selectors or dynamic XPath coordinates, Pega Scenario Testing anchors actions to stable, model-driven platform identifiers (data-test-id). If a UI section is restyled or moved into a different layout template, the test continues to run without failure.
• Two Target Scopes:
  1. Case Type Tests: Records user journeys through an entire case lifecycle, navigating across stages, processes, and views.
  2. Portal Tests: Records administrative user interactions with portal dashboard widgets, landing pages, and navigation menus.

Recording a Scenario Test Journey

1. From the App Studio header, open the Scenario Testing panel.
2. Select Create test case and choose Case type or Portal.
3. Click Record. App Studio launches the application in test recording mode.
4. Perform the user journey: fill in form fields, upload test documents, click Next, select dropdown values, and submit assignments.
5. Insert Assertions: Click the orange crosshair tool on any on-screen UI element to add an assertion (e.g., verify that a case status badge displays "Pending-Approval" or that a calculated loan total displays $25,000).
6. Click Stop & Save to persist the test case.

Multi-Persona Journey Testing

A major capability of Scenario Testing is testing multi-persona case handoffs within a single automated test run:

• Step 1: The test begins in the Customer Portal, simulating a customer submitting a new dispute case.
• Step 2: The scenario switches operator context to a Customer Service Representative (CSR) in the Worker Portal, opening the newly routed assignment from the team Work Queue and completing initial document verification.
• Step 3: The scenario switches operator context to a Branch Manager in the Manager Portal to approve the dispute.
• Step 4: The scenario verifies that the case transitions to the Resolved-Completed stage and displays the correct final confirmation view.

Storage & CI/CD Execution of Scenario Tests

• Dedicated Test Ruleset: Scenario tests must always be saved into a dedicated Test Ruleset (e.g., LoanAppTest). Keeping test assets isolated in a test ruleset ensures that automated test scripts and test data are never inadvertently packaged into production deployment archives.
• Headless Execution: Scenario tests can be executed in headless browser mode during automated CI/CD pipeline runs orchestrated by Pega Deployment Manager.

---

Comparison Matrix: Pega Unit vs. Scenario Testing