Software testing refers to the work of ensuring software meets the expectations and standards of the team, users and stakeholders.For developers, software testing is a fantastic way to learn how to fix bugs, and improve their code quality.

In some cases, you may join a team that requires you to write your own tests or ensure you run automated tests, so having the bare minimum skills will be valuable

Some of the basic requirements in software testing include:

• Technical skills & experience in a programming language. Having programming skills is valuable in software testing because you will write logic to test code. You'll also need to know how to read code in order to identify bugs & areas of improvement.

• Understand how the product functions and what's important to the business. Having this knowledge will help you in planning tests, tool configuration, setting up CI/CD, & bug management practices.

Test Strategy

In software testing, a test strategy is the first item you'll need in order to start the testing process. This will help you prioritize your features to be tested and align your tasks to what's being shipped to production. A typical test strategy involves:

A typical test strategy includes:

1. Introduction

- what QA provides to the project - Types of testing to be done - How you'll carry out testing.

2. References

- These include links to the project, high-level information of the project, tools and the project's tech stack.

3. QA deliverables

- This Quality strategy & how quality will be maintained on the project - Test plans for each feature & test scenarios - Issues reported - Release process document which includes steps to doing a release to production.

4. Test Management

- Resources needed to carry out testing e.g. tooling such as Jenkins - Test environments needed for exploratory & manual testing e.g manually testing the product on Windows, or Mac - Test data e.g. test accounts to access the application. You can create a table of accounts - Scope of testing e.g. unit, integration, functional, or regression. Specify how much code you'll cover.

5. Test Plan

This is where you'll map out the test scenarios

6. Acceptance Criteria

The acceptance criteria is expected in testing. It involves: - The Given - The precondition or beginning state of the scenario - The When - The input or action of the scenario - The Then - Expected outcome of the scenario

How to Determine When Testing is Complete

Decide what it means when a piece of functionality is done and ready to share publicly. The typical process involves defining what the definition of done looks like. This typically includes: - Manual and automated tests - Signed off acceptance criteria from product, design & QA

Types of Testing

1. Box Testing

- White box testing is where developers are responsible. - White box testing involves unit and system testing.

Other types of box testing include black box & gray box testing.

2. Manual Testing

Manual testing is a type of black box testing because it depends on a particular input to the UI and expects a particular type of data as a result. It is recommended to not automate all scenarios because they can be time consuming.

3. Integration Testing

This type of testing focuses on the interaction between app components and the server & data layer. Integration testing covers three layers:

- The presentation layer - HTML, CSS & JS - Application layer - Code - Data Layer - Servers

Integration tests are gray box tests because they tests the interaction between the application and the server to confirm that the right information is received.

The benefits of Integration tests is that they can catch issues with the functionality and can be ran within seconds. This means that you can run more integration tests than UI/automation tests.

4. Performance Testing

Performance testing checks how an application performs under system load to ensure it can scale over time.

Performance testing is a type of black box testing because you'll test how your application performs under stress without visibility into the application. Types of performance testing include:

- Load testing - Endurance testing to check for problems like memory leaks

- Stress testing - Identifies the breaking point of an application. You can introduce slow internet, shut down the application to check whether your app is resilient.

5. Security Testing

Exposes security problems in an application to safeguard your app from bad actors and malicious intent.

Vulnerabilities can also show up in dependencies in your applications. Make use of tools like Github to automate such security checks on your dependencies.

Identifying & Reporting bugs

You can have a bug reporting system where you report, triage and fix a bug. The recommended tool for managing bugs is the same tool you're using to build your project. Always categorize bugs when reporting. Check out the bug report template below:

Triaging Bugs

Triaging bugs depends on severity and priority. Severity bugs determines how much a bug is affecting a business.

Priority bugs identifies which bugs should be prioritized. You can use a priority/severity quadrant to determine which bugs need high a high priority and high severity status.

Fixing Bugs

You can set how many bugs to pix per sprint. Because bugs are always showing up, best practice is to not introduce new bugs to be fixed while a sprint is ongoing.

The idea is to always focus on priority bugs that are affecting the application.

Bug Bashes

These are sessions or meetings where teams do exploratory testing to find and fix bugs. These sessions are called mob testing where your team does exploratory on a feature or manual testing with a complete test plan.

You can do mob testing a week or 2 weeks before the software release date where you explore every feature to identify and fix issues.

You can have bug bashes 4 times a year of as much as when you do software releases.

Software Testing Tips

• Use Video Capture - This helps in reducing the markdown in bug report and also give clearer context into the bug. Video capture complements bug reports and you can upload low res videos

• Include log files in bug reports

• Using personas for testing

• Pair testing where two people test the system

Continuous Testing

You can run automaton, API and regression tests autonomously Continuous testing runs overnight or during the build process

Agile Testing

This is where testing is integrated from the beginning of product development. When testing at the beginning of a project, a tester needs to do the following:

• Review product requirement

• Ask clarifying questions

• Extract information to set a quality standard

• Create a plan outlining a product's testability

• Implement a process to ensure this quality

Agile Testing Workflow

Projects are broken down into a series of components which make up a whole product when combined. These products are called epics.

Each epic consists of a number of actions that are fulfilled to build out the functionality of a product. These actions are referred to as stories. Stories are components assigned to developers who build out the scaffolding to accommodate the remaining components from other roles of the team.

References: https://www.linkedin.com/learning/paths/lambdatest-software-testing-professional-certificate