Author End-to-End Tests in Natural Language with KaneAI
Plan, Author, and Evolve E2E Tests for Web and Mobile Apps in Natural Language.
- TestMu AI (Formerly LambdaTest)
- /
- Blog
- /
- What Is SAP Testing? Types, Process & S/4HANA Guide
What Is SAP Testing? Types, Process & S/4HANA Guide
SAP testing guide: the seven ERP testing types, tools for ABAP and Fiori, what SAP ECC end of life in 2027 means for testing, and how KaneAI tests S/4HANA.
Last Updated on:
On This Page
- What Is SAP Testing?
- SAP ERP Offerings
- SAP Testing Process
- SAP Testing Tools
- SAP ERP Testing Types
- Testing SAP Modules
- SAP Automation Testing
- Regression Best Practices
- SAP Test Management
- AI Agents & KaneAI
- SAP Test Scenarios
- 90-Day S/4HANA Test Plan
- SAPUI5 Framework
- Testing SAPUI5 Apps
- SAPUI5 Testing Types
- Conclusion
SAP runs the finance, procurement, and supply chain operations of a large share of the world's biggest companies, which makes an untested change in one module an operational risk across every module it feeds. SAP testing is the discipline that contains that risk, and it splits cleanly into two jobs that need different tools: validating the ABAP-based ERP backend, and validating the SAP Fiori and SAPUI5 web interface that now sits on top of nearly every S/4HANA deployment.
This guide covers both sides: the seven ERP testing types, the SAP testing process, the tools that map to each layer, what to test inside SAP modules such as MM and SD, and how to test Fiori and SAPUI5 applications with QUnit, OPA5, and wdi5.
TL;DR
SAP testing is the practice of validating the ABAP-based ERP backend and the SAP Fiori web layer across unit, integration, functional, performance, security, regression, and user acceptance testing. It exists because one untested change in an SAP module posts into every module it feeds, such as a Sales and Distribution pricing error landing in Financial Accounting.
Which SAP Layers Need Testing?
- ABAP-based ERP backend: requires SAP-native tooling to validate core business logic, custom code, and database transactions.
- SAP Fiori and SAPUI5 web layer: requires web test frameworks to validate the browser-based user experience that S/4HANA runs on.
Can One Tool Cover Every SAP Layer?
- Does KaneAI drive the classic SAP GUI desktop client? No. KaneAI tests the Fiori, SAPUI5, and S/4HANA web layer, while SAP GUI transactions and ABAP logic stay with SAP-native tools such as eCATT.
- Can OPA5 run end-to-end tests across several pages? No. OPA5 integration tests stay inside one SAPUI5 app, so multi-page Fiori flows move to wdi5 or Selenium system tests.
- Can business users run SAP user acceptance testing without coding skills? Yes. UAT validates real business scenarios through the SAP GUI or Fiori launchpad, while ABAP unit tests and automation scripts still need technical skills.
What Are the Types of SAP Testing?
- Unit testing: validates individual ABAP objects and WRICEF developments before integration to ensure custom code works correctly.
- Integration testing: checks data flow between SAP modules and external systems to prevent partial writes and sync errors.
- Functional testing: confirms business processes match documented requirements and functional designs rather than just the UI.
- Performance testing: measures system behavior under high transaction volumes, peak load, and background scheduled jobs.
- Security testing: validates user roles, permissions, and segregation of duties to ensure compliance and traceability.
- Regression testing: confirms existing business processes survive each change, support pack, or S/4HANA release upgrade.
- User acceptance testing: allows business users to validate real-world scenarios and provide sign-off before go-live.
Which SAP Testing Tools Should You Use?
- ABAP Workbench: provides tools for building, modifying, and unit-testing standard and custom ABAP application logic.
- ABAP Test Cockpit: provides static code quality checks and consolidated results for objects developed in SAP.
- eCATT: records and parameterizes SAP GUI transactions through a graphical interface and an ABAP script editor.
- SAP Test Automation by Tricentis: SAP's own offering for automated business process tests across SAP and third-party systems, integrated with SAP Cloud ALM.
- QUnit: executes JavaScript unit tests on controllers, formatters, and models within the SAPUI5 framework.
- OPA5: drives the rendered Fiori UI for integration testing inside the app's own browser runtime, with no separate browser driver.
- wdi5: runs system and end-to-end tests through WebdriverIO and is the end-to-end tool SAP's UI5 documentation recommends now that UIVeri5 is deprecated.
- TestMu AI test automation cloud: TestMu AI's test automation cloud executes Selenium and AI-authored Fiori suites on 3,000+ browser and operating system combinations.
Where Do SAP Testing Programs Usually Fail?
- Security testing and user acceptance testing are the most commonly under-resourced testing types, with defects usually surfacing only after go-live.
- Regression volume spikes after each of the two major S/4HANA Cloud releases a year because UI-bound scripts break faster than teams can patch them.
What Is SAP Testing and Why Does It Matter?
SAP testing is the practice of validating that SAP applications, configurations, and customizations work correctly across business functions. It matters because a single defect can disrupt every connected module and process.
SAP (also known as SAP AG and SAP SE) stands for Systems, Applications, and Products. It is a German-based multinational known for its ERP business application software. ERP stands for Enterprise Resource Planning, a consolidated platform that lets organizations integrate business processes that are diversified in nature.
With an SAP ERP solution, an organization manages human resources, customer and supplier relationships, supply chain, enterprise performance, materials procurement and tracking, and financial accounts through one system. That consolidation is what makes testing consequential: a wrong pricing condition in Sales and Distribution does not stay in Sales and Distribution, it posts into Financial Accounting.
The market this software sits in keeps expanding. According to Fortune Business Insights, the global ERP software market was valued at USD 92.6 billion in 2025, is projected at USD 106.22 billion in 2026, and is forecast to reach USD 281.58 billion by 2034 at a 13% CAGR. North America alone generated USD 31.72 billion of that in 2025, 34.20% of the global market.

