Web GUI testing is a quality assessment practice aimed at evaluating the functionality of web applications from the perspective of its end users. While prior studies have explored the technical challenges of automated Web GUI testing, fewer works have explored how this practice is applied in real-world web apps. This study aims to investigate the adoption, characteristics, and maintenance of automated web GUI testing practices in open-source web applications, focusing on identifying trends and providing actionable insights for researchers and practitioners. We conducted a large-scale empirical analysis of 472 web applications on the GitHub platform, developed in Java , JavaScript , Python , and TypeScript . These projects use popular browser automation frameworks like Selenium , Playwright , Cypress , and Puppeteer . The study involved examining project characteristics and analyzing the co-evolution and maintenance of automated web GUI tests over time. Our findings empirically document automated web GUI testing adoption patterns in open-source projects, providing insights into the practical drivers behind both initial framework adoption and migration between different testing frameworks. Projects incorporating these tests generally show higher community engagement and consistent maintenance efforts. The analysis reveals that Web GUI tests tend to co-evolve with the underlying applications, reflecting their integration into the development lifecycle. The study provides valuable insights into the prevalence and maintenance of Web GUI testing, highlighting practical implications for improving testing practices. Our findings can guide further research on the matter and support practitioners in enhancing their testing strategies.

Performance testing is essential for ensuring that web applications remain responsive and reliable under varying workloads. Defining meaningful workloads remains a key challenge in performance testing, with existing solutions requiring deployed systems to collect real user behaviors, offering limited support for automated data dependency management, and lacking support for emerging protocols like WebSocket. Our previous work introduced E2E-Loader, a novel approach that supports the definition of performance testing workloads by exploiting existing End-to-End functional test cases, enabling workload creation even before system deployment. While initial results demonstrated technical feasibility, the practical utility and industrial readiness of automated workload generation remained unvalidated in real-world software engineering contexts. In this paper, we present E2E-Load-er++, an enhanced version of our original tool, with significant improvements to dependency detection capabilities, and provide the first rigorous industrial evaluation of our semi-automated performance testing workload generation approach. The comprehensive empirical assessment we conducted involved controlled experiments with professional software engineers working on proprietary industrial applications, aimed at measuring both technical effectiveness and practical impact of E2E-Loader++ on performance testing workflows. Results demonstrate substantial productivity gains: compared to manual approaches, E2E-Loader++ achieved a 62% reduction rate in workload creation time and a 37% reduction rate in the number of required user interactions per minute, while preserving comparable workload quality. Moreover, the tool received strong usability ratings and practitioner acceptance, confirming its potential for real-world adoption in industrial performance testing workflows.

Performance testing is crucial to ensuring that web applications meet user expectations under varying workloads. Activities such as stress, load, and smoke testing are designed to simulate different kinds of simultaneous user interactions and assess system behavior. Despite its recognized importance in quality assurance of large-scale web-based systems, witnessed by numerous studies proposing solutions to support these activities, the real-world adoption and evolutionary dynamics of performance tests have received limited attention in the literature. To fill this gap, we analyzed 77 open-source web projects using Apache JMETER and LOCUST. Our study investigates how performance tasks are performed (adoption time, load design, types of tasks), the characteristics of projects that adopt them, and their longterm maintenance. Our findings reveal that performance tests in open-source projects are simple, with a focus on singleuser behaviors and minimal requests, and most tests have low concurrency. Load tests are the most common, followed by smoke and stress tests. Projects with performance tests tend to be larger and more actively maintained. However, tests are mostly long-lived but rarely updated, suggesting potential risks to their relevance and coverage over time. Finally, by creating a taxonomy of performance test changes, we observe recurring patterns of modifications, including workload adjustments, network request changes, and updates to system monitoring.

End-to-End (E2E) testing is a critical practice for ensuring the functionality and reliability of software applications in real-world scenarios. The two main approaches within E2E testing are GUI testing and Performance testing. Despite their importance, their adoption remains limited due to several challenges, including limited automation in test generation, high fragility that complicates maintenance, and the lack of comprehensive datasets. These obstacles hinder both industrial adoption and academic progress. My Ph.D. research carried out in collaboration with an industry partner, addresses these challenges by proposing a solution to automate the generation of web workloads and estimate the fragility of web GUI tests. However, the work also highlighted the persistent lack of a comprehensive dataset. To fill this gap, I have developed a curated dataset of open-source repositories that allow these approaches to be explored and open up new avenues of research.

Performance testing is essential for ensuring that web applications deliver a satisfactory user experience under varying workloads. Crafting meaningful workloads is a key challenge, addressed in previous research by analyzing system logs that reflect real user behaviors. However, these approaches face limitations: they require the system under test to be deployed to collect usage data, offer limited automation for managing data dependencies, and often lack support for modern protocols like Websocket. We present E2E-LOADER, a tool for automating the generation of performance testing workloads for Web Applications. E2E-LOADER leverages existing End-to-End (E2E) GUI-level test cases to create workloads, allowing its use at early stages of development before user data is available. The tool fully supports HTTP and WEBSOCKET-based interactions and includes customizable heuristics to detect data dependencies automatically. E2E-LOADER has been evaluated in previous research in an industrial case study, demonstrating that it produces workloads comparable in quality to those manually designed by practitioners, with significantly less effort and time. The tool and its source code are openly available to support researchers and practitioners in advancing performance testing practices. A screencast showcasing E2E-LOADER in function is available at https://youtu.be/pDWNlllkAhU.

