Software testing integration testing tutorials and videos

Don’t Do E2E Testing

Software Testing Magazine — Mon, 09 Dec 2024 16:55:30 +0000

End-to-end (E2E) testing is one of the more common approaches to testing software, but it is complex, fragile expensive and low quality. As soon as we accept that the best way to test our system is to deploy it all together, with everything else that it interacts with and then try broad-brush interactions with the whole lot, we have lost control. To do a great job of testing software, we need much finer-grained control, and so we need to reject E2E testing. Great automated testing depends on us controlling the variables, and Acceptance Test-Driven Development (ATDD), Test-Driven Development (TDD) and Behavior-Driven Development (BDD) rely on our ability to synthesize inputs and collect outputs from our system so that we can test it. E2E testing stops us from doing that. In this video, Dave Farley, author of best-selling books “Continuous Delivery” and “Modern Software Engineering”, discusses the problems of end-to-end testing and how best to overcome them with a more effective and more efficient approach. Video producer: https://gotocon.com/

The post Don’t Do E2E Testing first appeared on Software Testing Magazine.

A Revolution in Integration Testing of Microservices

Software Testing Magazine — Thu, 23 May 2024 14:18:57 +0000

Testing strategies for modern software architectures are evolving. As we transition from monolithic structures to team-sized microservices with crisp APIs aligned to bounded contexts, we encounter more stable testing surfaces. This shift leads many high-performing teams to favor integration tests over fine-grained, brittle unit tests. These integration tests, which are closer to the functional requirements, prove more trustworthy and are more resilient to internal refactoring, though they may come with a higher cost. This presentation addresses the primary challenges of integration testing in the microservices era: cognitive overload, test isolation, and test execution speed. Join the testing revolution and discover how to enhance your software development team microservices testing efficiency and effectiveness. Video producer: https://www.devoxx.com/ Further reading: Automated Testing Strategy for a Microservices Architecture

The post A Revolution in Integration Testing of Microservices first appeared on Software Testing Magazine.

Challenges in Testing CRM Integration with Third-Party Systems

Software Testing Magazine — Fri, 03 Nov 2023 10:25:08 +0000

For many modern businesses, integrating Customer Relationship Management (CRM) systems with third-party platforms is crucial for seamless operations. However, testing CRM and navigating this process comes with challenges. If you’re considering this undertaking, this post will help you prepare for the challenges in testing CRM integration and tackle them effectively. Author: Elisabeth Green So, let’s unravel these challenges and equip ourselves with practical solutions to forge robust connections between CRM and third-party applications. Understanding CRM Integration Initially, the concept may feel a bit murky for some. So, a brief introduction may be in order. “CRM integration” refers to connecting a Customer Relationship Management (CRM) system with other third-party applications or software. The main purpose is to allow these different systems to work together smoothly. That is crucial because it enables a seamless flow of information and data between the CRM and other tools or platforms. For instance, it ensures that customer details and interactions recorded in the CRM are accessible and usable in other business areas, like marketing or sales tools. This seamless communication is essential for businesses to have a unified view of their customers and provide better service. Data might be scattered across various systems without integration, leading to inefficiencies and potential inaccuracies. Therefore, the process must be approached with due care and diligence. Challenges in Testing CRM Integration With introductions in order, one may face three main challenges during this process. In no particular order, these are the following. #1 Data Accuracy and Quality First, as mentioned [...]

The post Challenges in Testing CRM Integration with Third-Party Systems first appeared on Software Testing Magazine.

Effective Software Testing in Microservices Systems

Software Testing Magazine — Mon, 04 Sep 2023 14:53:50 +0000

The needs for test automation changes in a microservices architecture compared to a monolith or traditional Service Oriented Architecture (SOA). Even more so if we combine microservices with continuous delivery. What and how we choose to test has a large impact on how successful we will be with microservices. If we choose wisely, we can take advantage of the software architecture to get good test coverage and confidence relative to the effort. This talk gives guidance about effective levels to software testing at and how to use DDD techniques to guide the effort. Video producer: https://ndcoslo.com/ Further reading: Automated Testing Strategy for a Microservices Architecture

