Forem: Agilitest

Practical Guide to Test-Driven Development (TDD) in Web Development

Mathilde Lelong — Tue, 08 Aug 2023 08:36:57 +0000

‍Test-Driven Development (TDD) is a powerful approach in web development that helps ensure code quality and efficiency. It involves writing tests before writing the actual code, which may sound a bit unusual at first. However, by following this practice, developers can have a clear understanding of what they want to achieve and can build robust and reliable web applications. TDD encourages a systematic process where tests are written, code is implemented to pass those tests, and then the code is improved. This practical guide will walk you through the basics of TDD, provide tips for writing effective tests, and explain how to integrate TDD into your web development workflow.

What is TDD?

Test-Driven Development (TDD) is a software development approach that emphasizes writing tests before writing the actual code. It follows a cycle of writing small, automated tests, implementing the code to make the tests pass, and then refactoring the code. TDD has three core principles:

Test First: TDD encourages writing tests before writing production code. This ensures that code is developed with a clear goal and purpose in mind.
Small Steps: TDD promotes an incremental approach to development. Developers take small steps by writing one test at a time and implementing the necessary code to pass it.
Continuous Testing: TDD focuses on maintaining a comprehensive suite of tests that can be executed frequently. This provides ongoing feedback about the code's correctness and helps catch issues early.

Advantages of TDD in Web Development

Test-Driven Development (TDD) offers several advantages in web development. Let's explore these benefits in easy and understandable terms:

Improved Code Quality and Maintainability: TDD requires developers to write tests before writing actual code. This approach helps to guarantee that the code fulfills the necessary functionality and requirements. Continuous testing allows developers to detect errors and issues earlier in the development process, resulting in greater code quality. Furthermore, TDD promotes modular and loosely coupled code, which makes it easier to understand, maintain, and update in the future.
Faster Development Cycles and Reduced Debugging Time: TDD encourages an iterative development process. Developers gain clarity on what the code has to perform by writing tests beforehand, which streamlines the implementation process. As a result, development cycles become more efficient, with fewer back-and-forth revisions. Furthermore, because TDD catches flaws early, debugging time is greatly decreased. Developers can immediately identify and resolve issues, resulting in a better and faster development experience.
Enhanced Collaboration Among Team Members: TDD encourages development teams to work together. When developers write tests, they gain a clear understanding of the requirements and expectations. This shared comprehension increases communication and prevents misunderstandings among team members. Furthermore, when developers work on the same codebase, they can run each other's tests to guarantee that their changes do not break existing functionality. This style of collaboration fosters teamwork, knowledge exchange, and a sense of project ownership.
Increased Confidence in the Codebase: One of the significant benefits of TDD is the increased confidence it provides in the codebase. A complete suite of tests allows developers to be more certain that their code works as intended. Tests act as a safety net, giving developers reassurance that changes or additions to the codebase won't introduce regressions or break existing functionality. This confidence allows for more experimentation and refactoring without fear of unintended consequences, leading to a more robust and stable codebase.

Red-Green-Refactor Cycle

The Red-Green-Refactor cycle is a fundamental concept in Test-Driven Development (TDD) that guides the development process. It consists of three stages, each serving a specific purpose to ensure the code is reliable and maintainable.

Writing failing tests (Red): During this stage, you start by writing tests that describe the expected behavior of the feature or functionality you are working on. These tests should initially fail because you haven't implemented the corresponding code yet. The Red phase helps you clearly define what you want to achieve and serves as a guide for writing the necessary code.
Implementing the minimum code to pass the tests (Green): In the Green stage, you write the minimum amount of code required to make the failing tests pass. The focus here is on functionality rather than perfection. The goal is to make the tests go from failing (red) to passing (green). This minimal implementation should be simple and straightforward, addressing only the immediate requirements of the tests.
Refactoring the code while keeping the tests passing (Refactor): Once the tests are passing, you can move on to the Refactor stage. Here, you improve the code's design, structure, and readability without changing its behavior. Refactoring allows you to eliminate duplication, improve naming conventions, and make the code more maintainable. The key principle is that you refactor with confidence because the tests act as a safety net. If you accidentally introduce a bug, the tests will catch it.
The cycle then repeats as you go back to writing failing tests (Red) for the next feature or functionality you want to add. This iterative process helps you incrementally build a reliable codebase that is thoroughly tested and easy to maintain.

Writing Effective Test Cases
Writing effective test cases is crucial for successful Test-Driven Development (TDD) in web development. Well-designed tests ensure that your code functions as intended and can catch potential bugs early in the development process. Here, we will discuss the characteristics of good test cases, choosing appropriate test granularity, and the concepts of test coverage and prioritization.

Characteristics of Good Test Cases

Good test cases exhibit the following characteristics:

Clarity: Test cases should have clear and understandable objectives. They should be written in a way that anyone reading them can understand what the test is verifying.
Independence: Test cases should be independent of one another, meaning that the outcome of one test case should not influence the outcome of another. This allows for easier debugging and identification of the root cause of failures.
Reproducibility: Test cases should be reproducible, meaning that they can be executed multiple times with the same inputs and produce the same expected results. This ensures consistent and reliable testing.
Completeness: Test cases should cover a wide range of scenarios and edge cases to ensure comprehensive coverage of the functionality being tested. It's important to consider different inputs, boundary conditions, and potential failure scenarios.
Maintainability: Test cases should be easy to maintain as the codebase evolves. They should be designed in a way that allows for easy updates and modifications when changes are made to the system.

Choosing Appropriate Test Granularity

