Agile Testing Methodology
Agile testing methodology is one of the aspects of the software development lifecycle. It runs continuously alongside the development effort. The commonly used Agile Testing Methodology are:
Test-Driven Development (TDD)
Test-driven development (TDD) starts where tests are developed first based on the requirement provided by the user before writing production code. The development begins by creating the unit tests based on the user requirement and then write the code until the unit test passes.
The primary goal of TDD is a specification and not validation. It is important both for agile requirements and agile design techniques. The primary purpose of TDD is to write clean and defect-free code.
TDD is typically used on unit and component tests — which can be done with automated testing tools. TDD ensures the feature works as per the requirement.
Acceptance Test-Driven Development (ATDD)
ATDD focuses on getting feedback from various channels with different perspectives like customer, developer, and tester. Acceptance tests are defined which incorporates these different perspectives.
ATDD starts with customer input on functionality and then acceptance tests are defined based on inputs provided by the user. The next step is where unit tests are created based on the defined acceptance test. And then the code is written which is expected to pass the unit test.
ATDD is typically driven by pre-defined Acceptance Criteria and Acceptance Test Cases.
Behavior-Driven Development (BDD)
Behavior-driven development encourages communication between project stakeholders, so that members understand features, prior to the development process. Scenarios created by the business analysts are written in a specific format, the Gherkin Given/When/Then syntax. The scenarios describe the feature behavior in different situations with different input parameters.
In BDD, scenarios are created first, then tests are builds around those scenarios which are initially expected to fail, and then builds the software functionality that makes the scenarios passed.
Thus, development needs to be tied to a business outcome. BDD is also used for acceptance tests. These tests can be further automated as well using various frameworks like Cucumber, etc.
Exploratory testing allows the tester to test the functionality of an application by exploring the application rather than following a predefined path. It is a manual process. The testers try to learn the application and design & execute the test cases according to their findings.
This type of testing focuses on interacting with working software. The test design and execution activities are performed in parallel without formally documenting the test conditions, test cases, or test scripts.
Exploratory testing is typically used to find hidden risks within a product. These would be bugs that are missed in functional tests done in TDD.
Characteristics of Agile testing
- Business stories are generated to define the functionality.
- Continual feedback and acceptance testing are done by customers
- Promotes pair programming and shared code ownership amongst the developers.
- Test scripts should be written and automated with implemented code.
- Integration and testing of the code happen together.
- Quick response to change request
Advantages of Agile
- Customer satisfaction by rapid, continuous delivery of useful software.
- Frequent interactions with Customer, Developer, and Product Owner.
- Continuous attention to technical excellence and good design.
- Teams make changes in behavior in order to improve the effectiveness and efficiency of work.
- Receives late changes in requirements.
- It has faster turnaround times.
- It believes in face-to-face conversation which is ultimately the best form of communication.
- Product developed at a fast rate and frequently delivered (weeks rather than months) to the user.
Disadvantages of Agile
- It is difficult to assess the effort required at the beginning of the software development life cycle in case of some features.
- Frequent changes in the feature can also make it unstable.
- The cost of the Agile development methodology is more.
- Only expert project members are allowed to take any kind of decision during the development process.
- Documentation prone to get sidetracked which makes it difficult for new members to get up to speed.
- Agile demands more time and energy from resources because developers, testers, and customers must constantly interact with each other.
- The product lacks overall design, both from a UI/UX and architecture point of view, which leads to problems.
- Short cycles don’t leave enough time for the design thinking process, so designers have to redevelop the experience over and over due to negative feedback.
- In some cases, Projects can become ever-lasting because there’s no clear end.