Test Automation for All
Four 4-hour live instructor led online sessions with hands-on lab exercises
Test automation promises to save time and increase reliability. Often it’s considered an essential first step on the way to agile software development, DevOps, and modern development practices. It promises a world where every change and new feature is instantly checked to see that it meets its intended requirements and doesn’t break the rest of your systems.
Overcome the obstacles and start automating now
Today every software team faces the challenges of delivering more capabilities on faster timelines with greater reliability. Whether you call it “adopting DevOps practices,” “doing Agile,” or just plain “being more responsive to the business,” test automation is key to improving the efficiency and capabilities of your development processes.
Yet many teams fear test automation to be challenging, difficult, or impractical. There’s an alphabet soup of complex tools that seem beyond your reach. Automated testing has to be integrated into automated integration and delivery processes that don’t exist. How can you tame the madness and start to achieve the benefits on your schedule and budget?
Produce more frequent and reliable releases through test automation
Learn how to improve your development throughput and reliability by replacing slow, boring, and error-prone manual testing with fast, repeatable automated tests.
Organize your systems and processes to get the most out of automated testing. Improve system reliability by improving test coverage. Support deployments across many platforms with a single set of reusable tests.
Cut through the fear, uncertainty, and doubt surrounding test automation. Choose the tools and techniques appropriate to your project requirements and team skillsets.
Achieve automation without complex coding
Companies looking at test automation frequently want to transform manual UI-level testing into automated tests.
Writing automated tests is a programming activity. But often manual testers do not have coding and development skills. Some companies try to solve this by trying to put their manual testers through a quick training program (“boot camp”) intended to cover a programming language and an automation framework. This turns out to be harder than it seems.
Objectives
When you complete this course you will be able to:
- Explain different kinds of test automation
- Record UI tests using a record-playback tool.
- Create suites of tests that incorporate normal and exceptional scenarios.
- Write (and use tools to write) acceptance criteria as a series of detailed scenarios.
- Compare and contrast BDD scenarios with classic use cases.
- Use test scenarios to facilitate scope discussions with a development team.
- Devise a plan for converting your current manual testing processes to automated tests.
- Use a generation tool to create tests as combinations of inputs, conditions, and expected results.
- Model a user activity using a state model navigation map. Define a set of scenarios to fully cover paths through that activity.
- Explain the “DRY” principle and how to follow it to create more modular tests.
- Use unstructured exploratory testing to learn about and to discover bugs in an application.
- Use tools to document exploratory testing.
- Apply principles of equivalence partitioning and boundary value analysis to create test data.
- Create a test oracle that computes inputs and expected results.
- Explain the Test Automation Pyramid
- Understand the concepts of “coverage,” its implications for product quality, how to measure it, and how to improve it.
- Determine the extent of a user story. Apply a user story to KRAC (usually add / change) test suites.
- Track development progress with tests.
- Assess an application’s amenability to automation.
- Determine the skills required for your organization to successfully adopt automation.
Course Outline
Much of the learning takes place while doing exercises that demonstrate and reinforce the key course concepts. No specific programming skills are required. Many exercises require no more than pencil and paper. For other exercises, students get hands-on experience with several different test design and execution tools.
What’s Testing? Why Test?
- See how testing has become a hot topic in recent years with the growth of agile methods, automation, and DevOps.
- Discuss different purposes of testing
- Explore various testing facts and fallacies
- Exercise: How would you test a particular application?
Why Automate Testing?
- Learn why automated testing is a key part of an agile incremental development process.
- See how the short cycle times introduced by agile processes require faster test turnaround.
- Explore different kinds of test automation.
- Exercise: Discuss your current automation practices and goals.
Your First Automated Tests
- Learn the basic structure of an automated UI test, including setups, user behaviors, and checks.
- Learn how to build tests by copying and editing existing test cases.
- Practice building suites that incorporate normal and exceptional scenarios.
- Exercises: Create tests using the Selenium IDE record/playback tool. Create new tests from existing tests. Organize tests into playlists.
Designing Tests for Automation
- Examine test-driven development practices.
- Show how scenarios can be defined up front to say, “here’s what I expect this to do.”
- Show how progress toward completion can be measured by which scenarios pass.
- See how the Cucumber system enables test scenarios as executable specifications.
- Exercise: Write test scenarios in the Gherkin Given-When-Then language.
Automating Test Authoring
- Understand the difficulties in building tests one by one.
- Learn how to identify scenarios and to build test cases by forming combinations of inputs and environment conditions.
- Define actual values and identify required preconditions.
- Create directions for evaluating scenarios and manual testing.
- Connect individual test steps (“unit tests”) into functional test sequences.
- Exercises: Use the TAME test generation tool to create suites of scenarios and test cases
Modular Automation
- Identify the automation instructions associated with inputs, events, and checks.
- See how the scenarios of a story have common parts.
- Learn how to write scenarios to exploit the “DRY” principle.
- Identify setup and teardown instructions for test cases and an entire test suite.
- Exercises: Add the automation instructions from Selenium IDE tests to a TAME workbook. Generate and run automated tests.
Multi-Platform Testing
- Learn why it is important to test on many different platforms.
- Define and identify the platforms you’ll need to test.
- See the complexities in automating cross-browser tests.
- Explore tools that facilitate cross-browser and multi-platform testing.
- Understand how virtualization (virtual machines and containers) facilitate multi-platform testing.
- Exercise: Run automation tests on different browsers and window sizes. Adapt the tests to perform uniformly across different platforms.
UI Automation in Depth
- Understand the concept of “visual validation.”
- Learn how locator expressions are used to find UI objects.
- Distinguish between easy and difficult locator expressions.
- Learn how recorded locator expressions may produce fragile tests and how to make these locators more robust.
- See how to automate and check many different kinds of UI elements and controls.
- Exercises: Evaluate recorded locator expressions. Use built-in browser tools to improve locator expressions. Practice automating different kinds of web UI elements.
Exploratory Testing
- Learn how to use ad hoc exploratory tests to supplement scripted planned tests.
- Explore various tools that can be used to record exploratory tests.
- Conduct exploratory tests against an application.
- Learn about tools available to support exploratory testing.
- Exercise: Explore a new application to learn about the application and to find potential bugs. Practice describing bugs by writing Gherkin scenarios.
Automating Test Data
- Apply the techniques of equivalence partitioning and boundary value analysis.
- Use random generators to create test data.
- Understand the concept of a “test oracle.” Define expected results via calculations.
- See how value choices can originate from both black-box and glass-box tests.
- Create tests with allowed and disallowed input formats.
- Exercise: Define input and result values to create self-checking test cases.
Agile Test Automation
- Explore test activities in the life of an agile user story.
- See how to define scenarios that scope a story and become its test cases.
- Learn how to incorporate automated testing into the build and deploy processes.
- Discuss how to “shift left”—to make development and testing into concurrent activities.
- Exercises: Create scenarios for user stories’ acceptance criteria.
The Automation Pyramid
- Learn the history, rationale, and misinterpretations of the Test Automation Pyramid.
- Practice organizing a system top-down into processes, activities, and steps.
- See how development and testing generally proceed bottom-up.
- Explore different meanings of the term “unit test.”
- Learn how to describe a software architecture.
- Exercise: Describe how to test a complex process. Identify components that may need to be “mocked” during development.
Automation for Developers
- See how automation tests can be written by writing programming language code.
- Understand the pros and cons of constructing complex suites of code-level unit tests.
- Learn the general architecture of coded UI tests, including the concept of adapters.
- See how to use an IDE (Integrated Development Environment) to run coded tests.
- Practice measuring certain code properties and using those metrics to improve test suites.
- Exercises: Depending upon participants’ development skills and interest, practice applying these techniques in a commonly available IDE.
Automation Beyond Functional Testing
- Recall the difference between functional & nonfunctional requirements (“quality attributes”).
- Learn techniques for making nonfunctional requirements testable.
- Explore tools for performing nonfunctional testing.
- Exercises: Write quality attributes to be SMART (Specific, Measurable, Attainable, Relevant, and Timely). Use tools for evaluating a web application’s accessibility.
Assessing Automatability
- What makes an application easy or hard to automate?
- Examine how to balance the needs for automated vs. manual tests.
- Understand the technical and human factors that need to be considered when making a commitment to test automation.
- Exercise: Discuss a real-life test automation assessment plan.