Cloud concept · Updated

Acceptance Testing - Acceptance testing verifies that a system satisfies agreed acceptance criteria and is suitable for its intended business use.

In short

Acceptance testing evaluates observable system behavior against requirements that stakeholders consider necessary for release or delivery. In CI/CD pipelines, automated acceptance tests provide a repeatable release gate, complementing lower-level technical tests and any required human acceptance decisions.

Cloud Concepts Hub →

6 key aspects of Acceptance Testing

Effective acceptance testing turns agreed requirements into repeatable, traceable checks that inform release decisions.

01
Requirements-based outcomes

Define observable pass/fail criteria with business stakeholders before implementing tests. Verify outcomes such as correct order totals or denied unauthorized actions rather than internal method calls.

02
Automated release gates

Run acceptance scenarios against the deployed release candidate and block promotion when required scenarios fail. Keep automated test results separate from any manual approval required for business acceptance.

03
Appropriate interaction surfaces

Use APIs, browser interactions, or event inputs according to the requirement being evaluated. A browser is necessary only when the acceptance criterion depends on user interface behavior.

04
Repeatable environments and data

Provision relevant infrastructure consistently and isolate test identities and records. Design scenarios to tolerate expected asynchronous processing without accepting incorrect results.

05
Complementary test coverage

Combine acceptance tests with unit tests, integration tests, security scans, and other checks. Test categories can overlap, but none automatically replaces the others.

06
Traceable release evidence

Associate results and diagnostics with the tested artifact and environment configuration. Preserve enough detail to explain why promotion succeeded or failed.

Cloud services for Acceptance Testing

AWS CodePipeline coordinates the release workflow, while AWS CloudFormation can provision a repeatable acceptance environment. A deployment action, potentially using AWS CodeDeploy, installs the release candidate, and AWS CodeBuild executes acceptance scenarios against its endpoints. Failed required tests stop promotion; successful tests allow subsequent stages or a separate manual approval. Deployment lifecycle hooks can add targeted validation where appropriate. Keep the tested artifact unchanged during promotion, retain results and diagnostics, and arrange cleanup after both successful and failed runs so temporary environments do not accumulate cost or interfere with later tests.

AWS CodePipelineAWS CodePipeline

Orchestrates deployment and acceptance-test actions so required tests must succeed before later release stages run. Manual approval actions can provide a separate stakeholder sign-off when automated checks alone are insufficient.

AWS CodeBuildAWS CodeBuild

Runs acceptance-test frameworks and scripts against a deployed application using a configured build environment. Configure test commands to return failure on failed assertions, and publish supported test reports and diagnostic artifacts.

AWS CloudFormationAWS CloudFormation

Provisions repeatable test infrastructure from templates, helping acceptance environments reproduce relevant production settings. Pipeline automation can create isolated stacks before testing and remove them afterward, with explicit handling for retained resources and test data.

AWS CodeDeployAWS CodeDeploy

Supports deployment lifecycle hooks that can invoke validation logic, with available hooks and execution mechanisms depending on the compute platform. Selected acceptance checks can participate in deployment validation, while broader suites can remain in a separate pipeline test action.

Acceptance Testing exam questions

Real practice exam questions on Acceptance Testing, with the correct answer and its explanation. Answer them with every option in the exam simulator.

DOP-C02

A company uses AWS CodePipeline to deploy a reimbursement service to an isolated staging environment. An AWS CodeBuild action can access the deployed service through its authenticated APIs. Unit tests and tests of database and messaging connectivity already pass, but recent releases have violated reimbursement policies because of interactions between policy configuration and asynchronous processing.

The product owner specifies that claims of $500 or less must become payable without manager approval, larger claims must remain pending until an authorized manager approves them, and resubmitting a request with the same idempotency key must not create another reimbursement. Valid state transitions must complete within 60 seconds. Staging contains the candidate release, representative policy configuration, and dedicated test identities and records.

Which additional automated release gate would best verify that the candidate satisfies these requirements?

Show answerCORRECT ANSWER

Use CodeBuild to submit claims through the staging APIs with dedicated identities. Verify the required payable and pending states, verify that unauthorized approval attempts cannot change a claim's state, and verify that duplicate submissions produce only one reimbursement. Poll for expected asynchronous outcomes within the 60-second deadline, and fail the action on any unmet expectation.

This implements an automated acceptance gate derived from the stakeholder's release criteria. It verifies observable business outcomes against the deployed candidate, including authorization, policy thresholds, and idempotency. Bounded polling accommodates asynchronous processing without allowing missed requirements to pass.

Practice Acceptance Testing in a full exam

Questions on Acceptance Testing in each practice exam, with every answer option and an explanation for each:

Start a free practice exam

What is Acceptance Testing

3 min read

Acceptance testing answers a business-focused question: does the delivered system behave as agreed for its intended users or consumers? Tests derive from explicit acceptance criteria rather than implementation details. For an online ordering application, a criterion might state that an authenticated customer can purchase an available item, receive an order identifier, and see the correct total. Another might require an unsuccessful payment to leave the order unconfirmed and inventory unchanged.

Acceptance criteria should be concrete enough to produce an unambiguous result. Teams often express scenarios using given, when, and then statements that describe initial conditions, an action, and the expected outcome. Product owners, engineers, and testers should agree on these outcomes before implementation. Behavior-driven development tools can execute such scenarios, but neither that methodology nor a particular framework is required for acceptance testing.

In a cloud delivery pipeline, a typical sequence builds an immutable application artifact, runs fast unit tests and other checks, deploys the artifact into a test environment, and executes acceptance scenarios. Successful results allow promotion of that same artifact toward production. Failed assertions must cause the test command and pipeline action to fail; publishing a report without enforcing its result does not create a release gate. Some organizations also require a separate manual approval for business sign-off.

The test environment should reproduce the production characteristics that matter to the scenarios, including authentication, permissions, network access, configuration, database behavior, and asynchronous messaging. Infrastructure as code helps create repeatable environments, while isolated accounts or namespaces reduce interference between runs. Use synthetic or appropriately sanitized records, dedicated test identities, secure secret retrieval, and reliable cleanup. For an asynchronous order workflow, poll for the expected business outcome within a defined timeout instead of relying on a fixed sleep.

Acceptance testing differs from other test categories primarily by purpose. Unit tests check small units of logic, while integration tests check interactions between components. Acceptance tests determine whether agreed requirements are satisfied. A single test can be both an integration test and an acceptance test when it exercises collaborating components to verify a business rule. User interface testing describes an interaction surface, not an acceptance objective: acceptance scenarios can run through APIs, browsers, command-line interfaces, or event inputs. Security scans detect particular classes of vulnerabilities and do not establish business acceptance, although security requirements can have their own acceptance scenarios.

Comprehensive cloud acceptance suites take time, consume resources, and can fail because of unstable dependencies or shared test data. Favor focused API-level scenarios where they adequately verify requirements, and reserve browser-driven scenarios for behavior that depends on the interface. External-service sandboxes or controlled substitutes improve repeatability, but substitutions can hide real integration problems. Select representative real integrations deliberately and retain enough diagnostics to distinguish application defects from environment failures.

Acceptance testing is not synonymous with manual user acceptance testing or with exhaustive end-to-end testing. It can be automated and can verify a specific requirement without traversing every component. Passing acceptance tests provides evidence only for the criteria and conditions covered; it does not prove the absence of defects, security weaknesses, or performance limits. Keep test results, logs, and artifact identifiers together so engineers can trace a release decision to the exact software and scenarios evaluated.

Learn Acceptance Testing in lessons

3 short lessons on Acceptance Testing in 1 certification course.

Open the lessons