The post Effective Software Testing in Microservices Systems first appeared on Software Testing Magazine.

Testing in Production at LinkedIn

Software Testing Magazine — Tue, 29 Jun 2021 14:29:46 +0000

If you cannot ship to production with confidence, write tests until you can! This video will help you design a testing strategy for your products. Keep writing great tests! The video presents all the testing strategies used at LinkedIn to confidently ship features to 500M members. The flagship app linkedin.com ships 1000+ commits per week from 300+ unique contributors. Besides flagship, LinkedIn has other products that spread across 5000 codebases. Here are the topics discussed in this video: – testing in production – canaries and feature flags – testing microservices – testing machine learning models – testing search and relevance algorithms – resilience engineering Video producer: http://www.devoxx.com/

The post Testing in Production at LinkedIn first appeared on Software Testing Magazine.

How To Perform Exhaustive Testing

Software Testing Magazine — Mon, 18 Jan 2021 16:29:27 +0000

Exhaustive testing is a type of software testing approach where all the behaviors of a system are explored during the tests. If this approach is good in theory, it is not feasible in most testing contexts where time and resources are limited. This article presents the distinguishing characteristics of exhaustive testing and explain how to perform it. Author: Nataliia Syvynska, TestMatick, https://testmatick.com/ A good deal of something is not always considered an excellent indicator of quality. Any self-respecting software tester is a true protectionist who always strives to ensure that the software is of the highest quality. It is a good trait, but sometimes it can bring undesired results. To prevent this, it is necessary to become familiar with such a concept as “exhaustive testing”. This material will be a good help in setting professional criteria and methods for drawing up a universal software testing plan. A frequent piece of advice that you can find in articles for aspiring testers is: “You should always test everything you see, using all the methods you know”. From the software quality assurance’s point of view, this approach is not considered bad or wrong, especially when it comes to programs for a nuclear power station or spacecraft. Nevertheless, in the era of widespread commercial testing for a corporate (less often, government) order, with a specific budget, this can become a destructive phenomenon. By increasing the boundaries of the testing field and the number of tests to infinity, a quality assurance (QA) engineer brings the time for these [...]

The post How To Perform Exhaustive Testing first appeared on Software Testing Magazine.

Integration Testing a Cloud Native Application with JavaScript

Software Testing Magazine — Mon, 31 Aug 2020 15:29:01 +0000

This talk will take you through the challenge of testing a cloud-native application that uses MQTT (a pub/sub protocol), webhooks and REST to interact with IoT devices on top of AWS. It uses services which cannot be run on a developers machine for testing, so it was needed to develop a test setup which enables us to continuously test against real services. A Behavior-Driven Development (BDD) approach was used to write the tests to make the progress in the project self-documenting and the test immune against effects of big refactorings. This provided an extra set of challenges since these tests are written in a serial manner, which does not fit the asynchronous execution of the real solution. You will learn how all this is done using JavaScript and that this is not only an interesting challenge but uses tests that behave like real users, and that there is an Ops person in all of us. Video producer: http://oredev.org/

The post Integration Testing a Cloud Native Application with JavaScript first appeared on Software Testing Magazine.

Integration & End-to-End Testing with TestContainers and JUnit 5

Software Testing Magazine — Mon, 09 Dec 2019 16:16:08 +0000

The TestContainers library facilitates simple start up of a service dependencies, i.e. Postgres, Redis in throwaway Docker containers. This open source library works over Docker API and has a list of features which significantly improve a software developer experience. Some of these features are: * Docker environment autodiscovery * mapping to random unique host ports * easy Docker network configuration and sharing * waiting strategies for a ready status – containers cleanup guarantees * ready to use specific containers * JUnit 5 integration This talk discusses the above-mentioned features with code samples. The demo part shows integration tests for two services. They use Postgres and Redis under the hood, respectively. Another demo shows how it is possible to run both of the services in Docker containers at the same time together with their dependencies and to perform a simple end-to-end test. Video producer: https://voxxeddays.com/

The post Integration & End-to-End Testing with TestContainers and JUnit 5 first appeared on Software Testing Magazine.