Agile Testing and Quality Control Practices

Agile testing is the frequent verification and validation at test checkpoints and reviews throughout the project.

What is Agile Testing and Quality Control Practices

Agile testing is the frequent verification and validation at test checkpoints and reviews throughout the project. Agile teams take quality seriously from the start and embed the principles of prevention, early detection, early problem solving and troubleshooting into their practices. Some of the agile testing techniques include: Automated testing, Unit Testing, Exploratory testing, and Usability Testing. Some techniques to embed the quality into practices include: Pair programming, Test-driven Development (TDD), Acceptance Test Driven Development (ATDD), Behavior driven development (BDD), and Continuous Integration (CI).

Top related courses to Agile Testing and Quality Control Practices

Related methods and techniques to Agile Testing and Quality Control Practices

  • Unit Testing

    1. Unit Testing

    Unit testing is the testing of the smallest testable parts of the application code (called unit), such as modules, functions or code fragments. Unit testing is often performed in an automated process because frequent unit testing can quickly identify problems or code conflicts.

  • Acceptance Testing

    2. Acceptance Testing

    Acceptance tests check the acceptance of the results against the acceptance criteria of the user story (business requirements).
    These tests could be to check the result of a specific requirement, a specification, or contract requirements.

  • Exploratory Testing

    3. Exploratory Testing

    Exploratory testing is in addition to the 'scripted' testing (e.g., unit testing). In exploratory testing, tester explores the system on the fly to find issues and unexpected behavior in the system.

  • Usability Testing

    4. Usability Testing

    Usability testing is a technique to evaluate the user interaction with system under realistic conditions or controlled settings. The purpose of usability testing is to find out how well users respond to the system? How easy is it to use the system? What improvements are needed in terms of usability?

  • Continuous Integration (CI)

    5. Continuous Integration (CI)

    Continuous Integration (CI) is automating the integration of new or changed codes into the code repository. Continuous integration helps identify conflicts or incompatible code as early as possible and fix them as they occur. Code repositories allow developers to roll back code to previous versions.

    Continuous Integration involves:
    Source code control system – version control
    Build tools – build tools to compile code
    Testing tools – unit tests to ensure functionality works as expected
    Schedulers or triggers – initiates builds on a schedule or based on conditions
    Notifications – emails or instant messages reporting build results

  • Test-Driven Development (TDD)

    6. Test-Driven Development (TDD)

    In Test-Driven Development, the tests are written before the code is developed.
    The developer goes through the Red-Green-refactor (clean) stages until the code is finalized:

    Red – The written tests initially fail as the code is not written or is incomplete.
    Green – The code was written and passed the tests.
    Refactor – The developer works on cleaning up and refactoring the working code.

  • Acceptance Test Driven Development (ATDD)

    7. Acceptance Test Driven Development (ATDD)

    In acceptance test driven development (ATDD), the focus of the tests are on business requirements and the desired behavior from the system. The tests are written based the acceptance criteria of user stories that the developer team transforms them into acceptance tests that can be stored in the testing tools. The tests fail initially because they are written before the desired software functionalities are developed and work.

  • Behavior-Driven Development (BDD)

    8. Behavior-Driven Development (BDD)

    Behavior-Driven Development (BDD) is an agile testing technique that aims to validate scenarios and behaviors of the system. It follows the Gherkin language that uses the format of "Given, When, Then" keywords to describe desired system behavior – what should happen when in the application.

  • Pair programming

    9. Pair programming

    Pair programming is a core practice of the XP framework that allows team members to learn from each other, increase productivity, and find bugs by writing, directing, and reviewing code in pairs. The driver writes the code while another person, the navigator (aka. observer), reviews each line of code entered. The pairs (two members) change roles (i.e., driver and navigator) frequently. The navigator looks at major problems and errors and makes notes and share ideas on possible next steps or obstacles.

    Pair Programming is best done when team members are in the same location.