Scale also shows up at the small-business end. SAP's SAP Business One page says over 85,000 customers worldwide rely on the product, across wholesale distribution, light manufacturing, retail, and professional services.
A December 2025 SAP News post on Business One's global success counted 1.2 million users across more than 170 countries, supported by 850 partners and over 500 industry and country-specific extensions.
SAP offers a large number of products, along with IDEs, design systems, and the SAP Fiori design language plus the SAPUI5 UI framework. SAP Fiori is now the standard UX layer for S/4HANA, which is exactly why both the ERP backend and the SAPUI5 web layer need their own testing approach.
What Does SAP ERP Offer Across Business Sizes?
SAP ERP has an offering for every business size: S/4HANA for large enterprises, Business ByDesign for mid-sized firms, and Business One for small organizations.
SAP ERP lets an organization run human resources, customer relationship management, financial accounting, inventory, manufacturing, and management control end-to-end through a single system.
SAP S/4HANA is the latest ERP offering for large-scale enterprises, installable in on-premises data centers or in the cloud. SAP Business ByDesign serves medium-scale organizations, and SAP Business One serves small ones. Which tier a team runs changes the testing scope directly: an S/4HANA landscape means Fiori, so the web layer is in scope, while a classic ECC landscape keeps testing centered on SAP GUI and ABAP.
For teams still on ECC, the SAP ECC end of life date sets the deadline for moving that testing to S/4HANA and its Fiori layer.
What Is the SAP Testing Process?
The SAP testing process takes an SAP ERP or S/4HANA change from business requirements through test design, module and integration testing, customization checks, performance and security testing, and user acceptance testing, before deployment and again after any change.
Each step runs in the QA system, against configuration and transports that have not moved to production yet, so a failed test stops the transport instead of reaching users.