When writing test cases, it's important to choose the appropriate level of granularity based on the scope and complexity of the code being tested. The three common levels of test granularity are:

Unit Tests: These tests focus on testing individual units or components of code in isolation. Unit tests are typically small in scope and verify the behavior of specific functions, methods, or classes. They are fast to execute and help catch bugs early in the development process.
Integration Tests: Integration tests validate the interaction between different components or modules within the system. They test how these components work together and ensure that they integrate correctly. Integration tests provide confidence in the system's overall functionality and its ability to handle interactions between different parts.
End-to-End Tests: End-to-end tests simulate real user scenarios and cover the entire system from start to finish. They test the system as a whole, including its various components and external dependencies. End-to-end tests help ensure that all parts of the system work together seamlessly and validate the system's behavior from the user's perspective.

Test Coverage and Prioritization

Test coverage refers to the extent to which the codebase is exercised by your tests. It's important to achieve sufficient coverage to catch potential bugs and ensure that all critical functionality is tested. However, achieving 100% coverage may not always be practical or necessary.

Prioritizing test coverage involves identifying the most critical and high-risk areas of your codebase and ensuring that they are thoroughly tested. This includes focusing on complex algorithms, critical business logic, error-handling scenarios, and edge cases that could have significant impacts on the system's behavior.

Consider the following factors when prioritizing test coverage:

Business Impact: Focus on areas of the codebase that directly impact the core functionality or critical business processes. These areas should be thoroughly tested to minimize the risk of failures.
Complexity: Prioritize testing complex areas of the codebase that involve intricate logic, calculations, or algorithms. These areas are more prone to errors and require thorough testing.
Error-Prone Scenarios: Identify scenarios that are more likely to result in failures or errors. These scenarios could involve input validation, data transformation, or external dependencies. Test these areas rigorously to ensure robustness.
Code Changes: When making changes or adding new features, prioritize testing the affected areas to verify that the changes are working as intended and do not introduce regressions.
Understanding the characteristics of effective test cases, selecting the appropriate granularity, and prioritizing test coverage will help you build successful test cases that contribute to the success of Test-Driven Development in web development. These techniques will help to improve the code quality, maintainability, and overall stability of your web applications.

Best Practices and Tips for TDD in Web Development

Read full article here. An article by Paula Isabel Signo.

Effective Testing Techniques and Mobile App Development Cost Estimate

Mathilde Lelong — Tue, 18 Jul 2023 07:22:45 +0000

In the world of mobile app development, testing techniques play a crucial role in ensuring the quality and success of an application. At the same time, accurately estimating the cost of developing a mobile app is essential for effective project planning. In this article, we will explore different testing techniques that can be employed during the app development process. We will discuss factors that influence the cost estimate.

Understanding Testing Techniques for Mobile App Development

Testing is an integral part of mobile app development, as it helps identify and address issues, improve performance, and enhance the user experience. Let's explore some standard software testing techniques:

Functional Testing

Functional testing involves testing the app's functionality to ensure it performs as expected. This includes verifying individual features, user interactions, data handling, and overall app behavior. It involves evaluating an application's parts and functionalities to ensure they work as intended.

Developers can identify and address any issues or bugs hindering the app's performance by conducting functional testing. This type of testing focuses on verifying that the software meets the specified requirements and delivers a seamless user experience. By thoroughly testing each function and interaction, functional testing helps ensure the application performs flawlessly and meets user expectations.

Performance Testing

Performance testing evaluates the app's performance under different scenarios, such as load, stress, and endurance. It helps identify bottlenecks, assess response times, and optimize resource utilization.

By simulating real-world scenarios, performance testing measures the system's ability to handle high user loads, heavy data volumes, and concurrent transactions. It helps identify bottlenecks, resource limitations, and potential performance issues, allowing developers to optimize the application's speed and efficiency.

Usability Testing

Usability testing examines how users interact with the app, assessing its ease of use, intuitiveness, and overall user experience. This involves gathering feedback from real users to improve the app's design and navigation.

Usability testing aims to identify usability issues, confusing interface elements, or obstacles hindering users from accomplishing their tasks efficiently. By conducting usability testing, developers gain valuable insights into user preferences, behavior, and pain points, enabling them to make informed design decisions and improve the overall user experience of the application.

Compatibility Testing

Compatibility testing ensures the app works seamlessly across various devices, operating systems, and screen sizes. It verifies that the app functions correctly and displays appropriately on different platforms.

It involves validating that the software functions correctly and displays appropriately regardless of the user's chosen environment. Compatibility testing helps identify compatibility issues, such as layout distortions, functionality conflicts, or performance variations, that may arise due to differences in hardware or software configurations.

Security Testing

Security testing is crucial for protecting user data and ensuring the app's resistance against potential vulnerabilities. It involves testing for weaknesses, verifying secure data transmission, and implementing appropriate encryption measures.

It involves evaluating the software's ability to protect data, prevent unauthorized access, and withstand potential security threats. Security testing encompasses various techniques to uncover potential security loopholes and weaknesses to uncover potential security loopholes and liabilities, such as penetration testing, vulnerability scanning, and risk assessment.

By conducting thorough security testing, developers can identify and address potential security risks before deploying the application, safeguarding sensitive information and ensuring the software's resilience against malicious attacks.

Mobile App Development Cost Estimate

Accurately estimating the cost of developing a mobile app is vital for budgeting and decision-making.

Several factors influence the cost estimate:

Read full article on Agilitest blog.

Continuous Testing: Streamlining Your Testing Process in Web Development

Mathilde Lelong — Mon, 19 Jun 2023 09:10:11 +0000

