Distributed vivo testing software applications
Indeed, they can be executed on an unbounded combination of devices, operating systems, settings, and user preferences since apps may also interact with other apps or devices that were not even available when they were released. This results in a virtually infinite set of configurations that might be responsible for unexpected behaviors which can be validated in-house only to a negligible extent.
To address this challenge, this paper discusses the application of in-vivo testing to mobile apps. Our approach is different from prior work in that we are actively testing during execution, as opposed to passively monitoring the application or conducting tests in the user environment prior to operation.
We discuss new extensions to the existing in vivo testing framework called Invite and present empirical results that show the performance overhead improves linearly with the number of clients. Documents: Advanced Search Include Citations. Codefresh is a distributed, multi-cloud platform, that includes tens of different services. Part of them are related to user management, workflow management and different business logics and integration forms.
The system should be able to recover itself to manage, even if some services are not functioning. We have fully automated scenarios for every single service.
Most of the effort is on testing the service from a unit test perspective. I run unit tests and end-to-end tests, trying to isolate as much as possible from the rest of the system. Kind of a smoke test, unintegration environment.
We have an integration environment before the service is deployed and tested. We continue testing our system in production. Intensive unit testing and API testing for single services. Our system is a heavily distributed one, built from feature services.
Originally, it was a big monolith system and we started taking out parts of it, transforming it into microservices. Complexity is distributed into many small services. The problems coming from the monolithic system were eliminated but new problems emerged from the distributed system. For processing a request, we use a maximum of service calls and even when you call a service, it calls only one other service.
When you start our application, the frame of the app is served by the monolithic system and it also serves as an integration platform.
Every page you load is an iframe that renders content from a service. We use a lot of message queues. In order to make the system more resilient, we make the communication async using RabbitMQ with Compose. We follow the test pyramid, actively testing the system. We have unit tests, integration tests and functional tests. One service has unit tests and also integration tests where the service can test its components, such as the database. It also goes further to end-to-end tests where the API is tested.
Our infrastructure is duplicated. Every service has a staging and production version. The problem with the test pyramid is that as you go up and reach functional tests and the more the app is covered, the more the system becomes more rigid. I work with a variety of clients, so I don't have one answer.
Generally, they fall into 3 buckets:. The main one I'm working with here is a financial org, and so you see the main monolith, and we've broken out the bits that have scaling and change pressures. These are offline reconciliation and regulatory exposed pieces. Submitting the report failed. Please, try again. If the error persists, contact the administrator by writing to support infona. You can change the active elements on the page buttons and links by pressing a combination of keys:.
I accept. Polski English Login or register account. Chu, M. Abstract The in vivo software testing methodology focuses on testing live applications by executing unit tests throughout the lifecycle, including after deployment. The motivation is that the "known state " approach of traditional unit testing is not always sufficient; deployed applications rarely operate under such conditions, and it may be more informative to perform the testing in live environments.