Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.
Regression and Configuration Testing5:44 with Ryan Saul
Before new software is released, we need to determine that the software our users are already regularly using is still functioning the way we want it to. To do this, we need to test all of the features that have come out in the past, alongside all the new features we have just build.
Test Plan: RSVP App - Edit Invitee Feature Release
Verify edit invitee feature for RSVP app.
Regression test previous features.
Test on all supported browsers - Chrome, Firefox and Edge on Windows 10.
New Feature testing - 1 Day.
Regression testing - 1 Day.
Supported browser testing - 1 Day.
Total: 3 days.
- Test results.
- Bug report.
- Configuration test matrix
- Release must contain edit feature.
- All critical defects must be fixed.
- 100% of regression tests pass.
- All supported browsers must pass.
Risks and Contingencies:
- Previous client data may not load.
- Rollback to previous version.
- TEST1: Invite Someone new
- TEST2: Confirm someone
- TEST3: Remove someone
- TEST4: Edit someone
Configuration test example
|OS and Browser||Windows 10||Windows 8||OSX - High Sierra|
Before software gets released, we usually want to get some confidence
around whether the rest of the software that our customers already know and
love still works or not.
To do this, we basically need to test all of the features that have come out
in the past alongside all of these new features.
The nice thing about testing older features
is that you've probably already created test cases for them.
We like to call running these older test cases regression tests
because we're looking for regressions in the software.
Or to put it another way, if a test passed in a previous version of the software but
it is now suddenly failing, that's a regression in the software.
A regression is when a previous feature
begins to act in unexpected ways in the new release.
Compare that to a feature test.
A feature test is one we test out new functionality in the software, or
when something has been so heavily modified that it's new to us.
Feature tests are new and regression tests are old.
Feature tests are usually run once or twice before being rewritten into
regression tests because eventually, that new feature will become an old one.
When I think of a feature test,
I usually see it as being a one shot test to prove out the new functionality.
But I'll probably reapproach the feature later on when creating
a regression test for it.
Your test plan is going to have a mix of these feature tests and regression tests.
Assuming you're releasing some new feature with the next version of the software,
let's take our RSVP app again and the test plan that we've been creating for it.
So while I may have a feature test that checks the new edit someone functionality,
I also have a regression test for
invite someone, confirm someone, and delete someone.
With all four of these tests, I'm pretty confident that when we release
the software, it's going to work as intended.
But it turns out that there's one more thing we haven't considered.
What about all these other browsers?
So far we've been testing our software on Google Chrome, but
what about Firefox and Microsoft Edge?
To do this, we're going to also need to do some configuration testing.
Configuration testing is testing out all the systems and
their configurations that your software should run on reliably.
As you can imagine, this gets very complicated very quickly.
Many companies employ a test matrix of different configurations and
the test that will need to be run on each of them.
We're not gonna do a lot of that in this video, but you should know
that a lot of configuration testing depends on the software.
Some examples of things that you'll need to be testing are the operating systems,
different versions of the operating systems, drivers for
your hardware, sometimes even the hardware itself will all need to be tested.
Mostly, these apply to desktop applications, though.
For web applications, the main thing we need to worry about are the browsers.
Typically on a web application, you need to worry about which operating system your
users are on, the browsers they use, which versions of the browsers they're on,
and any other mobile devices that you wanna support.
This can also get fairly complicated.
It's important to write all these configurations down in a test plan.
In the test matrix that I have here, I have all the supported operating systems
at the top and all the supported browsers over on the left.
And we can tell which ones have passed and
failed based on our tests within this matrix.
It's also important to denote which test cases need to be tested
on which configurations.
For example, tests for a REST API probably don't need any true configuration testing.
You just need to make the API calls, and the browser doesn't really matter.
But for any UI tests,
we need to make sure that each browser handles the tests correctly.
Many times, even simple features will break down between Firefox and Chrome.
Mobile testing is another important area.
Web apps are often built to work on mobile devices, but
the different versions of these devices can often have different results.
I recommend two things to get some confidence around this.
First, limit the scope of which tests you do on all these different configurations,
and possibly write mobile-specific tests.
Second, use a VM-based browser testing tool, such as CrossBrowserTesting or
BrowserStack, that allows you to choose all sorts of different devices,
operating systems, browsers, and all of their various versions.
We'll have links to these tools in the teacher's notes below.
You'll probably see a huge list of different versions like here
on CrossBrowserTesting to get the versions that you need.
In configuration testing, you'll need to basically run a lot
of the same tests over and over on different configurations.
It can be tedious, but it builds a lot of confidence in the release.
Remember to limit the scope of what you are testing to
more of the bare essential tests when you're planning for configuration tests.
In our next video, we're also going to talk about ways to test
smarter with exploration testing and automating your tests.
You need to sign up for Treehouse in order to download course files.Sign up