In the fast-paced world of web development, delivering high-quality software in a timely manner can make all the difference in staying ahead of the competition. That's where continuous testing comes in. Continuous testing is an automated approach to testing that helps streamline the testing process, catch errors earlier, and ultimately deliver better software faster. In fact, according to a study by MarketsandMarkets, the continuous testing market is estimated to grow at a rate of around 16% annually from 2018 to 2023, reaching a value of $2.41 billion. This statistic alone highlights the importance of implementing continuous testing in web development to meet the growing demand for top-notch software delivery. In this article, we will explore continuous testing and how it can streamline the testing process in web development.

What Is Continuous Testing?

Continuous testing is an automated approach to testing in web development that involves continuously testing software throughout the development process. This means that tests are run automatically and continuously throughout the development cycle, catching errors and bugs early on and allowing for quick fixes. Continuous testing includes a variety of testing methods, such as unit testing, integration testing, and performance testing, among others. Continuous testing in web development allows developers to ensure high-quality software is delivered on time while also lowering overall testing costs.

What Are the Benefits of Continuous Testing?

Continuous Testing offers several benefits in web development, including:
Early detection of defects: Continuous testing helps to identify defects early in the development cycle, allowing for quicker resolution and reducing the risk of these defects affecting the overall quality of the software.
Increased test coverage: Automated testing allows for a wider range of tests to be executed, covering more scenarios than manual testing alone. This helps to increase the overall test coverage and ensure that all parts of the software are thoroughly tested.
Reduced time and cost: With continuous testing, developers can identify and fix defects earlier in the development process, reducing the overall cost of development and decreasing the time to market for the software.
Improved software quality: Continuous testing ensures that the software meets the highest quality standards and meets customer expectations, resulting in higher customer satisfaction and increased trust in the software.
Better collaboration and communication: Continuous testing encourages better collaboration between developers, testers, and other stakeholders, ensuring that everyone is working towards the same goal of delivering high-quality software.
Continuous Testing is a crucial process for streamlining the testing process in web development, and its benefits are numerous. It helps to catch defects early, increase test coverage, reduce time and cost, improve software quality, and foster better collaboration and communication among development teams.

Real-time Reporting in Continuous Testing

Real-time reporting is a crucial aspect of continuous testing in web development. It allows developers and testers to get immediate feedback on the quality and performance of their software as soon as a change is made. This section will discuss the role of real-time reporting in continuous testing and how it can help streamline the testing process.

The Role of Real-Time Reporting in Continuous Testing

Real-time reporting is crucial for continuous testing, allowing developers and testers to identify and address issues as they arise. It provides immediate feedback on test status, enabling developers to make quick adjustments to ensure software functionality. Real-time reporting also facilitates collaboration between stakeholders, ensuring everyone is aligned on the software status and enabling swift issue resolution.

Moreover, real-time reporting enhances testing process efficiency by prioritizing efforts on critical issues. Developers and testers can focus their efforts on areas that have the most impact on software quality by providing a thorough and up-to-date view of the software status. This helps to deliver high-quality software faster and more efficiently.

Best Practices for Real-Time Reporting in Web Development

Read full article on Agilitest blog. An article by Paula Isabel Signo.

The Role of Continuous Testing in Building High-Quality Software

Mathilde Lelong — Mon, 12 Jun 2023 12:58:21 +0000

The role of continuous testing in the delivery of high-quality software can never be emphasized, however, it is important that we understand the rudimentary nuggets of the concepts we are about to explore. For starters, software testing analyzes and verifies that a software product or program accomplishes its intended work. Some advantages include bug prevention, reduced development costs, and improved performance.

Furthermore, you should know that continuous testing is an integral part of software testing. It involves testing software continuously and automatically throughout its development and maintenance lifespan. It is critical for ensuring software quality, decreasing errors, shortening time to market, and increasing customer satisfaction. It’s an essential technique for software development, allowing firms to provide high-quality software that satisfies user expectations, minimizes costs, and retains a competitive advantage. Let us dive deeper.

What is Continuous Testing?

Over the years, software development has changed at a rapid pace. What is the catalyst for this evolution? Advanced software ensures quick and efficient service, utilizing Agile and DevOps to satisfy customers. The development period is shortened from weeks to months to days and hours, and automated testing progressively replaces manual testing techniques.

Continuous testing is a technique that involves continually and automatically testing software throughout its development and maintenance lifespan. It is a sequential process incorporating testing operations into the software development pipeline, allowing for the early discovery and correction of errors and difficulties. It is also commonly used in Agile and DevOps approaches, emphasizing iterative and collaborative software development with rapid releases and ongoing feedback loops. Its goal is to offer immediate and precise feedback on the quality and dependability of the program under development, allowing for faster releases and guaranteeing that the product satisfies the specified quality requirements.

Depending on the needs of the software being produced, it may entail using various testing techniques such as automated testing, unit testing, integration testing, performance testing, security testing, and other forms of testing. These tests are frequently automated and run in the background as part of the development pipeline, employing tools and frameworks that facilitate automated testing.

Benefits of Continuous Testing

Because the testing process begins in the early phases of development and continues indefinitely, application hazards are discovered early on. In this manner, development teams may avoid these difficulties as they advance through the development cycle, reducing the time and effort spent at the end of the process finding and fixing errors. Continuous testing is becoming increasingly popular, and it makes sense to use it since it can improve the efficiency of existing approaches. Here are some of its main benefits:

Testing Throughout the Pipeline: Testing Throughout the Pipeline (TTTP) is a software testing strategy that entails testing at every stage of the software development process, from design through deployment. It highlights the significance of regular and early testing to discover problems as early as possible, decrease expenses, and improve software quality. Continuous testing is a process that involves running automated tests continually throughout the software development pipeline to offer feedback on the program’s quality. This method enables developers to detect and correct flaws before they become more complex and costly. Developers may spot flaws early in the pipeline and address them before they become more complex and expensive to solve. This strategy can lower total software development costs and improve software quality.
Furthermore, testing throughout the pipeline aids in detecting flaws that traditional testing methods may miss. For example, tests performed during the design process can assist in detecting problems in the software architecture, but tests performed during the deployment phase can assist in detecting defects that only occur in production situations.
Improved Collaboration: Continuous testing guarantees everyone in the software development process is aware of the current status of the product, including flaws or issues discovered during testing. Improved cooperation can assist in identifying and resolving difficulties early in the development process, lowering the chance of serious problems later.
Effective collaboration is critical in software development and testing; continuous testing may aid this process in various ways. They include early problem identification and resolution, greater transparency throughout the software development process, consistent and dependable testing, less manual work, increased efficiency, and improved developer-tester communication and collaboration.
Discrepancy issues: When test automation scripts are performed in multiple environments, discrepancies might occur due to setup changes such as operating systems, browsers, and software versions. These discrepancies can lead to test failures, slowing development and raising expenses. Continuous Testing eliminates differences by providing the same parameters for all test automation scripts. This guarantees that tests are executed consistently across all environments. This uniformity also reduces the possibility of human mistakes. When testers are obliged to configure test environments manually, they are more likely to make mistakes. Continuous testing removes the need for manual configuration and decreases the risk of human errors by providing the same structures for all test automation scripts.
Furthermore, by providing the same parameters for every test automation script, continuous testing helps to increase testing process efficiency. Without spending time creating multiple environments, testers can perform tests more quickly. This can assist in accelerating the development process, allowing for faster software delivery.
Immediate Feedback: Continuous testing relies heavily on direct feedback. It refers to the continuous and timely examination of software quality throughout development, allowing developers to detect and fix any faults or errors swiftly.
Continuous testing requires immediate feedback since it helps detect faults early in development, making resolving them more straightforward and less expensive. It helps to minimize the time and expense of resolving problems while improving the overall quality of the product. Rapid feedback allows developers to iterate quickly and make required code modifications, resulting in a shorter time-to-market for the software product. This can provide businesses with a competitive advantage in the marketplace.

Continuous Testing Process and Phases

Continuous testing is a strategy that reiterates testing promptly, constantly, and throughout the software development lifecycle. The continuous testing process is divided into several phases, which are as follows:

Planning: This phase defines the testing strategy and objectives, as well as the tools and frameworks to be used. The testing team also works with the development team to ensure the program meets the specifications.
Test Design: Test cases and situations are created according to the requirements and design standards during this phase. The test cases should include all potential scenarios and exceptions to guarantee complete testing.
Test Execution: In this step, the tests are executed on the program, and the results are collected. Continuous automated tests are conducted, and manual tests are run as needed.
Test Reporting: The test results are examined in this phase, and reports are prepared. These reports assist in identifying any faults that need to be fixed and provide input on the software’s quality.
Test Maintenance: During this phase, the test cases and scenarios are updated and maintained to stay current and realistic. As the program evolves, the tests must evolve as well.
Continuous testing is a constant cycle throughout software development, from planning to test maintenance. Issues may be found early and fixed quickly by continually testing the program, resulting in higher-quality software and a shorter time-to-market.

Why Continuous Testing is Important in Building High-Quality Software

Read full article on the blog. An article by Olufunso Oladiran.

Impact of Agile Methodology on Software Development

Mathilde Lelong — Tue, 16 May 2023 12:51:48 +0000

What is Software Development?

According to IBM (International Business Machines Corporation), Software development refers to a set of computer science activities dedicated to the process of creating, designing, deploying, and supporting software. The software itself is the set of instructions or programs that tell a computer what to do. It is independent of hardware and makes computers programmable.

Types of Software Development Methodologies

  1. Agile Methodology

This emphasizes flexibility, collaboration, and rapid iteration. It is best suited for projects with rapidly changing requirements or a high degree of uncertainty, like requirement gathering. There are various types of frameworks in the Agile methodology but a few will be listed.

Kanban
Scrum
Extreme Programming (XP)
Crystal
Dynamic Systems Development Method (DSDM)
Feature Driven Development (FDD)‍

  2. Lean Methodology

This explains the elimination of waste and maximizing efficiency by continuously improving the process and people involved.

  3. Waterfall Methodology

This is a traditional, linear methodology that involves completing one phase of development before moving on to the next. It is best suited for projects with well-defined requirements and a fixed scope.

  4. DevOps Methodology

This is a methodology meant to improve work throughout the software development lifecycle. The DevOps process can be visualized as an infinite loop. It comprises the following steps: plan, code, build, test, release, deploy, operate, monitor, and thorough feedback while planning again which resets the loop.

Impact of Agile Methodology on Software Methodology

  1. Quality and Team Involvement

Agile methodology is a widely adopted software development approach that aims to deliver high-quality software in a timely and efficient manner. This is based on a set of principles that prioritizes (1) Adaptability (2) Flexibility (3) Collaboration among team members.

For example, my organization builds software solutions for clients. Here we adopt an agile methodology. Daily stand-up meetings are being conducted to ensure that every member of the development team fully understands what has been done and what is expected. We address issues or contributions in order to decide faster collectively.