- Understand business requirements - review business processes, SAP configurations, functional designs, and customizations to identify what needs testing.
- Create test scenarios and cases - write detailed cases covering SAP modules, business workflows, integrations, user roles, and expected outcomes.
- Test SAP modules and processes - validate core modules such as Finance, Sales, and Procurement against expected behavior.
- Perform integration testing - verify SAP modules and external systems exchange data correctly and end-to-end processes complete.
- Validate customizations - test custom developments, configurations, reports, workflows, and enhancements without breaking existing functionality.
- Execute performance testing - evaluate system behavior under different workloads, high transaction volumes, and peak usage.
- Conduct security testing - verify user roles, permissions, authorization objects, and data access controls.
- Perform user acceptance testing - let business users validate real-world scenarios and confirm production readiness.
One point worth being explicit about: SAP ERP testing largely means testing the customizations layered on top of standard SAP. The out-of-the-box modules ship tested by SAP. The configuration, WRICEF objects, and enhancements your organization added are what needs a test case, and they are where defects concentrate. The difference between ERP configuration and customization also sets the regression bill: configuration changes generally survive upgrades, while custom code has to be retested after every one.
What Are the SAP Testing Tools?
SAP testing tools split by layer. ABAP Workbench, ABAP Test Cockpit, the ABAP Test Double Framework, eCATT, SAP Cloud ALM test automation, and SAP GRC cover the backend and SAP GUI, while QUnit, OPA5, wdi5, Selenium, KaneAI, and Kane CLI cover Fiori and SAPUI5. Pick by the layer the change is in, because a tool that records SAP GUI transactions cannot assert on a Fiori DOM. For a tool-by-tool comparison with pros, cons, and best-fit teams, see this roundup of SAP testing tools.
SAP testing tools compared by the layer each tool covers and what it tests:
| Tool | SAP layer | What it tests |
|---|---|---|
| ABAP Workbench | ABAP backend | Builds, changes and unit-tests standard and custom ABAP logic |
| ABAP Test Cockpit | ABAP backend | Runs static code quality checks and shows consolidated results |
| eCATT | SAP GUI | Records and parameterizes SAP GUI transactions |
| SAP Test Automation by Tricentis | SAP and third-party systems | Automates business process tests, integrated with SAP Cloud ALM |
| QUnit | SAPUI5 | Runs JavaScript unit tests on controllers, formatters and models |
| OPA5 | SAP Fiori and SAPUI5 | Runs integration tests inside one app's browser runtime |
| wdi5 | SAP Fiori and SAPUI5 | Runs system and end-to-end tests across pages through WebdriverIO |
| KaneAI | SAP Fiori, SAPUI5 and S/4HANA web layer | Runs plain-English end-to-end tests of Fiori flows; SAP GUI stays with SAP-native tools |
What Are the Types of Testing Involved in SAP ERP?
SAP ERP testing includes unit, integration, functional, performance, security, regression, and user acceptance testing. Each covers a different risk area, and skipping one leaves a specific gap rather than a general one.
Unit Testing
Unit testing validates individual SAP components, especially ABAP code, before integration. In SAP it is triggered whenever a change lands in Workflow, Report, Interface, Conversion, Enhancement, or Forms, collectively known as WRICEF.
- ABAP code validation - tests the correctness of custom developments, reports, workflows, interfaces, conversions, enhancements, and forms.
- Dependency isolation - substitute external objects with mock objects so the test measures the object under test, not its neighbors.
Integration Testing (SIT)
Integration testing, called system integration testing (SIT) on most SAP projects, verifies communication between SAP modules and external systems. A worked example: if an organization runs a CRM for customer relationships and SAP for everything else, provisioning a new customer in the CRM must sync into the SAP financial and sales performance modules with matching identifiers and no partial writes.
- Cross-module validation - tests interactions between SAP modules such as Finance, Sales, and Procurement.
- External system integration - validates data synchronization between SAP and connected platforms.
Because the CRM side of that flow is usually Salesforce, it is worth treating it as its own testing discipline. Start with this complete guide to Salesforce testing, then compare the best Salesforce test automation tools for platforms with native CRM data-sync support and API-level assertions.
For implementation, this guide to Salesforce test automation covers why SAP-to-CRM sync automation fails and how to design a framework that survives seasonal releases. Driving that side with Selenium specifically is covered in Salesforce Selenium testing, while Salesforce case management and Salesforce CPQ testing cover the Service Cloud and quote-to-billing flows that SAP ERP feeds.
Functional Testing
Functional testing confirms SAP business processes meet documented requirements. SAP is highly configurable, so QA engineers work from the functional design document rather than the UI, since two organizations running the same module can have legitimately different correct behavior.
- Business process validation - tests configurations and workflows across SAP modules.
- Scenario-based testing - builds test scenarios from business requirements and functional designs.
Performance Testing
Performance testing evaluates SAP ERP behavior under load. Load in an SAP context comes from three directions: concurrent user count, high-volume business transactions such as month-end postings, and background scheduled jobs competing for the same resources.
- Load validation - checks system behavior with increased users, large transaction volumes, and scheduled background jobs.
- Stress testing - measures how the system degrades under extreme conditions and workload pressure.
Security Testing
Security testing validates SAP authorization, access controls, and data protection. This is the type most often deprioritized, because a segregation-of-duties gap does not block a go-live the way a broken workflow does. It surfaces later, in an audit.
- Role and permission testing - ensures users reach only the transactions and data their role requires.
- Segregation of duties - confirms no single user can perform conflicting business activities, such as creating a vendor and approving its payment.
- Audit validation - checks that significant changes remain traceable through logs.
Regression Testing
Regression testing confirms that new SAP releases, configurations, or changes leave existing functionality intact. It runs at two moments: before a release once code and configuration are frozen, and in production whenever a change request ships.
- Release validation - ensures existing business processes still work after updates.
- Change impact testing - verifies new changes do not break existing modules or integrations.
User Acceptance Testing (UAT)
User acceptance testing is the final validation before SAP changes go live, performed by business users rather than QA. It catches the class of defect where the system does exactly what the specification said and the specification was wrong.
- Business scenario validation - confirms SAP functionality matches real business expectations.
- Production-like testing - uses a UAT environment with realistic configurations and data.
- Release approval - business users provide documented sign-off before deployment.
Note: Run SAP Fiori and SAPUI5 test suites across 3,000+ browser and operating system combinations with TestMu AI. Try TestMu AI now!
How Do You Test Individual SAP Modules?
SAP module testing validates the business process each module owns, then validates the postings it creates in neighboring modules. Module boundaries are where integration defects concentrate.
Testing "SAP" in the abstract produces vague coverage. Testing a module means following one business process end to end and asserting on the documents it generates at each step. Three modules carry most of the transactional load in a typical implementation.
SAP MM (Materials Management)
MM owns procure-to-pay. A complete test follows a purchase requisition into a purchase order, records a goods receipt against it, and posts an invoice, then asserts the three-way match between order, receipt, and invoice holds. Common defect areas are release strategies that approve the wrong value bands, and material master data that lets a receipt post against a closed order.
SAP SD (Sales and Distribution)
SD owns order-to-cash. The test path runs sales order, delivery, goods issue, and billing document, checking that pricing conditions resolve correctly for each customer and that availability checks reserve the right stock. Pricing condition records are the highest-risk area, because a misconfigured condition produces a plausible-looking but wrong invoice rather than an error.
SAP FI (Financial Accounting)
FI receives the financial consequences of everything the other modules do. Testing it means verifying that MM goods receipts and SD billing documents post to the correct general ledger accounts, that tax determination applies the right codes, and that period-end close runs without unbalanced documents. Most FI defects originate as configuration errors in MM or SD, which is why module tests should always assert on the downstream posting rather than stopping at the originating document.
How to Perform SAP Automation Testing?
SAP automation testing uses tools and scripts to validate SAP business processes, configurations, and UI workflows automatically instead of executing every test by hand.
Because S/4HANA landscapes change with every release upgrade and support pack, automation is what keeps regression coverage alive without expanding manual effort at the same rate. A reliable process follows these steps.
- Define scope and identify what to automate - start with business-critical, stable, frequently executed flows such as order-to-cash, procure-to-pay, and financial postings. A workable rule: if a test runs more than a few times across its lifetime, automate it.
- Select the right automation tool - SAP-native options such as eCATT and SAP Test Automation by Tricentis cover backend and GUI flows, while web-native frameworks handle the Fiori and SAPUI5 layer of S/4HANA.
- Design detailed test cases - document preconditions, steps, expected results, and required test data, mapped back to the business processes and modules under test.
- Prepare and manage test data - SAP data is highly dynamic, so parameterized, data-driven tests survive far longer than hardcoded values.
- Execute across backend and web layers - run scripts against both the ABAP layer and the browser-based Fiori UI, validating processes that span multiple SAP and non-SAP systems.
- Manage defects and run regression - log failures, retest fixes, and re-run regression suites after every change or SAP update.
- Report and integrate into CI/CD - track coverage, pass rates, and open defects, then wire the suites into the release pipeline to keep pace with SAP's release cadence.
On the backend, SAP Test Automation by Tricentis handles automated end-to-end testing of business processes while eCATT records and parameterizes test objects for automation testing. For the S/4HANA web layer, Selenium automation testing works well against the Fiori HTML5 UI, and TestMu AI's Selenium Grid cloud runs those suites without local infrastructure.
On TestMu AI, teams can also run cross-browser testing for SAP S/4HANA and Fiori applications across 3,000+ browser and operating system combinations, which matters more for SAP than for most enterprise software because Fiori is consumed on desktops, tablets, and shop-floor devices in the same deployment.
Check out this quick video on how to perform automation testing on desktop browsers using the TestMu AI platform.
You can also subscribe to the TestMu AI YouTube Channel for tutorials on automated browser testing, Selenium testing, and CI/CD.
SAP Regression Testing Best Practices
Regression is where most SAP testing budget goes, because SAP's release cadence guarantees repeat work. These practices reduce the volume rather than just absorbing it.
- Build the suite around business processes, not transactions. A regression pack organized as order-to-cash and procure-to-pay flows stays meaningful after a transaction code is deprecated; one organized as a list of transaction codes does not.
- Risk-rank before every cycle. Full regression on every support pack is rarely affordable. Rank by change impact, so modules touched by the transport and their downstream postings get full coverage while untouched areas get a smoke pass.
- Parameterize test data and reset it between runs. SAP tests that consume documents leave state behind, and a suite that passes only on a freshly refreshed client is not a regression suite.
- Separate the backend and web packs. ABAP and Fiori tests break for different reasons and on different schedules, so mixing them into one pack makes failures harder to triage.
- Treat locator strategy as a maintenance decision. Fiori generates deeply nested, generated IDs, so tests bound to those IDs break on every UI change. Prefer stable attributes, or use AI testing tools that resolve elements semantically.
- Run the web pack in parallel. Sequential execution is the reason regression cycles stretch into days once the suite passes a few hundred Fiori cases.
For the last point, parallel testing across a cloud grid is the practical lever. Running the Fiori regression pack on an online browser farm collapses a sequential multi-hour cycle into a fraction of the wall-clock time without provisioning local machines.
To start from a working pack, download the SAP regression test cases as a CSV. No sign-up is needed. It groups the cases by business process, labels each one Smoke, Core or Full so you can risk-rank a cycle, and splits them into backend and web packs. Replace the test data placeholders with values from your client, and check the transaction codes against your release.
SAP Test Management and Traceability
SAP programs generate a traceability problem that smaller applications do not. A single S/4HANA release can touch a dozen modules, and auditors ask which business requirement each test covered and who signed it off. That is a test management question, not an automation question.
A workable SAP test management setup needs four things: test cases organized by business process and module, execution cycles tied to a specific transport or release, defect links back to the failing case, and requirement-to-test traceability that survives an audit. Spreadsheets handle the first two and fail at the last two once the program passes a few hundred cases.
TestMu AI's test management platform keeps cases, cycles, and requirement-to-defect traceability in one workspace, so manual UAT results recorded by business users and automated Fiori runs land in the same report rather than in two systems that have to be reconciled by hand. Its AI agents also draft and tag test cases and flag duplicates as the SAP suite grows. Defining the overall approach first helps: this guide to building a test strategy covers scope, entry and exit criteria, and environment planning.
How Do AI Agents Like KaneAI Automate SAP Web Testing?
AI test automation agents like KaneAI automate SAP web testing by generating, running, and auto-healing Fiori and SAPUI5 tests from plain-English instructions.
Every testing type above still depends on someone authoring and maintaining the underlying test logic, whether that is ABAP code, QUnit scripts, or Selenium locators. That authoring work is exactly what breaks when SAP ships a release upgrade.
AI agents change that for one specific layer of SAP test automation, the web UI. KaneAI by TestMu AI is a GenAI-native testing agent that lets teams describe SAP web workflows in plain English and have the tests generated, executed, and maintained. Here is how AI agents apply to SAP:
- Plain-English test authoring - instead of writing OPA5 page objects or Selenium locators by hand, a tester describes a Fiori workflow such as creating a sales order or approving a purchase requisition, and the agent generates the test.
- Requirements as input - KaneAI turns PRDs, Jira tickets, PDFs, and recordings directly into scenarios, which suits SAP programs where functional design documents already define the expected behavior.
- Execution across real browsers and devices - generated tests run in parallel on HyperExecute across 3,000+ browser and operating system combinations and 50,000+ real devices.
- Smart element detection and auto-healing - when a release upgrade changes the UI, KaneAI updates the affected steps and surfaces the change for review instead of failing on a brittle selector, which significantly reduces the maintenance spike after each release.
- Multi-framework export - tests export to Selenium, Playwright, Cypress, or Appium, so an SAP team that already owns a Selenium suite keeps its existing code ecosystem.
- Human-in-the-loop review - plans are approved before execution and runs can be paused mid-flight, so the sign-off checkpoint SAP programs already require moves earlier rather than disappearing.
TestMu AI's own deployment data gives a sense of scale on SAP specifically: in one education technology customer engagement, a team automated 400 SAP test cases during a 3.5-month pilot, reporting a 60% reduction in manual testing time and a 50% increase in test coverage. To set up a first SAP web test, see the KaneAI documentation.
Scope matters here. KaneAI automates SAP's modern web and browser layer, including SAP Fiori, SAPUI5 applications, and the S/4HANA Cloud browser UI, the same layer covered by QUnit, OPA5, and wdi5. It does not drive the classic SAP GUI desktop client or ABAP-level backend logic, where ABAP Test Cockpit, eCATT, and standard unit and integration approaches still apply.
Mobile SAP Testing on Real Devices
SAP planned to remove the Fiori Client app from the public app stores in March 2022 and kept it in maintenance only until December 31, 2022, according to its Fiori Client strategy update. Most mobile SAP use now runs through Fiori in mobile browsers or through custom apps.
The same KaneAI tests run on TestMu AI's Real Device Cloud of 50,000+ physical iOS and Android devices. That covers warehouse scanning flows on Android, approval flows on iPhones, and field-service apps tested under constrained network profiles.
SAP Test Scenarios to Automate First
A single Fiori screen looks like a form, but real coverage has to survive the way SAP is built and upgraded:
- Generated control IDs - SAPUI5 and Fiori generate IDs such as
__field0-innerand__button-postthat shift between renders and releases, so a selector written today rarely survives the next transport. - Multi-screen processes - a sales order leads to a delivery, a goods issue, and a billing document, so the test has to carry data across separate transactions.
- Mixed UI technologies - classic SAP GUI, Fiori launchpad tiles, and Web Dynpro screens often coexist in one landscape, so a single flow can cross three very different UI technologies.
- Backend state - an order needs a customer, a material, and stock that exists in the client under test, so data setup is half the work.
- Approvals - a purchase requisition waits until a manager releases it before the process can move on.
- Upgrade scope - every upgrade, support package, and custom Z-transaction can relabel fields, add mandatory entries, or reorder screens across finance, procurement, and HR at the same time.
In KaneAI, a sales order check is written the way a functional consultant would explain it:
- Open the Fiori launchpad and click the Create Sales Order tile
- Enter the customer Customer-1001
- Add the material MATERIAL-500 with a quantity of 5
- Post the order
- Verify the confirmation shows a new sales order number
- Verify the order status reads created
KaneAI finds each tile and field by what it means on screen rather than by a generated ID like __field0-inner, so a support pack that renumbers controls does not break the step. Shared steps like logging into the launchpad or selecting a company code become reusable modules you fix once and reuse everywhere, and when a step needs a manager to release an approval, a reviewer can step in mid-run and then hand control back. Once that path works, add the scenarios that tend to break after an update.
Order-to-Cash Across Screens
- Create a sales order for an existing customer and material
- Create the outbound delivery and post the goods issue
- Create the billing document and verify the accounting document posts
Purchase Requisition With Approval
- Raise a purchase requisition against a cost center
- Verify it routes to the approver and waits for release
- Release it as the approver and verify a purchase order is created
Master Data Validation
- Create a new material master with a required field left blank
- Verify SAP blocks the save and shows the correct error message
- Complete the field and verify the record saves with a new number
Finance Posting and Reversal
- Post a journal entry to a general ledger account
- Verify the document number is returned and the account balance updates
- Reverse the document and verify the balance returns to its original value
Each scenario runs across Chrome, Edge, Firefox, and real mobile devices for Fiori from the same plain-English steps. To keep them running without anyone watching, schedule the suite nightly so a transport moved on Tuesday cannot break order-to-cash unnoticed, trigger it on each transport or deploy through Kane CLI, and send failures to Slack with the screenshots, video, and plain-English reason for the step that failed. The same approach works for other enterprise platforms, as shown in how to test Salesforce without code and how to test ServiceNow without code.
A 90-Day Test Plan for ECC Customers Moving to S/4HANA
Whatever your go-live date, the first 90 days of migration testing should produce a baseline of today's behavior, an automated web and cross-application layer, and one timed upgrade rehearsal.
- Days 1-30, inventory - list your top 50 business processes by revenue or compliance impact, and tag each by interface: SAP GUI, Fiori, mobile, or cross-application.
- Days 1-30, baseline - capture how those processes behave on ECC today, with evidence, so post-migration results have something to compare against.
- Days 31-60, automate the web layer - author the Fiori and cross-application processes in KaneAI, and wire Kane CLI into CI for custom Fiori and SAP BTP apps.
- Days 31-60, cover GUI and ABAP - automate the SAP GUI and ABAP side with SAP-native tooling such as eCATT, ABAP Test Cockpit, and SAP Cloud ALM test automation.
- Days 61-90, rehearse an upgrade - run the full suite against a sandbox upgrade on real browsers and devices with HyperExecute, which runs suites up to 70% faster than a traditional grid, and time the run against the three weeks between the test-system and production upgrades.
- Day 90, decide with evidence - base go-live and AI-agent rollout decisions on test evidence, not status reports.
What Is the SAPUI5 Framework?
SAPUI5 is an enterprise-ready UI development framework for building web applications based on HTML5 standards.
SAPUI5 is built on HTML5 and follows the Model View Controller (MVC) pattern. It historically relied on jQuery, and current releases are replacing the deprecated jQuery APIs. It ships with the features large organizations need:
- Internationalization and localization
- Data-driven UIs and routing
- A suite for performance analysis
- Testing tools covering both unit and end-to-end testing
The framework ships a large library of UI control elements, from switches and buttons to table views and analytical report charts, and renders them responsively across desktop, laptop, tablet, and smartphone. That breadth is what makes Fiori test suites brittle: a single control can render different DOM structures depending on device width, so a locator that works on desktop can miss on tablet.
According to the SAPUI5 documentation, SAPUI5 enables the SAP Fiori design evolution toward a consistent user experience across SAP solutions.
Because SAP Fiori apps are SAPUI5 applications, SAP Fiori testing and SAPUI5 testing are, in practice, the same discipline applied to the same code base.
SAPUI5 also produced OpenUI5, the open-source subset released under the Apache 2.0 license for building cross-platform responsive web applications. The core and the most commonly used control libraries are identical in both, while SAPUI5 adds libraries such as charts and smart controls.
How Do You Test Websites and Web Apps Built on SAPUI5?
SAPUI5 and Fiori web apps are tested with QUnit for unit tests, OPA5 for integration tests, and wdi5 for system and end-to-end tests, with Selenium also supported.
Since SAPUI5 and OpenUI5 share an identical core, the approaches below apply equally to applications built on either, including SAP Fiori apps. Developers and testers already fluent in Selenium or Karma can keep using them to write automation scripts against SAPUI5 applications.
An OpenUI5 reference application run on the TestMu AI cloud (build 97889449) shows a detail worth designing around. A Fiori-style catalog renders its category list and item cards from data bindings, so assertions written against the rendered counts break whenever the underlying data changes. Assert on the control and its binding, not on the displayed value.
What Are the Types of Testing Involved in SAPUI5-Based Sites?
SAP's UI5 testing guidance draws a testing pyramid with QUnit unit tests at the base, OPA5 component and integration tests above them, and system tests with wdi5 or Selenium near the top. Keep more unit tests than integration tests, and more integration tests than system tests, since lower-level tests are cheaper to write, faster to run, and easier to keep green.
Unit Testing
QUnit, a JavaScript testing framework, is the standard for unit testing SAPUI5 and Fiori applications. It provides a test runner, test suites, test cases, assertions, and run reports, which is everything needed to test controllers, formatters, and models in isolation.
Wiring the suite to execute whenever a source file changes keeps the feedback loop tight during Fiori development.
Integration Testing
OPA5, short for One Page Acceptance tests for UI5, is the integration testing tool that ships with SAPUI5. It is built on top of QUnit and runs inside the application's own browser runtime, so tests need no browser driver or plugin and can be debugged in the same session as the app.
Per the OPA5 documentation, OPA5 hides asynchronicity by polling for the expected state instead of waiting on fixed timeouts, which keeps tests fast and less flaky. Use it to check how screens, controls, and navigation work together inside one app, for example that saving a sales order in a Fiori list report opens the object page with the right status.
Restrictions With the OPA5 Library and How to Deal With Them
OPA5 is fast inside a single app, and the same documentation lists where it stops:
- Screen capturing - OPA5 cannot take screenshots, so cosmetic and visual regressions need a separate check.
- Testing across more than one page - OPA5 is not designed for flows that cross several pages.
- Remote test execution - OPA5 does not support running tests on a remote machine.
- End-to-end tests - SAP does not recommend OPA5 for end-to-end tests because of authentication issues and fragile test data, which is the job of system testing tools such as wdi5.
For the visual gap, TestMu AI's SmartUI visual AI testing compares each new screenshot of a SAPUI5 or Fiori application with an approved baseline. It flags layout shifts, color changes, missing or new elements, and size changes, while its Visual AI filters out rendering noise such as anti-aliasing and font-rendering drift between operating systems.

