Abstract—This paper addresses one of the major problems of SOA software development: the lack of support for testing complex service-oriented systems. The research community has developed various means for checking individual Web services but has not come up with satisfactory solutions for testing systems that operate in service-based environments and, therefore, need realistic testbeds for evaluating their quality. We regard this as an unnecessary burden for SOA engineers. As a proposed solution for this issue, we present the Genesis2 testbed generator framework. Genesis2 supports engineers in modeling testbeds and programming their behavior. Out of these models it generates running instances of Web services, clients, registries, and other entities in order to emulate realistic SOA environments. By generating real testbeds, our approach assists engineers in performing runtime tests of their systems and particular focus has been put on the framework’s extensibility to allow the emulation of arbitrarily complex environments. Furthermore, by exploiting the advantages of the Groovy language, Genesis2 provides an intuitive yet powerful scripting interface for testbed control. I.

Abstract. Service-oriented architectures propose loosely coupled interacting services as building blocks for distributed applications. Since distributed services differ from traditional monolithic software systems, novel testing methods are required. Based on the specification of a service, we introduce an approach to automatically generate test cases for blackbox testing to check for conformance between the specification and the implementation of a service whose internal behavior might be confidential. Due to the interacting nature of services this is a nontrivial task.

Abstract—Mixed service-oriented systems composed of human actors and software services build up complex interaction networks. Without any coordination, such system may exhibit undesirable properties due to unexpected behavior. Also, communications and interactions in such networks are not preplanned by top-down composition models. Consequently, the management of service-oriented applications is difficult due to changing interaction and behavior patterns that possibly contradict and result in faults from varying conditions and misbehavior in the network. In this paper we present a self-adaptation approach that regulates local interactions to maintain desired system functionality. To prevent degraded or stalled systems, adaptations operate by link modification or substitution of actors based on similarity and trust metrics. Unlike a security perspective on trust, we focus on the notion of socially inspired trust. We design an architecture based on two separate independent frameworks. One providing a real Web service testbed extensible for dynamic adaptation actions. The other is our self-adaptation framework including all modules required by systems with self- * properties. In our experiments we study a trust and similarity based adaptation approach by simulating dynamic interactions in the real Web services testbed. Index Terms—Service-oriented collaboration, monitoring, selfadaptation, web service testbed, dynamic trust

Abstract. The modularity of Service-oriented Architectures (SOA) allows to establish complex distributed systems comprising e.g., services, clients, brokers, and workflow engines. A growing complexity, however, automatically increases the number of potential fault sources which have effects on the whole SOA. Fault handling mechanisms must be applied in order to achieve a certain level of robustness. In this paper we do not deal with fault-tolerance itself but regard the problem from a different perspective: how can fault-tolerance be evaluated? We argue that this can be best done by testing the system at runtime and observing its reaction on occuring faults. Though, engineers are facing the problem of how to perform such tests in a realistic manner in order to get meaningful results. As our contribution to this issue we present an approach for generating fault injection testbeds for SOA. Our framework allows to model testbeds and program their behavior, to generate running instances out of it, and to inject diverse types of faults. The strength of our approach lies in the customizability of the testbeds and the ability to program the fault-injecting mechanisms in a convenient manner. 1

Abstract. Services are loosely coupled interacting software components. Since two or more services are usually composed to one software system, the behavior of an implemented service should not differ to its specification. Therefore we propose an approach to test, if the implementation contains unspecified behavior. Due to the interacting nature of services this is a nontrivial task. 1

Open Web-based and social platforms dramatically influenced models for work. The emergence of service-oriented systems has paved the way for a new computing paradigm that not only applies to software services but also human actors. This work introduces a novel programming model for Open Enterprise Systems whose interactions are governed by dynamics. Compositions of humans and services often expose unexpected behavior because of sudden changes in load conditions or unresolved dependencies. We present a middleware for programming and adapting complex serviceoriented systems. Our approach is based on monitoring and real-time intervention to regulate interactions based on behavior policies. A further challenge addressed by our approach is how to simulate and adapt behavior rules prior to deploy polices in the real system. We outline a testing approach to analyze and evaluate the behavior of services.

Middleware for Web service compositions, such as BPEL engines, provides the execution environment for services as well as additional functionalities, such as monitoring and self-tuning. Given its role in service provisioning, it is very important to assess the performance of middleware in the context of a Serviceoriented Architecture (SOA). This paper presents SOABench, a framework for the automatic generation and execution of testbeds for benchmarking middleware for composite Web services and for assessing the performance of existing SOA infrastructures. SOABench defines a testbed model characterized by the composite services to execute, the workload to generate, the deployment configuration to use, the performance metrics to gather, the data analyses to perform on them, and the reports to produce. We have validated SOABench by benchmarking the performance of different BPEL engines. 1

Abstract—This paper addresses one of the major problems of SOA software development: the lack of support for testing complex service-oriented systems. The research community has developed various means for checking individual Web services but has not come up with satisfactory solutions for testing systems that operate in service-based environments and, therefore, need realistic testbeds for evaluating their quality. We regard this as an unnecessary burden for SOA engineers. As a proposed solution for this issue, we present the Genesis2 testbed generator framework. Genesis2 supports engineers in modeling testbeds and programming their behavior. Out of these models it generates running instances of Web services, clients, registries, and other entities in order to emulate realistic SOA environments. By generating real testbeds, our approach assists engineers in performing runtime tests of their systems and particular focus has been put on the framework’s extensibility to allow the emulation of arbitrarily complex environments. Furthermore, by exploiting the advantages of the Groovy language, Genesis2 provides an intuitive yet powerful scripting interface for testbed control. I.

Abstract. Large-scale and complex distributed systems are increasingly implemented as SOAs. These comprise diverse types of components, e.g., Web services, registries, workflow engines, and services buses, that interact with each others to establish composite functionality. The drawback of this trend is that testing of complex SOAs becomes a challenging task. During the development phase, testers must verify the system’s correct functionality, but often do not have access to adequate testbeds. In this paper, we present an approach for solving this issue. We combine the Genesis2 testbed generator, that emulates SOA environments, with Cafe, a framework for provisioning of component-based applications in the cloud. Our approach allows to model large-scale service-based testbed infrastructures, to specify their behavior, and to deploy these automatically in the cloud. As a result, testers can emulate required environments on-demand for evaluating SOAs at runtime. 1

Abstract—One of the key concepts of service-oriented computing is dynamic binding which favors on-demand integration of services into a running system. Companies can outsource tasks to external partners by using their services and are able to switch over to alternatives at runtime. However, this flexibility comes at a high cost because it complicates the testing process significantly. The major problem with external services is their restricted usability for testing purposes, due to costs or because policies forbid trial invocations. In this paper we present our approach to solve this issue by generating automatically testbeds which emulate external services. Based on previous work on testbed generation, we have developed a technique for intercepting Web service invocations in Java-based systems, generating emulated replicas at runtime, and redirecting the invocations transparently. We describe the concepts of our approach, its applicability, and limitations. I.