N.B: Agile teams work together to meet the customer's needs. This is achieved through regular team meetings called “Scrum” where teams share ideas, discuss progress, and identify issues that need to be addressed. Scrum is a lightweight agile framework that can be used by project managers to control all types of iterative and incremental projects. In Scrum, the product owner creates a product backlog that allows them to work with their team to identify and prioritize system functionality. The product backlog is a list of everything that needs to be accomplished to deliver a successful, working software system: this includes bug fixes, features, and non-functional requirements. Once the product backlog is defined, no additional functionality can be added except by the corresponding team. This close collaboration allows for early identification and resolution of problems, which helps to ensure that software is delivered timely, error-free, and of high satisfaction to customers.

  2. Quick response and transparency for key stakeholders

Read full article on the blog. An article by Olufunso Oladiran.

How Can Developers and Testers Work Better Together?

Mathilde Lelong — Tue, 09 May 2023 12:37:51 +0000

Developers and testers are on the same side – it does not matter if a company puts them in the same (agile) team or in separate teams of developers and testers. It is up to both testers and developers to build a great application. To achieve this goal, they will have to collaborate together in a productive way. To do so and to get their job done better, faster, and easier, there is different practical advice and hands-on advice that can help. I will start with tips and approaches that focus on individual cooperation between a developer and a tester. In the second half of this article, I’ll share advice that will help to improve cooperation on a team level.

Better cooperation on individual level

As a developer, I consider testers as my safety net. I would prefer a bug to be reported by a tester, rather than the end user finding a bug in production.

Generally speaking, people do not feel comfortable when someone criticizes their work. Developers should not think of testers as somebody who is constantly telling them that they did something wrong. Instead, developers should consider testers as partners who are trying to keep end users from criticizing their work. Testers at the same time should be aware that junior developers might feel uncomfortable when they receive a bug report. As they build up experience, developers won't, or at least shouldn't, get defensive when they receive bug reports.

I can tell from my experience, cooperation between a developer and a tester will be better if mutual respect is clearly visible.

Practical approaches to hard to reproduce bugs

Sometimes, a developer cannot reproduce a bug that a tester has reported. In my 17 years of professional experience as a developer, I found that there are a few tips and tricks that can help.

When a tester sends a screenshot to a developer, it is more effective to send a screenshot of the whole application — and not just a piece of the user interface. Sometimes, when a bug is on one part of the UI, I manage to find a clue for reproducing it on the other part of the UI. Simply by sending the screenshot of the complete tested application interface, a tester can facilitate the developer’s work to reproduce a bug.

But what if a screenshot is not enough to reproduce a bug? What if the additional information provided by a tester are not sufficient? Video is a great assistant. Use the screen recording app to record everything that goes on the application UI as part of the test. In my experience, a video is useful because a developer can find a (small) clue for reproducing a bug somewhere between steps that were already mentioned in the description of this bug. A small detail could trigger a bug, and a video helps a developer discover that detail.

Please note: It is not necessary for a tester to speak in his/her recording. Hearing the tester in video was never crucial for me to reproduce a bug. Many testers will feel more comfortable if they are not asked to record themselves commenting on the video.

Managing conflict

In case of a conflict between a tester and a developer, everyone involved must use effective communication, be diplomatic, and not take things personally. Both parts need to look at things from another person's perspective – this other person also has timelines, tasks, priorities, etc.

The aim is to prevent a conflict. In everyday life, there are times when a short message can prevent a misunderstanding and conflict that follows.

Always remember, that we are all on the same side as we build the same application.

Teamwork from scratch

Read full article on the blog. An article by Marko Lohert.

Testing Talks with John Ferguson Smart

Mathilde Lelong — Tue, 06 Dec 2022 08:47:21 +0000

Testing Talks is a series of interviews highlighting well-known personalities from the world of software quality and testing. In this new episode, we had the pleasure to talk with John Ferguson Smart.

You can watch the interview on YouTube, or directly head to the transcript below.

Can you introduce yourself and your background?

I'm John Smart. I've been working in Agile for several decades. I created a test automation library framework and I wrote a few books on Agile development. One of them is called ‘BDD in Action’ and the second edition is coming out shortly. I have been doing software development since the mid 90s in different forms. I got involved in Agile development in the late 90s, early. I started getting involved with BBD, more particularly, when I started working in London. In fact, I was hanging out with the London XP practitioners and worked with a lot of very smart people there who were floating around ideas like TVD and BBD, and practices like that. I picked up a few things there and started applying them. I've been coaching teams in XP and Agile in general. I think the first one was in Egypt around 2001-2002.

I've sort of watched the evolution of test automation over the years going from automating test scripts to clunky big commercial tools to Selenium or JavaScript tools. I’ve been watching this evolution with great interest - seeing things like low code and no code tools coming out.

What I do in my day job is more about helping teams but also bringing testers up to speed and running a thing called the Serenity Dojo. It is a program for manual testers and testers who are new to test automation and get them up to a level of what I'd consider to be a senior test automation level. Because I think there are too many testers held back by not knowing the right way to go about test automation, not knowing the right techniques. And these are not necessarily complicated techniques, but nobody shows it to them. And a lot of the people who do teach or a lot of the courses which get taught aren't necessarily very helpful a lot of the time. So I am trying to bring testers up to speed that way.

What motivated you to get into this industry?

