Microservices offer flexibility and scalability, but their decentralized and fast-changing nature makes it difficult to maintain consistent and meaningful test coverage, particularly at the level of service endpoints. Services are developed independently, logic is spread across multiple layers, and execution paths vary widely based on input and control flow. As a result, automated testing is hard to scale, and manual testing is time-consuming and error-prone. Recent advances in large language models present a promising opportunity for generating tests automatically. However, existing approaches often rely on providing the entire source code as input, which can exceed model limitations and include unrelated logic that reduces test quality. This paper proposes a structured approach that uses interprocedural control flow graphs to guide language models in generating accurate, maintainable endpoint tests that better reflect the complexity of modern microservice systems.
Microservices decompose systems into small, independent services, offering benefits that have led to widespread adoption. However, their distributed nature, diverse technology stacks, and independent development introduce significant challenges in ensuring system reliability. While numerous automated testing approaches have been proposed, only a few manually implemented test suites are openly available for comparison. To the best of our knowledge, no extensive benchmark test suites for component and integration testing of microservices are publicly accessible. This work addresses this gap by providing two benchmark test suites - one on the component and one on the integration level - developed within a case study on the well-established TrainTicket microservice system. The test suites were initially implemented by four independent teams and later unified by the authors, yielding 1,365 component and 210 integration tests in total. They uncover 51 faults, 8 untypical design decisions, and 1 fallback-related issue within the system. We further manually analyze the detected faults and compare them with existing fault taxonomies, identifying 11 gaps in current classifications. Additionally, we provide insights into the relation between the test case type and fault type it detected. Our insights can support future evaluations of new approaches and foster the development of more comprehensive fault models for microservice systems.
In distributed edge computing, effective resource management is key. While orchestration offers centralized control, choreography provides a decentralized alternative more suited to dynamic, resource-constrained environments-especially within emerging serverless paradigms. This study investigates choreography techniques for serverless edge computing, analyzing coordination strategies, communication models, and application domain. We conducted a Multivocal Literature Review (MLR), selecting 12 peer-reviewed studies from 332 sources (200 gray, 122 white literature). Three main choreography approaches emerged: structured, scheduling-based, and hybrid. End-to-end communication was twice as common as broadcasting. IoT was the most prevalent domain, consistent with the dominant use of lightweight edge devices. Choreography offers performance and flexibility benefits but remains underexplored. Key limitations include resource management challenges, underscoring the need for further research into scalable, decentralized coordination models for the edge.
Proactive resource scaling in container orchestration platforms like Kubernetes is essential to maintain application responsiveness under fluctuating workloads. Our study aims to explore predictive auto-scaling by forecasting CPU utilization from service request volumes using statistical and neural-networkbased time series models. We applied 29 forecasting techniques to production traces from a FinTech system, evaluating each model's accuracy using nine metrics: MAE, RMSE, SMAPE, MASE, RMSSE, $R^{2}$, NMAE, and NRMSE, and assessing the actual prediction distance. Experimental results show that neural network models, particularly Transformer and GRU, consistently exhibited strong accuracy performance with high explanatory power ($R^{2}$ values above 0.88) and relatively low mean absolute errors (MAE). However, several statistical models, specifically AutoTheta, FFT, and Exponential Smoothing, achieved higher accuracy than neural approaches, and in particular Exponential Smoothing, was the best performing model scoring the lowest MAE (332.824) and highest $R^{2}$ (0.961). Our findings demonstrate the viability of lightweight forecasting-driven scaling and suggest practical improvements for auto-scaling reliability in Kubernetes environments. The source code we used in this study is available as open-source on github.
This empirical study investigates industry awareness about the adoption of green practices across five modern software architectures: Microservices, Event-Driven, Serverless, Machine Learning, and Generative AI. Using an approach that combined surveys (109 responses) and interviews (19 professionals) from the industry, we gathered data to understand awareness of green practices throughout the design, development and maintenance of software architectures. Our findings reveal that while software professionals understand green software concepts, practical implementation lags due to higher priority given to performance, cost, accuracy, and reliability. Each architecture has specific energy challenges: Microservices struggles with resource allocation and excessive communication; Serverless faces over-invocation and cold-start issues; Event-Driven systems struggle with excessive triggering; Machine Learning systems have challenges with inadequate maintenance of model health and lack of awareness in compute requirements between training and inference phases; and Generative AI consumes high energy due to model size and algorithmic complexity. We identify both architecture-specific and common operational strategies for reducing energy consumption, establishing a foundation for future work in sustainable development in resource-intensive architectures.
