Software Testing

Test Automation Expert and Test Architect. He is a seasoned tester who can’t stay long in one place. He is looking for perfection and a place to challenge his skills.  He gathered experience working for different companies with different working models, From small to big corporations, From Products via In-house development to software house. Thanks to that he has a wide perspective on testing quality and delivering value.\

[linkedin.com/in/wyrodek/](https://linkedin.com/in/wyrodek/){ref="nofollow"}

large_https://i0.wp.com/wyrodek.pl/wp-content/uploads/2017/01/T1A0194.jpg

medium_https://i0.wp.com/wyrodek.pl/wp-content/uploads/2017/01/T1A0194.jpg

small_https://i0.wp.com/wyrodek.pl/wp-content/uploads/2017/01/T1A0194.jpg

thumbnail_https://i0.wp.com/wyrodek.pl/wp-content/uploads/2017/01/T1A0194.jpg

https://i0.wp.com/wyrodek.pl/wp-content/uploads/2017/01/T1A0194.jpg

Maciej Wyrodek

As a movement, DevOps is over 10 years old, and it is one of the most dominating approaches to modern software development. In some companies, however, testing in DevOps has become a critical issue.

[TABLE_OF_CONTENTS]

Lots of old methods and techniques are no longer good enough. DevOps requires changes in testers’ mindsets. Not everybody could adopt to this new era. Today we will try to help. We will look at some practices and techniques that actually work! We will also talk about quality mindset and look at automation. But first, we need to answer a few questions about DevOps and Testing, starting with:

## What do we mean by DevOps?

As with everything, DevOps has become a generic term. Everybody understands it differently:
- for some, it is about tools like CI/CD,
- for others it is a role in a company - usually a cloud and a CI/CD expert.

We will use a definition by [Gene Kim](https://itrevolution.com/faculty/gene-kim/){rel="nofollow"}, author of books like [Phoneix project](https://itrevolution.com/the-phoenix-project/){rel="nofollow"} and a [DevOps handbook](https://itrevolution.com/the-devops-handbook/){rel="nofollow"}, one of the greatest evangelists of DevOps.
In short: DevOps is a culture which helps to create learning organizations which can outperform competition, thanks to fast learning and experimentation enabled by fast delivery of the product.

In [Beyond the Phoenix project](https://itrevolution.com/book/beyond-phoenix-project-audiobook/){rel="nofollow"}, Gene Kim summed it up as 3 ways of DevOps:
- All about Flow,
- All about Feedback
- All about Learning

In short: You need to deliver a product fast to see how it works and learn what to improve, then repeat the cycle.

## What About testing?
Testing is good about collecting feedback and giving information, so it can be helpful with the feedback part.
But what about speed? Management Often sees testing as cost and a bottleneck.
Some even say you can’t have a good quality product if you are going fast. As we learn later, this is not true, but first, let’s discuss another important topic:

## What is quality?
I want you to answer one question. Which product is of better quality:
 - both are doing similar things,
- both have been on the market for some time
- one is a popular product with millions of users and known bugs in hundreds.
- the other one has less than a thousand users but virtually no bugs.

*So which is of better quality?*
At first glance, the other one feels as a better answer since it has fewer bugs.
But commercially it is a failure, it barely has any users! Users chose the other one  - maybe it was first on the market, maybe has had better marketing, maybe a better price.
The fact remains that, despite its all flows, the product is good enough for the users. We call this shippable quality, a product that good enough for users doesn’t need to be perfect as long as it satisfies the users’ needs.
The first thing you need to understand about Testing in DevOps is that **shippable quality today is better than perfect quality tomorrow**!

## Quality at Speed in DevOps
There is also one interesting paradox: the faster and more often you deploy, the better your product quality.
Why? In short:
1. First, you deploy frequently,
2. Each deployment contains less code, instead of months ita takes weeks, instead of weeks it takes days or even a single story.
3. Less code means fewer merging issues, fewer dependencies to check.
4. It also means smaller changes that are easier to test.
5. Resulting in fewer bugs.

It means you can also deploy quick fix if we find a serious issue.

## The Goal of Testing in DevOps
Summing all the concepts, we add all this together. The goal of testing in DevOps is clear: Empower teams to achieve testing as fast as possible.

## Ways of Testing in Devops

### Shift Left
To put it simply, Shift left is about testing as early as possible - and it doesn’t mean testing the finished product as early as possible. It means that, if you can find a partial concept or even an idea that you can verify before everything is done, you should do it at first chance.

A few Examples:
Start with the documentation. If the team has refinements, or there is a meeting where new features/stories are discussed, this is the place to put on the testing hat and do some lateral thinking. Pinpointing the issues here will save time later.

This is the time to ask a few important questions:
- How are we going to test it?
- What can we do to test it as fast as possible?

If the team is too big and the entire team meeting is out of the question, it is a good idea to have a 3 amigos meeting with the developer, the tester and the product owner/analyticto discuss how to develop a story and how to test it. The goal of this discussion should be to decide what needs to be automated and what to check manually.

Another example of Shift left is Dev Testing - instead of having a dedicated testing expert, developers with enough training can very well test their own code. It requires practice and discipline but canal in all, it saves a lot of time on the hand over imagine standard approach:
1.  developers write a code;
2.  the code waits for testing
3.  the testers test and find bug
4.  the bug waits for the developer to have the time to fix it
5.  the developer fixes it
6.  the bug waits for retest.

You get the idea. Now let’s look at a much shorter loop:
1. the developers write a code
2. they test it and fix issues immediately
3. Deployment

[As The Goal](https://www.amazon.com/Goal-Process-Ongoing-Improvement/dp/0884271951){rel="nofollow"} has showed us, a physical product wastes a lot of time just waiting to be worked on by different stations. Our work is not so different.
Of course developers need to be first taught how to test - and there are ways to do it: Dev-Test Pairing, or [Session Based Testing](https://www.satisfice.com/download/session-based-test-management){rel="nofollow"} with debriefings.
There is a lot more to shift left, but in general you can describe it in one phase: test as soon as possible.

### No code automation
Automation is a vast topic which we won’t cover completely here. Test automation should be a part of shift left, meaning: Automate as early as possible and only as much as you need. There are two tools that help in deciding what and how should be automated – a [Test Pyramid](/blog/software-testing/testing-pyramid-a-successful-approach-to-test-automation/) and Testing Quadrants.

However, the basic rule of thumb isthat if something can be done as unit test simply it should be done.

Unfortunately, even using this rule, we still need some end-to-end testing - this type is difficult to write and hard to maintain. Flaky(unstable) test are the bone of the industry.  Even the best companies, like Google, have problems with achieving 0% of flaky tests when creating end-to-end tests using tools like Selenium Web Driver or Cypress.

Usually, writing and stabilizing an end-to-end test takes a long time. Now imagine that you want to deploy often, but practically each new story requires fixing/changing the test automation, which takes a long time and slows you down.

Fortunately, the popularity of no-code leads to the rise of a new generation of Test Automation Tools like [BugBug.io](https://bugbug.io) and Mabl. Both allow to create a stable test in minutes!
Previously, the biggest issue related to this tool was that if a test was failed, your only option was to rerecord it. While fixing these test is much simpler, remember that Testing in DevOps is about speed!

Even if you would have to rerecord the test, it still will be faster than fixing a coded end to end test Written in Selenium Web Driver or Cypress.

### Monitoring and Testing in production
Unit and integration testing is all very nice but your system testing is also important. You need to make sure that everything works nicely together. There is one problem: the test environments. 

Usually they are not really on a par with production - they may have too low resources, run on different OS and many, many other issues. Even in the staging environment, often it is not a good representation of the production environment. Yes, in theory they should but in reality, if you want to test in an environment resembling production, there is no better place than production itself!

Ok, but how do you do that?
There are lots of approaches.
For example, you can do [cannery releases](https://martinfowler.com/bliki/CanaryRelease.htm){rel="nofollow"} of your application to see how it works in the wild.

If you have [a/b testing](https://hbr.org/2017/06/a-refresher-on-ab-testing){rel="nofollow"} - you can use these tools to hide all the new good things behind the a/b test and, after team ensures it is working, you can slowly start to show it to more and more users.
Another approach is [blue/green deployment](https://martinfowler.com/bliki/BlueGreenDeployment.html){rel="nofollow"}.

However, first YOU NEED TO HAVE GOOD MONITORING - with good observability. especially of user activity.
Remember what DevOps is about: “all about flow, all about feedback, and all about learning” - monitoring helps with both feedback and learning!
With a good rollback strategy or feature flags, you can safely deploy a code to production. If something goes wrong, swiftly disable it.

If you want to learn more, Cindy Sridharan runs an amazing blog [post](https://copyconstruct.medium.com/testing-microservices-the-sane-way-9bb31d158c16){rel="nofollow"} [series](https://copyconstruct.medium.com/testing-in-production-the-safe-way-18ca102d0ef1){rel="nofollow"} on [this topic](https://copyconstruct.medium.com/testing-in-production-the-hard-parts-3f06cefaf592){rel="nofollow"}.

### Quality Culture
We have talked about DevOps and we have talked about testing in it; there is one more issue to address as even the best tools and technical solutions won’t save the day if there is no culture promoting quality.  In order to create this culture, we need good principles.
Fortunately, [Modern Testing](https://www.moderntesting.org/){rel="nofollow"} comes to the rescue, trying to address the necessary cultural changes for testing in DevOps.
The basic principles include:

1. Our priority is improving the business.
2. We accelerate the team, and use models like Lean Thinking and the Theory of Constraints to help identify, prioritize and mitigate bottlenecks from the system.
3. We are a force for continuous improvement, helping the team adapt and optimize in order to succeed, rather than providing a safety net to catch failures.
4. We care deeply about the quality culture of our team, and we coach, lead, and nurture the team towards a more mature quality culture.
5. We believe the customer is the only one capable of judging and evaluating the quality of our product
6. We use data extensively to deeply understand customer usage and then close the gaps between product hypotheses and business impact.
7. We expand testing abilities and knowhow across the team; understanding that this may reduce (or eliminate) the need for a dedicated testing specialist.

## Summary

Today we started with the same definition of DevOps - culture concentrating on flow, feedback and learning.

We have explained the goal of testing in DevOps - empowering teams to achieve shippable quality as fast as possible.

Then we looked at a different way to help us achieve this goal from shifting left, and no-code test automation, to testing on production, ending on testing culture.

Notably, at first many of the discussed issues were not directly related to testing.

Most of the technical solutions require changes either in the process the deployment strategy or the code structure.

This is another important aspect of Testing in DevOps - testing cannot be left to the end. Just like quality, it needs to be built into both the product and the process. Since the beginning, it cannot be an afterthought.

If there is one thing that can bring your team closer to excellent DevOps testing, start with asking these questions: How can we test it? When is the first opportunity we can test it?

large_bug-g27e425b83_1280.jpg

medium_bug-g27e425b83_1280.jpg

small_bug-g27e425b83_1280.jpg

thumbnail_bug-g27e425b83_1280.jpg

bug-g27e425b83_1280.jpg

Testing in DevOps

testing-in-devops

thumbnail_https://media-exp1.licdn.com/dms/image/C4E03AQFhPAvVKTYptQ/profile-displayphoto-shrink_800_800/0/1575468541681?e=1646265600&v=beta&t=y7yyvxBb2bUGOo5TrJ4VmRjRrjcjfooYSAbit9n25F0

https://media-exp1.licdn.com/dms/image/C4E03AQFhPAvVKTYptQ/profile-displayphoto-shrink_800_800/0/1575468541681?e=1646265600&v=beta&t=y7yyvxBb2bUGOo5TrJ4VmRjRrjcjfooYSAbit9n25F0

Mark Macznik

If you want to make it big as a software developer, you need to deliver your clients a product that is stable and of high quality. Programming is a complicated process, and very often many programmers work on the same project. The more complex the software, the more bugs and flaws will creep their way into it – and it is absolutely crucial to beat them out before the final build reaches your client. 

Smoke testing is one of the methods of preliminary testing, often performed as functional tests or unit tests during the software production process. A smoke test is a critical test type, and passing it is one of the key requirements for moving on with the testing process. 

But what exactly is smoke testing and how is it performed? Is it as important as we say? We will try to answer these questions and more with this short yet informative guide on smoke testing with examples.

## How does Smoke Testing work?

Smoke testing, being one of the critical testing methods, aims to confirm whether the basic functionalities of your software are working as intended. Smoke testing is most often performed on initial builds when the software is at its most unstable. The results of smoke testing can give you a good idea of what’s working and what’s not in your app, allowing you a smooth transition into regression testing in the future.

Hiring a QA team to perform detailed tests on your software can be expensive. If you decide to keep your own QA team on a payroll every month, you can quickly find yourself bleeding money, and the team might not have that much work to do – especially if you’re a small developer. Outsourcing your QA might lower your costs, but still won’t be cheap. Performing a basic smoke test will give you an idea of which areas you will need to focus on during future testing. Keep in mind that smoke tests aren’t meant to be thoroughgoing – make sure to choose test cases that will only target the most crucial functionalities of your software. We can check everything in more detail during the later testing stages.

## What’s the difference between Smoke Testing and Sanity Testing?

If you know your way around software testing, you might have already spotted the similarities that smoke testing has when compared to sanity testing. Both tests mean to evaluate basic functionality to determine whether or not the app should move ahead to further tests, or whether it still needs more work at its most fundamental level. So what’s exactly the distinction between the two? 

While some argue that the two terms can be used interchangeably, there is actually a bit of difference. Sanity testing refers to testing new functionality and fixing bugs caused by patches or updates. Smoke testing, in turn, focuses on the key functionalities of the software.

## The benefits of performing a Smoke Test

While you might think smoke testing is only a rudimentary way of software testing, the benefits it gives the development team are undeniable. Apart from allowing you to save money on further QA by identifying flaws in basic functionality, smoke testing can save you tons of effort and time. If you should skip smoke testing and proceed directly to regression testing, you can easily get stuck in a testing cycle loop, moving on to thorough tests and going back a few steps each time a major error is found.

Smoke testing is fast, efficient, and effective. It allows you to find out any flaws and defects in the earliest stages of software production, reducing the risk of releasing a faulty product. Once all of the major bugs and problems have been solved you can then move on to more detailed testing methods, but in the beginning, smoke testing gives you the ability to swiftly get rid of critical errors that would otherwise hinder your progress.

So what could exactly happen if you forget about ensuring a proper smoke testing stage? The most common results of skipping this preliminary test are major setbacks in the future, as major defects go on undetected and make a mess out of your functional testing stage. Having to go back to basic functions and gradually fix them one by one, instead of figuring out all of them right from the get-go, will ultimately result in a waste of time, money, and effort.

## Smoke testing examples and sample test cases

How exactly smoke testing will look depends heavily on the type of software you are developing. If you’re running a simple website that has register and login functions, an example of smoke testing would be verifying that functionality. The result you’re going to usually expect from such a test would be to simply access your website and log in without any issues. The steps would look similar to this:

1. Open up your browser’s executable
2. Navigate to your website
3. Open the login panel
4. Enter your credentials and log in/register
5. Finish the process

If the results are positive – as in you actually managed to log in or register, then the test was successful. You can create similar test cases for other basic functionality of your software, like verifying whether a cart system is working properly at your online store or checking if your app doesn’t crash after you open the executable.

## Summary

All in all, you can see why smoke testing is so important. Can you imagine forwarding your build to QA only to find out the app crashes on start? Avoiding smoke testing can lead to a tremendous waste of time and resources, delaying newer iterations of your software and putting you in danger of missing deadlines.

If you care about the quality of your software, smoke testing and sanity testing are the way to go. Always perform a set of smoke testing cases at the beginning of the development process and some additional sanity testing in future builds to ensure stability and minimize your team’s effort during the testing phases.

large_smoke-tests-blog.jpg

medium_smoke-tests-blog.jpg

small_smoke-tests-blog.jpg

thumbnail_smoke-tests-blog.jpg

smoke-tests-blog.jpg

A concise introduction to Smoke Testing

a-concise-introduction-to-smoke-testing

Testing is an ever-present part of a software developer’s job, performed at every stage of the production process. There is a wide range of test types used for software testing, some performed at various points during production, and some performed after production to confirm that the software functions as intended.

Regression testing is performed on a product that has already been finished and released. How exactly is it performed? What are the objectives and how does the procedure look? If you’re keen to find out, keep on reading as we explain everything you should know about regression testing.

[TABLE_OF_CONTENTS]

## The definition of Regression Testing

**Regression testing** is a software testing method that aims to investigate and locate any possible flaws or bugs in software that has already been fully developed. Regression Testing is performed to find out whether your software has regressed (surprise, surprise) as you continue introducing new updates and bug fixes. Whenever a piece of software is changed in any way, new bugs might emerge and some of the older ones re-emerge. 

Most often, regression testing is performed immediately after introducing a new update, but it isn’t the only factor that might call for the test. If any software or hardware-related factor has changed, regression testing should be committed to find out whether everything performs as it has before the change. This can include any sort of bug fixes and software changes, but regression might also be caused by hardware configuration changes and electronic component degradation over time. Regression testing isn’t easy – it requires cooperation and diligence out of all of the team members, which makes it perfect for Agile Software Development practices.

## Regression Testing techniques

Regression testing can include various functional and non-functional tests in its process to thoroughly investigate the software in search of flaws. There are also many techniques with which developers and QA specialists perform regression testing, including:

- Retest All
- Regression Test Selection
- Test Case Prioritization
- Hybrid approach

## Retest All – an accurate yet expensive solution

The **Retest All** technique is the most accurate and all-around method of regression testing, but it is also the most expensive one. In Retest All, every test case is checked again on the software to confirm if all of its parts are working as intended. That’s all there is to Retest All – it might be simple in definition, but it is definitely the hardest and most costly technique to actually perform.

## Regression Test Selection – when you realize you might not have enough for a Retest All

**Regression Test Selection** has been designed as a solution to the expensive nature of the Retest All technique. In **RTS** we don’t run all of the tests in our test suite, but instead we divide all of the tests into three categories – reusable test cases, retestable test cases, and obsolete test cases. In addition, RTS might actually create new test cases that haven’t been in the suite before, but might be relevant for regression tests.

If you’re interested in finding out more about regression testing examples, we recommend taking a look at *Understanding Regression Testing Techniques* by Gaurav Duggal and Bharti Suri. The authors further divide RTS techniques, naming two most important categories – coverage techniques and minimization techniques, and explain what are safe techniques.

**Coverage techniques** feature specific coverage criteria, often provided by the client who wants their software regression tested. These techniques sift through all test cases, selecting only the ones that are relevant for the covered parts of your software. **Minimization techniques** work in a way similar to coverage techniques, but instead of selecting cases based on set criteria, you select a minimum set of cases that you think will do the job.

## Test Case Prioritization – a rational approach

**Test Case Prioritization** aims to maximize the rate of fault detection, creating the most thorough regression test for the lowest cost. Every test case is assigned a priority, after which all of them are performed in order, starting from the most important one and finishing on the least important one. Thanks to that, even if your resources aren’t enough to perform all of the tests in your suite, you will still perform the ones that should detect the most flaws.

**TSP** might be performed in two ways – the first one, called **General Prioritization**, selects test cases that should be effective (on average) on all versions of the software you’re working with. The other way, called **Version Specific Prioritization**, only takes into account a specific version of the software, without considering other existing or potential future versions.

## Hybrid approach – the best of both worlds

When choosing one technique of regression testing is impossible – why not combine the best features of Regression Test Selection and Test Case Prioritization? The **hybrid approach** is still being developed, and every researcher gives a personal spin on the idea. Since there isn’t an exact definition of what a hybrid approach actually is, there are tons of versions available – each one with its own upsides and downsides. 

## Conclusion – is Regression Testing necessary?

As you have already learned, regression tests are performed to keep the quality of your software as high as possible for as long as possible. Updates and changes to your software might introduce new problems, which is exactly why regression testing is so important – to keep user experience high throughout all iterations of your program. 

Not all projects require regression testing, of course. In projects that are already finished and won’t be further updated, regression testing is mostly irrelevant. However, if you are planning to continue development further – never forget to properly regression test your software before releasing an update.

large_regression-tests-blog.jpg

medium_regression-tests-blog.jpg

small_regression-tests-blog.jpg

thumbnail_regression-tests-blog.jpg

regression-tests-blog.jpg

Everything you need to know about Regression Testing

everything-you-need-to-know-about-regression-testing

When working on a piece of software, testing is one of the most crucial elements of the production process. It allows the development team to find out what works and what doesn’t, and doing it in a proper, standardized manner will give your entire work crew a better sense of communication. With proper testing practices, you can ensure your product stays at its highest quality, minimizing the number of bugs and flaws the users may experience and speeding up the development process.

Functional testing is one of the general software testing categories, meant to verify the functionality of an app or a website. Testing isn’t something done only at the very end of development – in fact, in the early planning stages of the project, you should create a list of functional specifications. Simply put, make a list of what your software is supposed to accomplish.

Implementing a proper functional testing phase can be very beneficial to your development process. How exactly to implement it properly? Let’s see what functional testing is all about with some examples to make it easier to understand.

## Who can perform functional testing?

Since functional testing is a black-box software testing technique, the tester doesn’t need any knowledge about the inner workings of your software. In fact, the tester doesn’t even need to know anything about programming – functional testing is all about user experience, so the tester shouldn’t need any more knowledge than an average user is privy to. In fact, functional tests are most effective when performed by someone without deeper knowledge of the system they are testing.

With functional testing, you can easily check the main functionality of your software, confirming whether all required features work as intended. It also gives you the ability to see how accessible the app is to standard users – as a developer and (most probably) a programming specialist, your knowledge allows you to instinctively use an app or a system in a way that a standard user wouldn’t be able to. Functional testing lets you see exactly how usable the software is for such users, letting you see whether the end-user can use the software comfortably and what exactly happens when an error occurs.

## What are the types of Functional Testing?

Since functional testing is more of a category of software tests than an individual testing methodology, there are a variety of types of functional tests. The most common types of functional testing are:

- Sanity Testing
- Smoke Testing
- Integration Testing
- System Testing
- Component Testing
- Unit Testing
- User Acceptance Testing

**Sanity Testing** is performed whenever your software gets updated with new bug fixes and changes. It verifies all of the newly introduced functionalities, making sure they work as intended. Most often, sanity testing is considered as a type of regression testing, and many programmers get it confused with smoke testing – let’s see why.

**Smoke Testing** is very similar to sanity testing, but there is a definitive difference. Smoke testing is performed on initial builds of the software, verifying that basic functionality works. This type of testing isn’t exhaustive – and it isn’t supposed to be. It aims to go over only the most fundamental components of your software. 

**Integration Testing** gives you the ability to confirm whether individual functionalities and components of your software perform well together. It is performed after all of the individual modules have been confirmed to work without flaws and is one of the most popular types of functional testing. Integration testing can be easily automated, and often is, making it a simple step in the QA process.

Once you are sure that all functionalities operate fine individually and when integrated together, it’s time for **System Testing**. System testing is performed not to confirm whether something works, but whether your software complies with specific requirements. These are most often requirements given to you by your client, and system testing gives you the ability to easily measure how well you have achieved what your client wanted of you.

**Component Testing** is performed before integration testing to verify the individual performance of every component of your software. Keep in mind that these components aren’t simply consisting of a single functionality. For example, a component test for the login component of a website might include testing the visibility of the UI, page loading, SQL performance, and end-user experience.Finally, **Unit Testing** is a very thorough test that directly examines the code of your software’s components to make sure it is doing exactly what it is supposed to do. Unit testing can provide valuable documentation of your code development as you progress with the software’s production, which can be extremely useful to communicate between teams and speed up the work. Without unit testing, failed tests can be much harder to explain, and finding error sources will take much more time.

## Conclusion – how to understand Functional Testing?

Since there are so many types of functional testing tests, it’s impossible to provide an example that would fit all of them. Instead, we want to demonstrate to you first a simple functional testing framework. In its simplest form, functional testing can be said to have three steps.

1. Prepare input values and categorize them into test cases
2. Verify your test cases
3. Compare the results to the software requirements and expected results

However, functional tests can have varying degrees of complexity. Let’s consider the example of a login functionality test. Unit testing would require dozens of test cases and many scenarios, including every part of the login process. In turn, a simple smoke test would require much fewer cases, only verifying the functionalities critical for the end-user to log in.

As you can see, functional testing is a fascinating and very comprehensive subject, with many software testing types that will surely be useful to any software developer. With proper testing practices, your software can achieve better quality much faster, fostering communication and cooperation between different teams working on the same project.

large_functional-testing.jpg

medium_functional-testing.jpg

small_functional-testing.jpg

thumbnail_functional-testing.jpg

functional-testing.jpg

What is Functional Testing? Types and examples.

what-is-functional-testing-types-and-examples

Before you release your product into the market, it is extremely important to properly test whether it’s functioning as intended. To do that, software developers utilize a variety of testing techniques that verify the software’s integrity. The IT industry makes use of dozens of various test suites – there are over 40 different testing methods, counting only the most popular ones! To thoroughly check their software, developers implement **End-to-End testing**, often simply called **E2E** testing – an elaborate technique that mimics end-user experience. 

There are many layers to End to End testing, as it is one of the most complex testing methods, requiring you to check every part of your software that the end-user interacts with in any imaginable way. 

With this guide, we want to show you the importance of E2E tests, as well as tell you precisely what they are, including a few specific examples.

[TABLE_OF_CONTENTS]

## What exactly is End-to-End testing?

**End-to-End testing** is one of the most useful and informative techniques for software testing, providing valuable data about the inner workings of the program from the end-user perspective. With E2E testing, developers can thoroughly verify the behavior of their software. During the test, you will be trying to replicate key user behavior scenarios when using your software. The actual list of things to do varies, depending on the type of software you’re testing – but in all cases, it is rather extensive.

When performing a software testing method, like an End-to-End test on a web application, you would start with opening your browser and navigating to the proper URL, and then proceeding to use the software as intended for the end-user.

Similarly, in the case of a regular desktop application or mobile application, you would open the app just like a user would, checking out every bit of functionality that is intended for the users to work with. Keep in mind that during E2E testing you won’t need to check developer-specific aspects of the software, only the end-user perspective if it is important to you.

During an E2E test, your goal is to verify all of the dependencies and data integrity that directly or indirectly influence the reception of the software by the end-user. This usually includes any external services, as well as databases used by the software and metrics, as well as any other system dependencies. E2E tests will ideally be performed in the production environment, but this isn’t always possible. The tests can, of course, be performed in an independent End-to-End testing environment, but you should make sure it is as close to the production environment as possible.

Within the SDLC process, E2E tests are performed in the Testing phase, which is situated after Coding and before Deployment. 

## Why is End-to-End testing so useful?

Is End-to-End testing necessary? It is true that more and more developers make sure to implement an E2E testing phase before the final deployment of their software. There are many benefits to E2E tests, but the most crucial ones are:

- The ability to verify software performance from the end-user perspective
- Testing not only the software itself but also any interrelated sub systems, increasing test coverage
- Validation of back-end systems
- Immediate end-user-like feedback on test failing

While tests such as unit testing or integration testing are very useful, allowing you to verify the working of each component and providing quick results, they don’t give you the whole picture. By not performing E2E tests, you won’t know how the experience of using your software will look like from the end-user perspective.

For example, individual component testing (integration tests) might show promising results and full functionality. However, when combined, something goes wrong and produces a bug. By only checking individual components, you wouldn’t be able to find out about the bug. With a proper End-to-End test, you can verify whether everything works correctly together as it should. Even integration testing doesn’t cover all of the system components of your software, and you might never know whether every aspect of your app clicks together.

E2E testing doesn’t necessarily have to discover bugs – it can also give you useful insight into the user scenario of your product. Overall, all types of tests play their respective roles in the whole testing process. Just because E2E tests give you a more complex understanding of your software as a whole doesn’t mean that other test types are less valuable. Before releasing your app, always make sure to proceed with a thought-through testing strategy. However, while they’re certainly extremely useful, keep in mind that E2E tests occupy the top of the testing pyramid, making them the most expensive and most difficult to perform.

End-to-End testing is also one of the few functional types of tests that can be performed manually, as well as automated - which is done especially often in Continuous Integration. In such a scenario, a chosen set of tests can be run automatically each time a new iteration is uploaded to the testing server.

## End-to-End Testing Framework

Alright, so now you know what End-to-End testing is – but how to exactly implement it? There is a wide variety of checks and individual tests that must be covered by your end-to-end testing plan, some of which include:

- Establishing test requirements in the preparation phase (including software and hardware requirements)
- Creating proper documentation
- Deciding what type of test environment will be used (production environment or independent test environment)
- Preparation of test cases and general E2E design
- Tracking of data input and output
- Test execution and evaluation

When executing E2E testing methods, developers usually follow an established E2E testing framework that guides you throughout the process, enumerating various tasks and responsibilities. The framework is relatively simple and consists of only three elements:

### Establish user functions

The User Functions relates to listing the features of your software, as well as all of its interconnected software systems. To properly measure and test software functionality, you need to first think about what you’re going to test. After you’re finished with listing user functions, remember to record everything relevant to each of them, including both the input and output data. Since E2E testing can be considered holistic, you also need to pay attention to all of the relations between every individual function – how they work together and whether there are any clashes.

### Come up with specific conditions

Now that you have established the user functions you’re going to test, you need to think about the testing conditions. Try to come up with as many quantifiable indicators that can be measured for each of the functions. These can range from response time to consistency of data flow, to simple convenience of use. Remember – you’re trying to imagine yourself as an end-user, so try to keep track of anything that might be an issue for a non-developer.

### Create individual test cases

Finally, before the E2E testing can commence, you need to prepare specific test cases for each of the conditions. At this point, you have prepared a list of user functions to test, as well as data conditions that will be measured during the test. Now, you need to create at least one test case for each of the conditions. By test cases, we mean user scenarios during which specific indicators will be able to be measured. 

And by test case preparation status, we mean the precise location of the test instances being developed, as compared to intended test cases.

## Examples of E2E tests

Congratulations, you’ve almost reached the end! At this point, you should pretty much be a walking fountain of knowledge about End-to-End tests. However, the raw theory is one thing, and implementing those types of tests for system testing in reality is another. To make the process a bit more digestible, consider this End-to-End testing example for a website with shopping functionality:

- Go to the specified URL
- Open a list of products
- Check whether the information on the list correlates with specific product pages
- Try to add the product to the cart and look for visible confirmation
- Navigate to the cart and check whether the product has been successfully added
- Double-check all of the relevant information (price, product info, etc.)
- Proceed with the check-out and verify payment options integration

See how simple it is in the end? Now you can implement E2E testing methodology in your software to ensure better end-user reception, increase your product quality, and build a positive brand image.

## Frequently Asked Questions

1. **What is automated testing?** \
Automated testing in software development is a form of software testing that uses the execution of predefined sets of operations to probe and validate the software system. The fundamental purpose of test automation in software development is to generate objective feedback about the quality of the product. One such tool is Selenium. It can run UI tests.
The ideal situation is to run E2E tests with both manual testing and automated testing approaches. If your application has a lot of complicated user interfaces, you'll need more end-to-end testing.

2. **What is software development lifecycle?** \
Software development lifecycle (SDLC) is the process used by developers to create, deploy and maintain software. This process includes several steps that are all closely connected with one another. These steps include requirements gathering, analysis and design, coding and testing.

3. **What is a testing pyramid?** \
In software development projects, we have limited time and resources. This is why it's important to consider our test efforts carefully and find the right balance between different types of testing.
Basically, there are 3 layers in the testing pyramid: Unit Tests, Integration Tests,  and E2E Tests.


large_testowanie-end-to-end.png

medium_testowanie-end-to-end.png

small_testowanie-end-to-end.png

thumbnail_testowanie-end-to-end.png

testowanie-end-to-end.png

What is End-to-End (E2E) testing?

what-is-end-to-end-testing

**Nowadays, the profession of a software tester has become a symbol of entering the IT world without elbow grease. Why can some people pull it off and some cannot? Is there a golden rule for securing a job as a tester? Let’s find out.**

A good software tester has not only undergone special training crowned by a respective diploma. If you want to do this job successfully, you will appreciate natural predispositions and skills that you can acquire single-handedly. You may wonder if pure skills will suffice. Well, it depends …

## Who can work as a software tester?

Speaking in most general terms: anyone. There are no age or “trade” limitations; for many people who want to branch out the profession of a tester marks the first step in a career in IT. Many candidates fall prey to a stereotype, thinking that this is a simple, easy and pleasant profession that anyone can practise. Here come the details that you need to be aware of if you are  contemplating the job of a tester. As it is the case with other professions, some predispositions are also welcome, not only personality-related. These predispositions include:

### Analytical thinking 
A good tester needs to be able to combine facts, view an application and its possible uses in the context of its product environment and to draw conclusions;

### Inquisitiveness


When, surfing the Internet, you ask questions like “why does it work this way?”, “I wonder why they used this solution”, you are on the right path. Even if people around you sometimes find your inquisitiveness irritating,  it will prove priceless in a tester’s work;

### Resilience to boredom

It comes in handy especially at the beginning of work as a manual tester, when you check how an application works and simply “click your way” through some software an unlimited number of times. A certain degree of repeatability is an inherent part of a tester’s job; 

### Openness to people 

Another stereotype worth debunking before stepping onto the path of software testing is an introvert hiding in his cubbyhole, a dead ringer of  a character from “IT Crowd”, avoiding people at all cost. The situation is quite the opposite! Yes, you spend some time on the testing itself but you need to communicate the results of your work to a developer, a project manager or an entire team. Sometimes you need to explain what is not working. Sometimes you need to ask why something is working the way it is ☺   This is not a job for people who would rather have their arm chopped off than talk to someone on the team.

### Creativity

It will come in handy on a higher level of advancement when you are responsible for creating testing scenarios. In some companies, testers cooperate closely with the entire project team and contribute to developing the assumptions behind a product which provides plenty of room for creativity.

The stereotype of a software tester has one “benefit”: people think that testers do not need to know programming. Yes and no – it all depends on your aspirations. 

## Do you want to be a manual tester?

At this stage,  you are typically in charge of “clicking your way” through an application and reporting possible errors. After several or over a dozen months of working as a tester you can also start to write scenarios and test cases. At this stage, in order to acquire new skills, you can also learn to make use of automation tools  or tools supporting manual testers. However, if you do not want to grow or learn the basis of a programming language – you hit the wall.   The same holds true for financial promotion – among testers, the manual ones are at the bottom of the pay brackets. 

## Do you want to be an automatic tester?

Knowing the basis of programming is imperative because in this job you write your own test-automatizing scripts and you fix possible operating errors. All the time, you supervise also the programmes’ operations and you enhance them, for example with new requirements that occurred in the process of creating a product. There is a reason why burnt-out developers or people who want to have a break in programming are good candidates for automatic testers. If you are literate in even one programming language (of course the more the better) you are good to go.

## How to start working as a programming tester

Ok, let’s assume that you remain firm in your decision to become a tester. You have all the predispositions and you want to grow in IT. Where do you start? Regular broadening of your horizons and self-learning are a must; it does not matter whether you  already know the job or are contemplating it. The Internet is a mine of knowledge; we recommend publications both in Polish and English  (there are many more materials in English). If you know some basis, you can apply right away for a manual testing internship programme. Junior positions are also within your reach – they are particularly attractive to people who branch out and cannot afford an unpaid or poorly paid internship. At the same time, you can try to take on single jobs on platforms like uTest – they will ensure an inflow of cash as well as experience, so valuable at the dawn of a professional career.

Read also: A manual tester: 10 reasons that make this job interesting

## Working as a software tester – with or without training?

As working in IT has become fashionable, training companies are flourishing. They offer not only trainings for developers but also testers. On the one hand, this is an interesting and developing option because a course poses an opportunity to acquire knowledge in a user-friendly way.  This is also a guarantee of regularity in learning which is of importance to less systematic people or ones having difficulties with self-motivation. On the other hand, a training is usually costly. Before you choose the school, take a good look of the market because some participants complain about the small number of practical classes and poor care on the part of the mentors. Whether you decide to embark on a  course or not, it is a good idea to find a mentor: a person who already works as a tester and who may lend a guiding hand in your search, recommend literature on the subject  or give you feedback on your work. Last but not least: even if you have the best teachers/mentors, without your determination and own work they will not be of great help. Acquisition of testing skills is, first and foremost,  a considerable effort and ensures regular enrichment of knowledge – a lot depends on you and your commitment.

## How to be an IT tester with a certificate

The schools mentioned here frequently offer their own diplomas but the market honours certificates issued by the International Software Testing Qualifications Board (ISTQB). While you can obtain certificates at any stage of professional development, a document on the basic level should be the first step to becoming a Certified Tester. If you are new to the industry, this item on your CV is bound to be welcome. On the other hand, some people are critical about the certificates and say that all you need to know as a tester can be learnt single-handedly.

## How to be a tester and earn real money 

This is a very important issue; after all, the time of poorly paid internship must come to an end. Big companies typically have a natural development and promotion path that you may follow after having worked for some time as an intern or an IT junior. However, continued development is key to promotion – if you are contemplating the position of an automatic tester, do not put off learning  programming. The more you know about testing and the industry the better your chances of becoming a QA (quality assurance) team member. It stands for a tester with considerable experience who is in charge of entire projects, also related to people management, writing testing scenarios, writing automatic tests and monitoring work within a project. Irrespective of the position you assume, when you work in IT you should know the methods of project management while words like “agile” and “waterfall” should definitely ring the bell. 

large_jak-zostac-testerem.png

medium_jak-zostac-testerem.png

small_jak-zostac-testerem.png

thumbnail_jak-zostac-testerem.png

jak-zostac-testerem.png

How you can become a software tester

how-you-can-become-a-software-tester

Blog about test automation

Features

Pricing

Case studies

Privacy policy

Terms of service

About us

Book a demo

Contact

Get more tips and product related content. Zero spam.

Don't miss any updates

End-to-end testing made simple! BugBug is a new, more intuitive tool for test automation of web apps. Get all the benefits of test automation without hiring new people or infrastructure changes.

BugBug.io | Intuitive and reliable test automation for startups

large_Open Graph 1200x630 3.png

medium_Open Graph 1200x630 3.png

small_Open Graph 1200x630 3.png

thumbnail_Open Graph 1200x630 3.png

Open Graph 1200x630 3.png

Updates

Product

Testing can be difficult, it is hard to master, there are many questions and many issues we can face with each new feature, each new story. Every day, testers need to decide what to test, how to test, what to automate, and what risks to accept. These decisions are hard and require a lot of experience. Fortunately, there are techniques, heuristics, and models which can help with planning tests. One of the oldest and still very useful techniques is **Agile Testing Quadrants** (**ATQ**). it is a simple table that helps us select the tools we need to use, depending on the required outcome. In this article, we will look into the history of Agile Testing Quadrants, their uses, and limitations. We will also discuss the attempts at modernizing it.

![Agile-Testing-Quadrants](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Agile_Testing_Quadrants_4b2d044860.png)

[TABLE_OF_CONTENTS]


## Agile Testing Quadrants or Agile Testing Matrix?

First, we need to clear one thing: as with everything in IT, even this simple table needs to have many names! Chances are that you will come across it as an Agile Matrix, Testing Matrix, Testing Quadrants, or Agile quadrants. All of them refer to the same thing. The only exception is the Agile Testing Matrix which may refer to both Agile Testing Quadrants and its precursor the Named Agile Testing Matrix. 

![Testing matrix](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/test_matrix_00ac277513.jpg)


## The Story of Matrix

When speaking about **Testing in Agile**, there is probably not a single more important person to its development than [Lisa Crispin](https://lisacrispin.com/) and [Janet Gregory](https://janetgregory.ca/). Their book, [Agile Testing](https://www.goodreads.com/book/show/5341009-agile-testing), has helped many testers. [Testing Pyramid ](https://bugbug.io/blog/software-testing/testing-pyramid-a-successful-approach-to-test-automation/) was born while [Mike Cohn](https://twitter.com/mikewcohn) tried to explain the nuances of automation to Lisa’s team (*Experience of Test Automation - chapter 1 Section 1.3.*) Agile Testing Book played a key role in the popularization of Agile Testing Quadrants, where the creation of ATQ is often misattributed to this wonderful duo. As Lisa Crispin explained in [her blog](https://lisacrispin.com/2011/11/08/using-the-agile-testing-quadrants/) - they improved on the older concept by [Brian Marick](http://www.exampler.com/old-blog/2003/08/22/#agile-testing-project-2) - an Agile Testing Matrix created as part of his blog series presenting his vision of testing in Agile. So Agile Testing Quadrants have almost 20- year-long history and they are still one of the best models used for testing.

## The Usefulness of Agile Testing Quadrants

Agile Testing Quadrants have two axes which split the matrix into 4 quadrants. Both axes pose the same questions, namely **What is the goal of your testing?** The major difference between the two axes is the flavor of the question: the horizontal axis asks what is currently more important: helping the team to deliver faster or ensuring that the product is as good as possible? the vertical axis asks if we are concentrating on the aspects of technology, ensuring that everything is working well, or are we looking from the perspective of business and customers, making sure that our program is worth using? Obtaining both answers points to one of the Quadrants with a list of useful examples. This can be a little confusing, so let’s look at some of the examples.

### Example 1: E-commerce shop

Let’s say we have e-commerce shop development that is going nicely. However, there is one enormous risk on the horizon, namely quite a lot of features, each tested separately so no one is sure how they will work in the real world. The team believes that the standard paths will work. However, no one is sure what kind of edge cases will come from the real world.

Looking at our matrix we can see that problem is definitely business-facing - we don’t know what the user will do. We also need to make sure that our product will handle it, ergo - Critique Product.
Looking at it we land in Q3  where we have propositions of the following techniques:
 - Exploratory Testing
 - Scenarios
 - Usability Testing
 - User Acceptance Testing (UAT)
 - Alpha/Beta Testing.

So our goal is to find edge cases. Looking at the list, all the techniques could prove helpful. But some may require too much investment so late in the developments (Scenarios). Some are a poor fit for an e-commerce shop (alpha/beta testing, UAT). Which leaves us with Usability Testing and Exploratory testing.
ATQ is not an extensive matrix, it contains only examples of techniques rather than a complete list. For example, a different technique that could help is [Dogfooding](https://en.wikipedia.org/wiki/Eating_your_own_dog_food) where company employees themselves use a product to satisfy their everyday needs.

### Example 2: Messaging App

A company has made a very successful messaging app, but now they are facing the problem of success. Their small app, designed for a small community, is gaining popularity fast. The team feels that the app is not ready for all this attention. The situation is clear - from a business perspective, everything works well enough. The risk is technology, and again the problem lies in the critique of a product. This leads us to Q4 where we have, among others, *Performance* and *Security* testing. There is no doubt that we will need both. Lots of users mean a load on an application and nothing will kill its momentum like failing servers. Security is also important. Attention also attracts bad actors who will try to exploit the system.

### Example 3: Early Development.

The team suffers a problem of poor quality code. In the case of some features, developers are reluctant to fix a familiar bug because of the high risk of breaking something else. One glance at the ATQ shows that we need something to support the development and its technology which leads us straight to Q1. Both Unit Test and Component Test would improve team productivity and code quality.

The above example may give a wrong impression that Agile Testing Quadrants are used to select one and only one tool. **THIS IS NOT TRUE**: we can use ATQ for each goal of our testing, for each need, for each problem we are trying to address. However, trying to improve too much at once may lead to too much-wasted effort and no result. Concentrate on one subject at a time.

## Evolution

While the concept of AQT has changed little over the years, the techniques in each quadrant have evolved, for example: 

![Updated Agile Testing Quadrants](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/updated_atq_06346e83b7.jpg)

In [More Agile Testing](https://www.informit.com/articles/article.aspx?p=2253544), the author presented a new version with Micheal Hüttermann changes, with a circle of *Outside-in, Barrier-free, Collaborative in the middle of the quadrants*. The author believes that it will stretch beyond any quadrants. The main issue with this update is that it is a catchphrase and provides no information about the tools and techniques that may help.

![Agile Testing Quadrants next iteration](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Agile_Testing_Quadrants_next_d74569f53c.jpg)

A few years back, [Lisa and Janet](https://agiletester.ca/applying-the-agile-testing-quadrants-to-continuous-delivery-and-devops-culture-part-1-working-towards-continuous-delivery/) also presented a version more in line with DevOps. This version adds a lot more techniques to each of the quadrants but also changes one side, from *Supporting Team to Guide Development*. While it may seem like a single name change, fortunately, the original name leads to many misunderstandings and the new label is much more descriptive. 

![RST Agile Testing Ecosystem 1.1](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/bb_ATQ_1fb44a3b67.png)


Michael Bolton and James Bach have also made the [above version](https://www.slideshare.net/HcmcStc/the-new-agile-testing-quadrants-bringing-skilled-testers-and-developers-together-james-bach) which is compatible with Rapide Software Testing. Most of these updates are only fine-tuning, adding elements that their author thinks are better in this context. So which one to choose? It is the author’s opinion that the original version holds well? It is still relevant, because:

## It is just a model.

“All models are wrong, but some are useful” is an old aphorism attributed to George Box. And it is important to bear it in mind in the case of Test Pyramid, Agile Testing Quadrants, etc. Models are what they are: models which need to help us think about a problem. **They are not the golden rules that should be followed in the letter**. They provide us with a good way of tackling the problem. But it is up to the user to decide if a specific model will work for a specific problem.

## Summary

The **Agile Testing Quadrant** is a model which is nearly 20 years old. Owing to its simplicity, it is still relevant. It is a great tool for teams and testers who have a problem with choosing the right testing method. For junior testers, it is a great place to look into different tools and approaches, and for more advanced testers it will be an excellent aid in building or improving the testing process.

large_beetle-g2d0bd3bb5_1280.jpg

medium_beetle-g2d0bd3bb5_1280.jpg

small_beetle-g2d0bd3bb5_1280.jpg

thumbnail_beetle-g2d0bd3bb5_1280.jpg

beetle-g2d0bd3bb5_1280.jpg

Agile Testing Quadrants

agile-testing-quadrants

A self-taught software QA Engineer working at an IT start-up, Dominika has experience in
web testing. Currently, she is focusing on developing her test automation skills with Python.
Apart from programming, she likes to make pottery and cook vegetarian delicacies.\

[linkedin.com/in/dominika-nykiel](https://linkedin.com/in/dominika-nykiel){rel="nofollow"}

medium_https://media-exp1.licdn.com/dms/image/C5603AQH6NBuKQg3UWw/profile-displayphoto-shrink_800_800/0/1637439945009?e=1646265600&v=beta&t=IwBmGAWmNdXvprRNzsLB-PbwuPFXBTKFfTLP612yEuA

small_https://media-exp1.licdn.com/dms/image/C5603AQH6NBuKQg3UWw/profile-displayphoto-shrink_800_800/0/1637439945009?e=1646265600&v=beta&t=IwBmGAWmNdXvprRNzsLB-PbwuPFXBTKFfTLP612yEuA

thumbnail_https://media-exp1.licdn.com/dms/image/C5603AQH6NBuKQg3UWw/profile-displayphoto-shrink_800_800/0/1637439945009?e=1646265600&v=beta&t=IwBmGAWmNdXvprRNzsLB-PbwuPFXBTKFfTLP612yEuA

https://media-exp1.licdn.com/dms/image/C5603AQH6NBuKQg3UWw/profile-displayphoto-shrink_800_800/0/1637439945009?e=1646265600&v=beta&t=IwBmGAWmNdXvprRNzsLB-PbwuPFXBTKFfTLP612yEuA

Dominika Nykiel

An aspiring technical writer with an interest in testing and a knack for learning languages.
Former journalist, translator, and editor, whose work was published in several magazines. She
speaks French and Norwegian and is looking forward to learning Spanish.\

[linkedin.com/in/aleksandra-spilkowska](https://linkedin.com/in/aleksandra-spilkowska){rel="nofollow"}

large_a_spilkowska_cropped.jpg

medium_a_spilkowska_cropped.jpg

small_a_spilkowska_cropped.jpg

thumbnail_a_spilkowska_cropped.jpg

a_spilkowska_cropped.jpg

Aleksandra Spilkowska

Ask any QA Engineer worth their salt about their Chrome extensions - they probably have a bunch of them ready to go at all times. And for a good reason! They can come in handy when you need to edit a screenshot, clear a browser cache, or test a website’s performance. Saving some clicks and double-checking for hidden issues means that a QA’s everyday life is much easier, and it leaves more time to focus on spotting all the bugs before the final product is released. Get ready to pimp your browser with some of the most useful Chrome extensions for testers!

[TABLE_OF_CONTENTS]

## [Monosnap](https://chrome.google.com/webstore/detail/monosnap/lhgadannddhdpkfhfjjgcpdjhpmjhkfm){rel="nofollow"}

![Monosnap](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/monosnap_a19cbb03a1.png)

A reliable recorder is a must-have in your virtual toolbelt. While most recorders are programs, Monosnap is an extension so there are extra advantages, especially if you tend to switch between devices a lot. You can capture a GIF or a video, a selected area of the screen, and of course a fullscreen. There is also a set of basic editing features such as drawing, creating marks, highlighting details, or hiding sensitive data. No watermark in sight! Monosnap works with both Windows and iOS.

## [Clear cache](https://chrome.google.com/webstore/detail/clear-cache/cppjkneekbjaeellbfkmgnhonkkjfpdn?hl=en){rel="nofollow"}

![Clear Cache](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/clearcache_ec20bd645f.png)

It does just what the name promises: clears your cache and browsing data. What's the catch? There isn't any! You can do it all with a single click. This extension allows you to choose how much data you want to clear and from which domains you want the cookies removed. Neat!

## [Bug Magnet](https://chrome.google.com/webstore/detail/bug-magnet/efhedldbjahpgjcneebmbolkalbhckfi){rel="nofollow"}

![Bug Magnet](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/bugmagnet_115b949485.png)

For many, this is a go-to extension for exploratory testing. Will it do all the work for you? Unfortunately, the answer is no, but it sure helps a lot. This exploratory testing assistant will offer you access to common boundaries and edge cases. It works on input fields, text areas, content editable DIVs, and more. This means that you don’t need to rack your brain to think of an email, postcode, or address anymore, Following selection of the value, Bug Magnet fills in the field you need. It’s an open-source solution and you can customize it to your liking.

## [PerfectPixel](https://chrome.google.com/webstore/detail/perfectpixel-by-welldonec/dkaagdgjmgdmbnecmcefdhjekcoceebi){rel="nofollow"}

![Perfect Pixel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/perfectpixel_6d7ba283bd.png)

This extension is very convenient for frontend testing, especially when there is a need to compare a website design with frontend changes. It adds a semi-transparent overlay over the top of the developed HTML to make it perfect - down to the last pixel. The position, size, and opacity level are no longer your enemies with this handy extension.

## [Web Developer](https://chrome.google.com/webstore/detail/web-developer/bfbameneiokkgbdmiekhjnmfkcnldhhm){rel="nofollow"}

![WebDeveloper](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/webdeveloper_827b9ef3f7.png)

The Swiss Army knife of web developing tools, this extension will equip your browser with a toolbar full of functional items. Cookies? Managed. Information? Anchored. Web elements? Highlighted. CSS? Edited. Forms? Populated. Of course, some tools work better than others, and you aren’t going to use all of them equally, just like with a real Swiss Army knife (fish scaler, anyone?) but it’s still a quite useful quality multitool.

## [Lighthouse](https://chrome.google.com/webstore/detail/lighthouse/blipmdconlkpinefehnmjammfjpmpbjk?hl=en){rel="nofollow"}

![LightHouse](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/lighthouse_f51d97d7ce.png)

Yet another multi-use extension, it runs overall non-functional tests on websites. The metrics you can audit are performance, SEO, best practices, accessibility, PWA (Progressive Web Application). Lighthouse auto-generates a clear, simple report which lets you know how well your website performs for an average user. The audit will instantly highlight the areas that need improvement and will give you a general overview of the website’s functionality.  

## [Postman Interceptor](https://chrome.google.com/webstore/detail/postman-interceptor/aicmkgpgakddgnaphhhpliifpcfhicfo?hl=en){rel="nofollow"}

![Postman Interceptor](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/postman_interceptor_a0d0b62ce1.png)

Assuming you have heard of Postman (if you haven’t, [go check it out now](https://www.postman.com/){rel="nofollow"}!), you might be interested in further improving the workload with this practical extension. The Interceptor sends requests which use browser cookies to the Postman app without using a proxy. This is an advantage for testing APIs, as Interceptor makes it possible to send headers (typically restricted by Chrome).

## [SelectorsHub](https://chrome.google.com/webstore/detail/selectorshub-xpath-plugin/ndgimibanhlabgdgjcpbbndiehljcpfh){rel="nofollow"}

![SelectorsHub](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/selectors_hub_624439475b.png)

Whether you’re a seasoned tester or just starting your journey, this extension can be a worthy addition to your collection. SelectorsHub is easily the top-rated XPath & cssSelector plugin available now, and it lives up to the hype. It helps write and verify XPath and cssSelector in less than 5 seconds, auto-suggests attributes, text, etc. SelectorsHub not only supports the iframe and the SVG elements, it is also the only extension supporting shadowDOM (at least for now). And if you value a proper error message, you’ll get one for missing elements in the selectors. This impressive extension is indispensable not just in test automation but also to users of codeless, smart testing tools.

## Summary

That’s it! We hope you have enjoyed our pick. Of course, this list is in no way comprehensive, as new extensions are added to the Chrome web store all the time. While the choice might initially seem overwhelming, it is highly recommended to checkout various extensions and find the ones that suit your needs best. Hopefully, this article will be a good starting point for these explorations!


large_leaf-gfcaac0297_1280.jpg

medium_leaf-gfcaac0297_1280.jpg

small_leaf-gfcaac0297_1280.jpg

thumbnail_leaf-gfcaac0297_1280.jpg

leaf-gfcaac0297_1280.jpg

Best Chrome Extensions for Software Testers

best-chrome-extensions-for-software-testers

Professional Quality Evangelist, experienced in testing web and mobile applications.\

[linkedin.com/in/kinga-witko-b5bba659/](https://www.linkedin.com/in/kinga-witko-b5bba659/){ref="nofollow"}

thumbnail_https://pbs.twimg.com/profile_images/1410220490434744328/eqEl_DXL_400x400.jpg

https://pbs.twimg.com/profile_images/1410220490434744328/eqEl_DXL_400x400.jpg

Kinga Witko

As recent data show (https://gs.statcounter.com/browser-market-share), Chrome is the most used browser in the world, representing over 64% of the browser market.

The Chrome Developer Tools (DevTools for short) are a set of web authoring and debugging tools built into Google Chrome. The DevTools provide web developers with improved access to the internals of the browser and their web application. Did you know that they are quite useful for the Testers as well?

[TABLE_OF_CONTENTS]

## Give it a try in testing the web

There are multiple functions in which Dev Tools may support your testing, not only limited to:
- resizing (change user agents)
- screen rotation
- using Console: Debug JS – CSS, Logs
- network manipulation: Throttling, Performance
- security testing
- location change
- looking for elements (id)
- taking screenshots
- clearing cache
- test recording
- database checking (IndexedDB  - a transactional database system, like the SQL-based RDBMS)

## How to enter?
To open the developer console in Google Chrome, open the Chrome Menu in the upper-right-hand corner of the browser window and select **More Tools > Developer Tools**. 

![https://i.imgur.com/fIMFZgz.png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/f_IMF_Zgz_bea99d61c0.png)

You can also take shortcuts:

**On Mac:** \
Command+Option+I 

**On Windows/Linux:** \
F12 or Control+Shift+ I


You can dock your DevTools window to the right of your viewport or at the bottom of the screen, depending on your preferences. By default, DevTools are docked to the right of your viewport. You can also dock to bottom, dock to left, or undock to DevTools to a separate bottom.

![https://i.imgur.com/13JgWaO.png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/13_Jg_Wa_O_2e4ec2b59e.png)

It is possible to reorder the panels so they suit your needs best. Click and drag a panel tab to change its ordering. Your custom tab order persists across the DevTools sessions.


## How to start
Chrome DevTools can be used in web and mobile testing. Every Tester should take advantage of it because these tools are free and easily accessible. 
Here is a list of the most useful ideas for testing purposes. Maybe you'll come up with new ones?

### Resizing and Rotating
It is important to check the UI of your website on mobile browsers and multiple screen resolutions. For some people, it’s “Just the UI” testing but do remember that nowadays a lion’s share of the market (54.37%) belongs to mobile browsers ([stats here](https://gs.statcounter.com/platform-market-share/desktop-mobile-tablet)).

![Browser market stats](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/image7_6614995465.png)

Use the **Responsive** option in Chrome DevTools to make sure that a majority of different screen resolutions is covered.

You can select the desired resolution from the dropdown list of many different mobile devices to test against different screen sizes. DevTools tell us the screen dimensions of the device in the top menu as well. What is more, you are also able to rotate the screen. Screen rotation is a common cause of mobile bugs, as the mobile website layout changes when the screen is rotated, and page elements may need to reload. While it won't pretend to be the real device, it will give you a lot of hints on what other tests should be performed on your application.

![DevTools resizing and rotating](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/image6_02544f7f6a.png)

### Console - debug

Either a developer or a tester can debug a website on a mobile device.
In the JavaScript **Console** you can find all ranges of errors in the application.
As the complexity of JavaScript applications increases, developers need powerful debugging tools to help quickly discover the cause of an issue and fix it efficiently. The Chrome DevTools include several useful tools to make debugging JavaScript less painful.

![DevTools console](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/image9_aee0e7d98e.png)

### Network and Throttling
The **Network** option allows you to observe the order and time of loading elements. You are provided with insights into resources that are requested and downloaded over the network in real-time. It is of special importance in mobile testing as users expect mobile apps to work smoothly and fast.
1. Open DevTools (F12)
2. Click the ‘Network’ tab
3. Click the No Throttling dropdown
4. Select the type of connection you want to imitate
5. Reload the page to see the assets downloading at that connection speed.

The Network tab in Chrome DevTools has an option to faux throttle your network, so you can experience what your users might see visiting your website on 3G, Offline, or with your real speed connection. The **Throttling** option is also useful for visualizing how fonts are loaded. The lower the speed, the more end-user frustration on your website.

In this section, in the left upper corner, there is also a record button that allows you to preserve all the activities (logs) and compare them with other test results.

![DevTools network throttling](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/image8_9e4f1f589f.png)

### Elements
The Elements panel allows you to see everything in one DOM tree and fosters inspection and on-the-fly editing of DOM elements. It is also a useful option for automating tests.
You can always access this option for a specific element on the website:
1. Mouse-over the element (word, button, etc.)
2. Right-click on the mouse
3. Click Inspect

![DevTools Elements](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/image12_3c7cc49608.png)

In the Chrome DevTools panel, you’ll be directed to the very element in the DOM structure.
The **Elements** tab is extremely useful if you need to play around with CSS in your application. Sometimes you need to switch on and off some buttons/lists/checkboxes. It is possible in this section to select the desired elements in the DOM structure and edit them in the Styles sub-section. 

There is also a handy way of locating a node element in the DOM using a CSS selector. From the elements panel, use a keyboard shortcut (win: Ctrl+f, mac: Cmd+f) to open up the search input UI. Enter a CSS selector into the search input UI.

### Clear Site Data
Cache clearing is one of the activities that might be used daily in the testing exercise. Chrome DevTools can successfully help you out.
Press Control+Shift+P or Command+Shift+P (Mac) to open the Command Menu and then run the Clear Site Data command to clear all data related to the page, including Service workers, localStorage, sessionStorage, IndexedDB, Web SQL, Cookies, Cache, and Application Cache.
If you don't want to delete all site data, you can control what data are deleted from **Application >  Storage**.

![DevTools application storage](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/image10_3278490be8.png)

### Location
This is a fantastic functionality! It shows how to test an app that must work in different locations and presents a map for you - teleportation has not been invented yet! There is an option in DevTools that allows you to mimic location. The option is slightly hidden:
1. Open Dev Tools
2. Click the action bar in the top right corner of the screen
3. Select More Tools
4. Click Sensors

Now you can provide a website/application with your desired geo-coordinates and pretend you are there. Remember about reloading the page with every change to the coordinates.

![DevTools location](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/image11_d0b495da83.png)

### Performance monitor

In the same **More Tools** panel you can find the Performance Monitor. Use it to get a real-time view of various aspects of a page's load or runtime performance, including:
- CPU usage.
- JavaScript heap size.
- The total number of DOM nodes, JavaScript event listeners, documents, and frames on the page.
- Layouts and style recalculations per second.

There is also a separated **Performance** tab in the upper menu, which shows the Compute Intersections in the flame chart. These options can help you to identify the events and debug on its potential performance overheads.

![DevTools Performance](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/image13_7323c216c2.png)

### Screenshots
There are two ways of taking screenshots when working with DevTools:

**Screenshots of a portion of the viewport**

1. Click **Inspect** or press Command+Shift+C (Mac) or Control+Shift+C (Windows, Linux) to enter Inspect Element Mode.
2. Hold Command (Mac) or Control (Windows, Linux) and select the portion of the viewport if which you want to take a screenshot.
3. Release the mouse. DevTools downloads a screenshot of the selected portion.

**Screenshots of specific HTML nodes**

1. Select an element in the Elements tab
2. Open the Command menu
3. Start typing node and select Capture node screenshot. DevTools downloads a screenshot of the selected node.

## How to operate on mobile devices?
Last but not least, if you want to test the mobile option, it might be useful to know how to attach your device to Chrome DevTools.

1. Install the Chrome browser on your PC
2. Get hold of an Android smartphone
3. Find a USB cable to connect them
4. Plug your device in.
5. Type chrome://inspect in the Chrome browser.

On mobile devices, you can take advantage of Chrome Developer Tools in a very similar way to web testing. You can perform throttling, look for elements, or check the network connection. What is more, you are also able to check things in a database through Stetho (*debug bridge for Android applications*). 

If it doesn’t work right away - all you need to do is enable the developer options:
1. Open settings
2. Go to System> About phone>Version number
3. Tap on it 7 times (that’s right)

And there you go.
1. Open the developer options
2. Switch them on
3. Allow USB debugging

From now on the device should be visible in Chrome/inspect.
 
There is much more to Chrome DevTools - all you need is to explore the options. Each year, Chrome adds new functionalities to its extensions, including DevTools. The number of options expands and allows not only for better development but also better testing without multiple external tools or applications. For basic functional testing, Chrome DevTools is more than enough. They just require time to learn how to best use them and to benefit from all the resources they offer. 


large_weevil-g22fd4954a_1280.jpg

medium_weevil-g22fd4954a_1280.jpg

small_weevil-g22fd4954a_1280.jpg

thumbnail_weevil-g22fd4954a_1280.jpg

weevil-g22fd4954a_1280.jpg

Chrome DevTools introduction

chrome-dev-tools-introduction

[TABLE_OF_CONTENTS]

## Why Agile?

The word 'agile' became trendy years ago and the eagerness of using it in projects in organizations remains high even today.

We have Agile dev teams and Agile testers, Agile projects. Unfortunately, the term 'agile' has become a convenient replacement for lack of requirements, lack of documentation,  or, just basically,  a pure mess.

On the other hand, Agile means nothing more than a way of working well to reduce the cost of change and uncertainty.

## Traditional vs. Agile

Talking about methodologies is always good as it leads to spotting the difference between traditional - usually phased or gated (Waterfall) ways of making software,

![phased_or_gated](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/phased_or_gated_f4e60a9340.png)

as opposed to iterative, where every story is expanded, coded, and tested with a possible release after each iteration.

![agile.png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/agile_4b0f766f35.png)

## The Agile change

Agile testing influences the whole process of making software, including:
- Whole Team Approach
- Coding and testing as a single process
- Feedback, collaboration
- TDD/ATDD practices
- Test-infected developers
- Better tools
- Better designed tests 

It also allows a tester to be an actual part of the team rather than a siloed unit in an organization. A tester is not a gatekeeper or quality police but he/she provides valuable input into each phase of development.

In real life, it means that an Agile tester takes part in all team meetings, provides the input, asks questions, is invited to pair programming sessions with developers, and takes the same responsibility for the code and product as any other member of the team. Of course, it requires from the Tester a larger skill set, great communications skills, and at least basic knowledge of coding and test automation.

## How to include testing?

There are many ways for extending Test Specialist responsibilities in an Agile team. They don’t necessarily include testing itself but also include a vast range of communication, presentation, and consultation activities.

### TDD
Traditional testing relies on ample documentation. Agile testing is an approach to a process that mimics the principles of agile software development, especially where:
- Testing is done more often,
- The whole team knows how and what to test, it is possible to share tasks
- Testing relies less on documentation and more on team member collaboration.

One of the great examples of how to include testing into an agile process is to start from Test-Driven Development. The TDD methodology is a software development process that emphasizes the need for good software quality. Traditionally, a developer has written the code, and then the testing department has examined it and reported bugs. Moreover, in TDD, it is the developers who write unit tests first before even writing any code that would complete a user story.

Of course, it is possible to pair in every task, so in most situations, it is possible for a developer to work together with a Quality Expert and think of possible test cases.

The tests initially fail until the developer writes a minimal sequencet of code to pass the tests. As the next step, the code is refactored to meet the quality requirements of the team.

It is possible to implement TDD into the Scrum or Kanban type of working. The point is to focus on testing and quality in general. Additionally, it makes testing more agile by moving most of the testing procedures to the early stages of the development lifecycle. When writing test scenarios at the beginning of each story, developers need to understand the requirements and cooperate with the other team members. This minimizes unnecessary code creation and also resolves any doubts at the beginning of the development cycle.

### Automate regression testing
Regression testing is yet another type of software testing to verify if the software, previously developed and tested, still performs correctly after changes or interface with other software. Changes may include software enhancements, patches, configuration changes, etc.

If regression testing in a software project is supposed to make any sense - it has to be performed as often as possible - at least on a sprint basis. Ideally - daily. Why? Because stable test suites would detect any unexpected system behaviors and react to a major change.

Small systems usually have checklists rather than test suites - large ones - even ‘monstrous’.
Deciding what should be automated is always tough because having automated test scripts may not be something that the team could present  to the customer. The question is rather: WHY would you want to automate anything?

The problem is that sometimes, automated suites are not reliable or trustworthy and the effort to keep them alive is quite hard. Test suites have to be regularly maintained and extended. Automation is great for this task but it is just another tool – not the purpose of the project.

Most importantly, even in the Agile environment, all tests need to be reviewed often and prioritized daily.

No one will benefit from extended long-running test suits. What is more, automated regression tests should be efficient and alert early in the development phase, to be of better quality and truly agile.

### Visualize testing activities
One of the great examples of working with a Scrum or Kanban board is to visualize all the tasks in the project, not only the developer’s ones.

It is a great idea for the team to select even small, repetitive manual test tasks as prospects for automation. All these ideas and tasks can be placed on a board and addressed accordingly. It doesn’t mean that a tester is responsible for doing it.

Besides, in cross-functional Agile teams, there is a great opportunity for the testers to learn more coding and test automation, and for the developers to pay more attention to code quality.

### Communicate
Irrespective if a project is handled in Scrum, Kanban, or another Agile manner – the key to success is (?) the communication in the team.

Also, there are useful respective tools which help  teams deliver faster and fight for better quality and efficiency. CI/CD build tools can be easily integrated with common tools for communication such as Slack, and can inform automatically that the build is done or if the build has failed. It can also be helpful in automated regression and getting the test result accessible to everyone.

### Avoid single used solutions
The responsible software development process requires planning and adjusting, not working “here and now” and then fixing production bugs. Single–used solutions in a code, in testing, unnecessary work done in the cutting-corners mode to satisfy the customer’s demands are the things that often  boomerang in the future.

When a manager  approaches you and asks for doing development quickly instead of properly – “because it’s Agile” – remember that this is nothing else but a start of technical debt.

Discuss, propose, think, but when you agree on a shortcut – for example skipping performance testing or postponing some exploratory sessions due to lack of time – be aware of the consequences in the future.

You’ll save some time now, but you’ll be in real trouble soon.

### Explore
As Elisabeth Hendrickson said in her book “Explore it!”:

 “No matter what your job title, you most likely find yourself testing regularly. Testing is an integral part of creating anything.”

This is so true in Agile. Exploratory testing is simultaneously designing and executing tests to learn about the system, and then using your insights from the last experiment to feed the next.

Exploratory testing involves scouting around areas that the net of other forms of testing doesn’t cover. A tester interacts with the implementation, designing, and executing tiny experiments in a rapid succession.

### Give and receive feedback
Every Agile Team uses feedback to improve. It does not matter whether feedback is provided daily or during longer sessions such as Retrospective or Planning. Testers are expert feedback providers, they usually have overall knowledge about the product and can advise at the beginning of brainstorming or at the end of the iteration to improve further work. Feedback lets the team make course corrections.

### Testing in Scrum
How to incorporate testing in Scrum? 
The Scrum Guide doesn't say anything about testing because it's "a framework for developing, delivering, and sustaining complex products". It transcends the type of product that the team is developing, and the types of testing that the team needs to do, or how testing fits into the process is different for producing different types of software products. It does not define a specific “Tester” role, as testing is the whole team’s responsibility.

Of course, there can be a person more focused on delivering high quality, measuring application performance or assuring application security, but this role is not defined by the book. It usually means that when a team decides to work according to Scrum Guide and at the same time, there is an organizatinal role of a “Software Tester” - an expectation might arise that this person should provide guidance for the entire team (or even organization) on how to test software most effectively and lead the others in the field.

## Summary
It is not the choice of a methodology or technology that limits us from raising the quality of the product or including test automation in a daily routine. It is rather a drive that comes from the team and helps everybody to get better at coding, testing, and taking care of the product.

The choice of the methodology is always a process, not a single decision. It requires work and effort from every team member, not only from the tester.

If you have anything to do with test management or quality assurance - this short exercise is great for practicing on a daily basis: start your working day from a short trip around different metrics - nightly builds, code coverage, cyclomatic complexity, etc. Try to explore and add a new flavor to the testing. Every day you can make an important discovery and improve the quality of your work.