In testing? That's a really good question. I drifted into testing from the BBD space. I've always been interested in the testing world. When I was a technical project manager, I was involved in testing activities, in measuring defect rates, in studying models... I've been involved with the testing side of things for quite a while, and I think it all started in Sydney in 2011. I was helping teams do test automation there. And then one of my friends' managers at the time proposed this idea of what if you could use tests to document applications? What if you use tests to be able to document features? And so we talked about that. I thought that was a pretty cool idea and I came up with some prototypes. I got more involved in test automation – I mean I was teaching test automation before that probably in 2005-2006 – but actually getting into writing the tools and creating a test automation tool that would not just automate tests but also document features was new

What do you love the most about your job?

I like to see the evolution that people make in their work, in the way they work; when they learn to write good test automation techniques or to use really effective test automation frameworks.

I find it satisfying to see tests move from writing very crude ad hoc test scripts to tests that take less time to write new scripts. So it's sort of about what I like seeing. What I enjoy most about my work is just seeing that impact. Seeing the impact of when you teach people a technique and they pick it up, apply it and run it and how it actually has an impact on their career. It is not just about the theoretical esthetical idea of writing nice code but the concrete impact it has on the projects earning and on their own career paths.

Do you have an anecdote to share?

I have lots of anecdotes… There was one project I was working on, and we were doing a requirement 3 Amigo sessions. The Product Owner came up with the requirements, saying: ‘Right. Well. What needs to happen is we need to upload an Excel spreadsheet into the database, and then it needs to send out a message into our workflow system where all the system users have to be notified. And then they need to be able to update the workflow state or change the state and make this spreadsheet.’ It was basically all about locking down data. They could upload a spreadsheet, but it couldn't be changed. And the only way to change it was to submit a workflow process where they could go into the workflow and modify the data, and then they had their permissions and access rights. It was a very complicated system and one of the testers there on the team said ‘Yes, but why do we need to do that? What's the reasoning behind it?’ We were sort of doing the BBD approach of having three Amigos and being very analytical and critical about requirements as it came through.

I'm always asking, why do you need this? What's it for? And the PO said ‘Well, we need to do this in this way because that's the way it's always been done, that's the way it was done with the previous application.’ And so she asked her why was it done like that in the previous application? And turns out it dates back from an application before that, two applications back. It was where this file got uploaded, and the file was basically a reporting file from vendors about a bus timetable system. But basically, did the buses run on time? They had to upload statistics and pass a certain date. They weren't allowed to modify those statistics. And so they had this whole workflow in place because of the original system. So, one of the developers said, “Well, why don't we just send an email notifying everyone that this data has been uploaded?” And it turns out that's actually all that was needed.

So this requirement went from about three months work to about a day or less because the tester was asking these questions. So I quite liked that story. It saved the government department quite a lot of money just by asking the right question. I think that shows when testers do get involved earlier on, not just waiting to test stuff that comes out the end of the pipeline, but are actually involved in the requirements' discovery. The critical mindset that you have as a tester can really help to prevent waste much earlier than people often think.

What are the main points to succeed in agile transformation for you?

So the main success criteria of an agile transformation… I guess at the end of the day, are you delivering value sooner, and can you adapt to change? That's what agile essentially is about. Can you adapt to change more readily? But generally speaking, that's quite hard to measure, and you don't actually measure that until a fair bit down the line. So the thing I tend to keep an eye on is little things, little what I call proxy metrics. Like, how often do you deliver working software? How early do developers or development team members, including testers, get involved in requirements discovery, in talking about requirements? Do you have a testing team? If you've got a separate testing team, it's usually not a very good sign on the agile front. Do you have a UAT space? Do you allocate time to UAT testing at the end of each phase? Those

things tell me that we're not really doing things in a job way. So when I see teams that plan three months of work, and then they have another two months following that to actually do testing or integration testing or UIT testing or whatever they want to call it. That usually tells me that there is an agile process. Their agile transformation is not as optimal as it might be. And they're not actually using an agile approach if it's delivered when everything is ready. And that includes the testing.

How should companies organize testing teams for better efficiency?

Read full article on Agilitest' blog.

Best Examples of Functional Test Cases | Agilitest blog

Mathilde Lelong — Tue, 15 Nov 2022 08:29:17 +0000

Recently I was reviewing the test cases of one of my colleagues who has joined as a fresher in the testing team. Though he had tried his best to cover up all the test cases as per the functionality and WireFrame provided in the Business Requirement Specification, I found that cases written were not descriptive to be understood in one go. I had to ask him multiple times what he meant to say in Case 1, then in Case 2 and so on…
In my experience, I have observed this multiple times. The test cases written by testers are not quite descriptive, people try to address multiple things in a single test case which actually makes it difficult to understand. A test case should be so specific that even a lay man should understand what it is actually trying to cover and test. Functional test cases need to be developed, reviewed, used, managed and saved.

What does a Test Case mean?

IEEE Standard 610 (1990) defines test case as follows:
"(1) A set of test inputs, execution conditions, and expected results developed for a particular objective, such as to exercise a particular program path or to verify compliance with a specific requirement."
"(2) (IEEE Std 829–1983) Documentation specifying inputs, predicted results, and a set of execution conditions for a test item."
It's basically what you are testing, with what input, what you expect in return and finally recording the actual outcome of the test.
Furthermore, Test Cases can be classified into different categories like GUI, Functional, etc.

What is a Functional Test Case?

A test case which covers the specific functionality of the application can be termed as "Functional Test Case". Functional test case is attached to a certain function or feature of the application and verifies if it produces the expected result as mentioned in the Business Specification or Functional Specification Document.
Before anything is moved to production, it is required to test that specific feature in the test environment to verify it is actually performing the required function correctly.
Not everything you test in the application relates to the functionality or feature. There are, for example GUI related things like Color, Background, icons, text color, font size, etc which can be tested separately, though these are also important aspects with regards to the application however can not be taken as functional test cases.

