Agile Testing Life Cycle: Hypatia Rojas
Agile Testing Life Cycle: Hypatia Rojas
Hypatia Rojas
Hands off approach.- Developers and testers work separate from each other.
Ratio.- 3:1 developer:tester ratio typical; In complex cases the ratio may be 1:2
Responsibilities.- Developer team will have architects and programers. Test team may have some
programing skills for automation. Specialize on setting up/maintaining the test environment and
running testcases.
Documentation.- Testers create test plan and well defined testcases, report defect tracking.
Iteration 0.- Initial requirement envisioning / initial architecture envisioning. Organize the team as a whole
(developers/Architects/stake holders/testers etc.) Beginning to set up test/development environments.
Construction Iterations.- Iterations 1-N. Use a prioritize requirement practice by taking the most important tasks from the work
item stack or product backlog and implement them. Agile teams will take a whole team approach where testers are embedded
in the development team, working side by side with the them to build the system. The focus of the team is Test-Driven
Development (TDD). The team produces Confirmatory Testing via Development Regression Testing.
Parallel independent Testing.- This team only exist to test very complex projects. The ratio is approximately 1:15
tester:developers. The team has skilled members that set and maintain a complex test environment to test more then one
project. This team may or may not automate the testcases. This team may use RQM to create and report test plans, test-
cases, and defects to the different projects in the organization. This team executes what is called “System Integration
Testing”.
Iteration N.- This iteration may be used for “End Of Cycle Testing”. The EOC testing is typically done by the Parallel
Independent test team
End of iteration demos.- This is also considered a test effort. The presenters will collect comments from the stake holders and
open tasks
Release Iteration(s).- This is iteration R in blue. The goal of this iteration is to deploy a system into production and some End
Of Cycle testing may be needed to ensure that the system is ready for production.
© 2007 IBM Corporation
4 Nov 14,
Test-Driven Development (TDD)
Test-driven development (TDD) is an agile development technique
which combines:
Test-first development (TFD).- The first step is to quickly add a test,
basically just enough code to fail. Next run the tests, often the complete
test suite although for sake of speed you may decide to run only a
subset, to ensure that the new test does in fact fail. Then update your
functional code to make it pass the new tests. The fourth step is to run
the tests again. If they fail you need to update your functional code and
retest. Once the tests pass the next step is to start over.
Refactoring.- is a technique where you make a small change to your
existing source code or source data to improve its design without
changing its semantics. The test case may also need to be updated.
System Integration Testing.- A combination of different
hardware and software to test a project. Example: KVM/Power.
IBM Director/TPM
Security Testing.- Project may need to test functionality and
data security
Usability Testing.- Complex testing that may involve other
languages and may need specific equipment
Test Environment.- Manages and updates the test environment