The platform can also be scheduled to run automated screenshot testing at set intervals and send results over email, removing the need to wait around for test completion.
Testing Across More Than One Page at a Time
Because OPA5 stays within one page, multi-page Fiori workflows move to browser-level suites in Selenium or wdi5, and those suites grow quickly once every browser and device combination is in scope. Run them in parallel across machines rather than one after another.
TestMu AI runs those Selenium suites in parallel on a cloud grid without local test infrastructure. As a cloud-based test automation platform, it reports each run's execution status and outcome in one dashboard.

System Testing
For system and end-to-end tests, SAP's UI5 documentation now recommends wdi5, a WebdriverIO service from the UI5 community. It drives a real browser and uses SAPUI5's own test API, so selectors target UI5 controls instead of the generated DOM IDs that break between releases.
UIVeri5, the Protractor-inspired framework SAP previously recommended, is deprecated and no longer developed. Existing UIVeri5 tests keep working for now, but new Fiori suites should start on wdi5 or Selenium.
Conclusion
Start by mapping your landscape to the two layers in this guide: which processes run in SAP GUI and ABAP, and which run in Fiori and SAPUI5. That split decides the tool set, because ABAP Test Cockpit, eCATT, and SAP Cloud ALM test automation cover one side, while QUnit, OPA5, wdi5, and KaneAI cover the other.
Then work back from December 31, 2027: baseline your top processes on ECC now and automate regression first, since it is the testing type that grows with every release. To see your own Fiori processes running in KaneAI, book a demo from the SAP test automation page.
Testing web or mobile apps without writing code? KaneAI by TestMu AI turns plain-English instructions into tests.
Author
Anmol Gupta is Vice President of Product Management at TestMu AI, driving HyperExecute, the test orchestration cloud that runs and accelerates automated test execution. He led the development of the Unified Test Execution Cloud Platform and now leads a 30-member cross-functional product organization across product lines contributing $7M+ in revenue. He brings over nine years of experience and previously co-founded the SaaS company Timble as CTO, where he grew the team from 5 to 40 and launched an AI KYC platform that processed 600K+ applications in five months while cutting verification time from 12 minutes to under 30 seconds. Anmol holds an MTech and BTech from IIT Delhi.
Reviewer
Mayank Bhola is Co-Founder and Head of Products at TestMu AI, where he leads the entire product portfolio across KaneAI, Kane CLI, HyperExecute, SmartUI, the Real Device Cloud, Accessibility, and other software testing product lines. As an early Lead Architect he designed and built the company's flagship Tunnel technology from scratch, created the React-based automation platform, and architected the data-intensive pipelines and FAAS services that scale it. He brings more than 10 years of experience in software development and product engineering, with earlier roles as Head of Technology at Juggernaut Books and Senior Software Engineer at PressPlay TV and Zomato. Mayank holds a B.Tech in Computer Engineering from JIIT Noida.
SAP Testing FAQs
Did you find this page helpful?
More Related Blogs
TestMu AI forEnterprise
Get access to solutions built on Enterprise
grade security, privacy, & compliance
- Advanced access controls
- Advanced data retention rules
- Advanced Local Testing
- Premium Support options
- Early access to beta features
- Private Slack Channel
- Unlimited Manual Accessibility DevTools Tests