What should a Functional Test Case have?

These points are not specific to functional test cases and can be covered in normal test cases as well. However for writing a functional test it is recommended to cover the following:
Menu Name - Window name where functionality needs to be covered.
Description of the test case.
Pre Conditions required.
Steps required to execute the test.
Expected Output.
Actual Output.
Remarks - In case, any additional info needs to be provided.

In case of test case failure, always make sure that you provide all the required information that is available at your end in the Actual Output column. Information like the following is very handy for the developers to debug the issue and also understand the cause of the failure:
Error message displayed.
Error log.
Screenshot of the issue.
Exact steps to reproduce the issue.

How to write a Functional Test Case?

Let's take the example of login functionality and write a few test cases.

Read full article here. An article by Mohammad Faisal Khatri.

Reliability Testing in Software Testing | Complete Guide

Mathilde Lelong — Tue, 08 Nov 2022 13:07:37 +0000

In this post, we’re going to know what exactly reliability testing means in software testing, the importance of reliability testing and its types in detail. So if you were looking for a quick guide on reliability testing, then you are at the right place. Let’s not delay things and get started!

What is Reliability Testing?

Reliability testing is a testing technique to test the functionality of software under given circumstances within a specified period of time. This technique helps identify software design errors that need to be rectified to support seamless software operations for the intended purpose. It checks whether the software is working smoothly without any failure operation in a particular environment and makes sure that there are no bugs and errors for its expected purpose.

In today’s quickly evolving technological sector, the usage of software applications is increasing in every aspect of our life – including telecommunication, fintech, healthcare, government sectors, etc. The objective of reliability testing is to identify the pattern of failures, its occurrence in a specific period of time, and the root cause of failure.

Thus, we can say that reliability testing is essential to have accurate data on which the users can be dependent. Its aim is to standardize the software quality and the software products that we are building. If we have the ability to repeat the test cases and get the same output multiple times, then the product is reliable.

Lastly, it is important to perform reliability testing for every software that is developed and never ignore it as it makes sure that the software is created as the requirements, satisfies the purpose for which it is made, and is capable enough to render an error-free operation.

In the end, its motto is to provide quality software.

Objectives of Reliability Testing

To build a robust and reliable product that works perfectly every time.
To find errors and resolve them before the software is delivered and released.
To make sure that all the customers are satisfied and all its requirements are achieved.
To uncover issues in the product's design and functionality.
To unlock latest design patterns in the defect trends.

What is the importance of Reliability Testing?

Test-retest reliability
Reliability testing is one of the main phases of software development, which is performed to estimate test-retest reliability only a few days or weeks apart before the software is released. The time here is restricted so that the skills of examinees in the area can be assessed easily. The connection between two administrators and the examinee’s scores is estimated through statistical correlation, where reliability testing takes place to illustrate the preparation of a plan that is consistent and generates stable scores across time.
Improve software performance
When you hire a dedicated team of software developers, you'll definitely get your product at a satisfactory level which can be useful. But when they perform reliability testing, it works much better and enhances the performance of the software. Performing reliability testing is essential not because it satisfies the customer, but because it makes sure that all the functions involved in it are working as per the requirements or not. If not, then they will recheck it and come up with more efficient solutions to present it to a client.

In short, reliability testing makes sure that the user receives the best possible and expected experience for a business and bug-gree aspect. But unfortunately, one minor error or bug can highly affect your software and lead to complex consequences which can be difficult to handle and perform continual dependability testing.

Decision consistency
After performing test-retest reliability testing, we are now all set to get the examinees results whether we have passed it or failed. The result of reliability testing and classification decisions is estimated depending on the software consistency.
Bugs and issues resolution

Read full article here. An article by Joy Anderson.

Manual tests & automated tests : a comparison

Mathilde Lelong — Wed, 02 Nov 2022 10:00:52 +0000

Nowadays, we tend to advocate test automation. But, is it really good to automate everything? What are the benefits of test automation? How to choose which tests to automate?
Take a look at the infographic here.

Infographic transcript

Testing Time

Manual testing execution takes time because it is necessary to set up a meticulous and recurrent time-consuming testing protocol. Testers are limited by the time available to work. When it comes to automated testing, execution time is optimized. Automated test protocol takes more time to implement, but takes less time for each execution. It allows automation to be competitive as the number of deliveries/campaign replays increases. Also, automation works 24/7.

Testing accuracy

For testing accuracy, manual testing is relevant on a human aspect. In fact, it allows more flexibility from a human perspective in the viability of the tests. Elements that were not initially in the tasks can be judged manually. On the other hand, automated testing relies on automation tools and scripts. In fact, scripts cannot find anomalies if they are outside its test program. However, automated testing shows a higher efficiency, because automation is run by a machine, where a manual process increases a risk of errors omission due to the human factor.

Exploratory Testing

When well done and without heavy maintenance, test automation gives more time to testers to explore real end-to-end end-user UX and interface scenarios. However, exploratory and UX testing are hard to engage due to heavy workload on manual testing.

Types of tasks

With automated testing, coverage tests and functional tests can be automated, including real user simulations.

User interface

For the UI, both types of tests are valid. With manual testing, the tester can give feedback on the application's user-friendliness to provide ideas. With automated testing, automation does not allow for objective opinions but gives more time to testers to provide feedback.

User path testing

Automation does not analyze or perceive system behaviors that are not implemented in its programming, whereas humans can perceive particular system behaviors. For this part, manual testing tends to be more effective than automation.

UX testing