End-to-end (E2E) testing is a software validation approach that simulates realistic user scenarios throughout the entire workflow of an application. In the context of web applications, E2E testing involves two activities: Graphic User Interface (GUI) testing, which simulates user interactions with the web app’s GUI through web browsers, and performance testing, which evaluates system workload handling. Despite its recognized importance in delivering high-quality web applications, the availability of large-scale datasets featuring real-world E2E web tests remains limited, hindering research in the field.To address this gap, we present E2EGit, a comprehensive dataset of non-trivial open-source web projects collected on GitHub that adopt E2E testing. By analyzing over 5,000 web repositories across popular programming languages (Java, JavaScript, TypeScript and Python), we identified 472 repositories implementing 43,670 automated Web GUI tests with popular browser automation frameworks (Selenium, Playwright, Cypress, Puppeteer), and 84 repositories that featured 271 automated performance tests implemented leveraging the most popular open-source tools (JMeter, LoCust). Among these, 13 repositories implemented both types of testing for a total of 786 Web GUI tests and 61 performance tests. The dataset is available on Zenodo (DOI: 10.5281/zenodo.14234731).

Online property booking platforms are widely used and rely heavily on consistent, up-to-date information about accommodation facilities, often sourced from third-party providers.However, these external data sources are frequently affected by incomplete or inconsistent details, which can frustrate users and result in a loss of market.In response to these challenges, we present an industrial case study involving the integration of Large Language Models (LLMs) into CALEIDOHOTELS, a property reservation platform developed by FERVENTO.We evaluate two well-know LLMs in this context: Mistral 7B, fine-tuned with QLoRA, and Mixtral 8x7B, utilized with a refined system prompt.Both models were assessed based on their ability to generate consistent and homogeneous descriptions while minimizing hallucinations.Mixtral 8x7B outperformed Mistral 7B in terms of completeness (99.6% vs. 93%), precision (98.8% vs. 96%), and hallucination rate (1.2% vs. 4%), producing shorter yet more concise content (249 vs. 277 words on average).However, this came at a significantly higher computational cost: 50GB VRAM and $1.61/hour versus 5GB and $0.16/hour for Mistral 7B.Our findings provide practical insights into the trade-offs between model quality and resource efficiency, offering guidance for deploying LLMs in production environments and demonstrating their effectiveness in enhancing the consistency and reliability of accommodation data.

When teaching Programming and Software Engineering in Bachelor’s Degree programs, the emphasis on creating functional software projects often overshadows the focus on software quality, a trend consistent with ACM curricula recommendations. Dedicated Software Engineering courses take typically place in the later stages of the curriculum, and allocate only limited time to software quality, leaving educators with the difficult task of deciding which quality aspects to prioritize. To educate students on the importance of developing high-quality code, it is important to introduce these skills as part of the assessment criteria. To this end, we have implemented a pipeline based on advanced frameworks such as ArchUnit and SonarQube. It was successfully tested on a class of students engaged in the Object Oriented Programming course, demonstrating its usefulness as a resource for educators and providing some concrete evidence of quality problems in student projects.

Automated end-to-end web tests are typically implemented as scripts that leverage dedicated libraries to simulate user interactions with web pages in a remotely controlled web browser. These tests are crucial for ensuring the functionality and reliability of web applications, as well as confirming non-regression on new releases. Still, as web applications evolve, maintaining the end-to-end test code is one of the main challenges faced by practitioners. Indeed, even minor alterations in web pages can easily break existing test code, rendering it unable to correctly locate and interact with web page elements. This issue is commonly known as web test fragility.

Performance testing is crucial to assess that Web Applications provide a good user experience under different workloads. A workload reproduces the interactions of a number of concurrent users with the system, to observe its actual behavior under stress.Defining meaningful workloads is a key challenge in performance testing, and many solutions have been proposed in the literature to support testers in this task, mostly based on analyzing system logs describing real user behaviors. However, in our industrial and academic experience, we found that these solutions present some limitations, hindering performance testers’ applicability and productivity. In particular, (I) they require the system under test to be actually deployed in order to collect real user behaviors; (II) they offer limited support to automated management of data dependencies; (III) they lack support for emerging protocols, such as WebSocket.In this paper, we present E2E-Loader, a novel approach to automate the design of performance testing workloads for web applications. E2E-Loader generates workloads by exploiting existing End-to-End functional test cases and can be used at an early stage, before the system is deployed and actual user behaviors have been collected. Our solution features full WebSocket support and includes a customizable heuristic to automatically detect data dependencies.We empirically evaluate the proposed approach in an industrial case study. Results are promising and show that the workloads generated with E2E-Loader are generally comparable to those that were manually created by practitioners working with our industrial partner while requiring a fraction of the time to be obtained. Finally, we make E2E-Loader and its source code publicly available for interested practitioners and researchers.