Acceptance testing in Testing Fundamentals - Framework Patterns

Framework Mode - Acceptance testing

Folder Structure for Acceptance Testing Framework

acceptance-testing-project/
├── tests/
│   ├── acceptance/
│   │   ├── user_journey_tests.test.js
│   │   └── feature_acceptance.test.js
│   └── helpers/
│       └── test_helpers.js
├── pages/
│   ├── loginPage.js
│   ├── dashboardPage.js
│   └── checkoutPage.js
├── config/
│   ├── environments.json
│   └── acceptance.config.js
├── reports/
│   └── acceptance-report.html
├── utils/
│   └── waitUtils.js
└── package.json

Test Framework Layers for Acceptance Testing

• Test Scripts Layer: Contains acceptance test cases that simulate real user scenarios to verify the system meets business requirements.
• Page Objects Layer: Encapsulates UI elements and actions for pages involved in acceptance tests, promoting reuse and clarity.
• Utilities Layer: Helper functions like waits, data generators, or common assertions to support tests.
• Configuration Layer: Holds environment settings, test data, and parameters to run tests in different contexts.
• Reporting Layer: Generates readable test reports showing pass/fail results for stakeholders.

Configuration Patterns for Acceptance Testing

• Environment Files: Use JSON or JS files to define URLs, credentials, and settings for dev, staging, and production.
• Parameterization: Pass environment and browser options via command line or config files to run tests flexibly.
• Secrets Management: Store sensitive data like passwords securely outside code, e.g., environment variables.
• Test Data: Use external files or fixtures to separate test inputs from test logic for easier maintenance.

Test Reporting and CI/CD Integration

• HTML Reports: Generate clear, user-friendly reports showing which acceptance tests passed or failed.
• CI/CD Integration: Configure pipelines (e.g., GitHub Actions, Jenkins) to run acceptance tests automatically on code changes.
• Notifications: Send test results via email or chat tools to keep the team informed.
• Artifacts: Save screenshots or logs on failures to help diagnose issues quickly.

Best Practices for Acceptance Testing Frameworks

1. Write Tests from User Perspective: Acceptance tests should reflect real user goals and workflows, not internal code details.
2. Keep Tests Independent: Each acceptance test should run alone without relying on others to avoid false failures.
3. Use Page Object Model: Abstract UI interactions to make tests easier to read and maintain.
4. Automate Environment Setup: Ensure tests run in consistent environments to avoid flaky results.
5. Clear Reporting: Provide simple, understandable reports so non-technical stakeholders can see if requirements are met.

Self-Check Question

Where in this folder structure would you add a new acceptance test for the "Shopping Cart Checkout" feature?

Key Result

Acceptance testing frameworks focus on verifying user requirements through clear, user-focused test scripts organized with page objects and robust configuration.

Practice

1. What is the main purpose of acceptance testing in software development?

easy

A. To test individual functions or methods in isolation

B. To check the internal code quality and structure

C. To verify the software meets user requirements and expectations

D. To find syntax errors in the source code

Solution

1. Step 1: Understand acceptance testing goal

   Acceptance testing focuses on confirming the software meets what users expect and need.

2. Step 2: Compare options to acceptance testing purpose

   Options B, C, and D relate to other testing types like unit or code testing, not acceptance testing.

3. Final Answer:

   To verify the software meets user requirements and expectations -> Option C

4. Quick Check:

   Acceptance testing = user requirements check [OK]

Hint: Acceptance testing checks if users get what they want [OK]

Common Mistakes:

• Confusing acceptance testing with unit testing
• Thinking acceptance testing checks code syntax
• Believing acceptance testing is done after release

2. Which of the following is the correct way to describe an acceptance test scenario?

easy

A. Check if the software's internal functions return correct values

B. Run automated scripts to find syntax errors

C. Write complex code to test each module separately

D. Describe user actions and expected results in simple language

Solution

1. Step 1: Identify acceptance test scenario style

   Acceptance tests use simple, clear descriptions of what users do and expect.

2. Step 2: Eliminate unrelated options

   Options A, C, and D focus on code-level or automated testing, not user-focused scenarios.

3. Final Answer:

   Describe user actions and expected results in simple language -> Option D

4. Quick Check:

   Acceptance test scenario = user steps + expected results [OK]

Hint: Acceptance tests use simple user stories, not code details [OK]

Common Mistakes:

• Writing technical code instead of user steps
• Confusing acceptance tests with unit tests
• Using jargon instead of simple language

3. Consider this acceptance test scenario for a login feature:

Given the user is on the login page
When the user enters valid credentials
Then the user should see the dashboard

What is the expected outcome when this test runs?

medium

A. The user is redirected to the dashboard page

B. The application crashes

C. The login page reloads without changes

D. The user sees an error message about invalid credentials

Solution

1. Step 1: Analyze the acceptance test steps

   The scenario says valid credentials are entered, so login should succeed.

2. Step 2: Determine expected result from scenario

   After successful login, the user should see the dashboard, meaning redirection to dashboard page.

3. Final Answer:

   The user is redirected to the dashboard page -> Option A

4. Quick Check:

   Valid login = dashboard shown [OK]

Hint: Valid login leads to dashboard, not error or crash [OK]

Common Mistakes:

• Choosing error message for valid credentials
• Confusing page reload with successful login
• Assuming crash on valid input

4. A tester wrote this acceptance test scenario:

Given the user is on the homepage
When the user clicks the 'Submit' button
Then the form should be submitted

But during testing, clicking 'Submit' does nothing. What is the most likely cause?

medium

A. The form submission is successful but not visible

B. The 'Submit' button locator is incorrect or missing

C. The user is not on the homepage

D. The acceptance test scenario is invalid syntax

Solution

1. Step 1: Understand the test failure symptom

   Clicking 'Submit' does nothing, so the button action is not triggered.

2. Step 2: Identify common causes for no action on click

   Incorrect or missing locator means the test cannot find the button to click, causing no action.

3. Final Answer:

   The 'Submit' button locator is incorrect or missing -> Option B

4. Quick Check:

   Button not found = no click action [OK]

Hint: No action on click? Check button locator first [OK]

Common Mistakes:

• Assuming form submitted but invisible
• Ignoring locator issues
• Blaming test syntax instead of element identification

5. You are designing acceptance tests for an online shopping cart. Which scenario best fits acceptance testing principles?

hard

A. Check that adding an item updates the cart total and displays the item

B. Test the database query that retrieves product prices

C. Verify the 'Add to Cart' button triggers the correct JavaScript function

D. Ensure the CSS styles for the cart page load correctly

Solution

1. Step 1: Identify acceptance test focus

   Acceptance tests check if the user sees expected results after actions, like cart updates.

2. Step 2: Evaluate each option against acceptance testing

   Check that adding an item updates the cart total and displays the item describes user-visible behavior after adding item, fitting acceptance testing. Options A, B, and D focus on internal code, database, or styling, not user outcomes.

3. Final Answer:

   Check that adding an item updates the cart total and displays the item -> Option A

4. Quick Check:

   User sees cart update = acceptance test [OK]

Hint: Acceptance tests focus on user-visible results, not code details [OK]

Common Mistakes:

• Choosing technical checks over user outcomes
• Confusing acceptance tests with unit or integration tests
• Ignoring visible feedback to users