Automation can't judge the user experience. This task needs a brain to verify the correct display of text, links, images…

Investment

Automation follows its program, regardless of the context, and it adapts to any type of system. On the other hand, a tester may encounter difficulties if he is out of his comfort zone. Automation speeds up the verification process and allows more time to correct anomalies. Moreover, manual testing can lead to deadlines overrun if too many errors occur.

Process impact

Due to heavy workload, manual testing should be done at the very end of the software production process, breaking the production process. Processes may be leanified by automation by allowing a more softened flow of work.

Teams state of mind

Validation teams are under pressure for each delivery testing phase. Developers are also forced to work on two versions at the same time. Automation testing provides more regular work, allowing testers to have more time to work with other teams (3 amigos), ensuring a better state of mind.

Read full article here.

Ebook - Scaling functional test automation for happy teams

Mathilde Lelong — Tue, 20 Sep 2022 07:21:50 +0000

1. From manual to automated tests

a. The organization of manual tests teams – V-cycle
For many years, software was mainly developed with a V-cycle methodology. As a reminder, the V-cycle is a project organization model that is characterized by a flow of activity that details the product until its realization and a flow that assembles the product by checking its quality.

In this model, the further upstream the steps are, the later the validation of the step. This observation was made by experts who wanted to implement ‘Shift Left’, which is used to detect anomalies as early as possible, by implementing processes such as reviews. As a reminder, reviews are processes for verifying written deliverables that can be adapted to a wide range of subjects such as code, specifications, scripted tests…

In addition to late testing, the V-Cycle offers other problems. The delivery cycles are long and thus limit the number of deliveries per year (often between one and four). The specific test ‘phases’ also take place in a very punctual manner. Another issue arises with SUTs (System Under Test) that have many changes to test, with many requirements, leading to test campaigns that can last several weeks.

This V-cycle method gives the advantage to manual testing. Testing teams working in V-cycle spend a lot of time preparing a campaign with design and test writing phases. After that, the testing campaign can begin, after the software has been delivered. As this test campaign can be long, a follow-up is regularly set up to have intermediate assessments. At the end of the campaign, the test team moves on to another topic, such as preparing a new campaign for a different SUT.

The test loads on a particular SUT are therefore not at all smoothed out with the V-cycle method. However, a good understanding of the business, the ability to understand the specifications and to design the tests are a must. In V-Cycle, there is much less room for error compared to the Agile method, where a new version can be delivered very quickly.

This methodology has trained testers to be highly skilled in the art of understanding the business, implementing strategies around RBT (Risk Based Testing) and designing quality tests. Testers who are used to the V-cycle have not generally been asked to work on test automation. Indeed, there are few campaigns that are regularly enough executed to be considered repetitive and require automation.

b. Challenges faced by manual tests
Download and read this book for free here.

In this book

From manual to automated tests
a. Organizations of team doing manual tests - V-cycle
b. Challenges faced by manual tests
c. How to reorganize teams to allow test automation
From test automation to smart test automation
a. Identify which tests to automate
b. How to implement continuous testing
c. What you can achieve by testing frequently (happy teams)
Finding the right tools
a. How to find the right test automation tool
b. Next steps: building your test automation strategy

Introduction to data-driven testing with Agilitest

Mathilde Lelong — Wed, 07 Sep 2022 13:54:41 +0000

Automating software tests is an essential practice for setting up an Agile development process. In particular, the non-regression tests must be done in an automated way to free up time for the validation teams to automate new tests on the latest functionalities, or even to carry out exploratory testing.

Since we are talking about automation, let's tackle a fundamental issue: the variability of tests using a** data file.** Welcome to what is called data-driven testing in software development.

What is data-driven testing ?

Data-driven testing (or DDT) is a software testing methodology that uses an array of conditions to populate the test's input data, as well as its expected output data, and its environment and control variables.

The most simple way to set up DDT is to create a table in CSV format and assign one or more columns to input parameters and output data. Each row will represent a data set for an iteration of the test. This is precisely what we are going to do. It is also called table-driven testing or parameterized testing.

Data Driven Testing is strategic because testers frequently have multiple data sets for a single test and creating individual tests for each data set can be time-consuming and really challenging. Data driven testing helps separate data from test scripts and the same test scripts can be executed for different combinations of input test data. This way, test results can be generated efficiently.

Data-driven testing with Agilitest

Create a project with a main ATS script

To get started, you need to create a new project or open an existing project.

We are going to create a main ATS script that will be used to hook the DDT dataset to the actions of the test. This ATS script will contain a Sub-script line which is configured with two basic data: the name of the script to open and the path to the CSV file.

Create a CSV (or JSON) data file

You must therefore create a CSV file with the New component button. The names of these files must match the names called in the main ATS script. To do this, simply drag and drop the CSV file into the CSV file path box and the path will be relative to the root of the project, for example: assets:///data/data.csv

The CSV file is created and edited in Agilitest. Then you can edit this file with a classic text editor as long as you respect its syntax (CSV encoded in UTF-8 with comma field separator, double-quotes framing character, and CRLF line breaks). The file can also be generated by an external routine.

Agilitest also allows you to use a remote CSV file by entering a URL address instead of assets:///data/data.csv. The CSV file can then be generated dynamically by a small web application, or simply remain static remotely.

The fields of your CSV files can contain texts to be entered on the keyboard, text to be recognized on the application, or even attributes to recognize on the page (CSS classes or id, desktop attributes, etc.). Finally, they can contain values to compare with fields in your application.

Create a secondary ATS script

Read full article here, an article by Paul Chevalier.