Eros Magri

Model-Driven testing for web applications using abstract state machines

The increasing diffusion and importance of Web Applications has led to strict requirements in terms of continuity of the service, because their unavailability can lead to severe economic losses. Techniques to assure the quality of these applications are thus needed in order to identify in advance possible faults. Model-driven approaches to the testing of Web Applications can provide developers with a way of checking the conformance of the actual Web Application with respect to the model built from the requirements. These approaches can be used to automatically generate from the model a set of test cases satisfying certain coverage criteria, and thus can be integrated in a classical test driven development process. In this paper we present an automated technique for Web Application testing using a model-driven approach. We present a way of modeling Web Applications by Abstract State Machines (ASMs), and a process for generating automatically from the model a concrete test suite that is executed on the Web Application under test in order to check the conformance between the application and the model.

Conflict detection in security policies using Semantic Web technology

The design of efficient and effective techniques for security policy analysis is a crucial open problem in modern information systems. Significant attention has been dedicated in the past to the use of logical tools for the analysis of security policies, but this work has produced a limited impact on enterprise information systems. Important reasons of the limited success of past research were the difficult integration of these approaches with the technological scenario and the limited scalability of many proposals. Nowadays Semantic Web tools are increasingly used in modern information systems. We show how the tools provided by Semantic Web and ontology management technologies offer an adequate basis for the realization of techniques able to support conflict analysis in security policies. Based on the use of these techniques, we propose a solution for two different variants of conflict analysis: (a) Policy Incompatibility, and (b) Separation of Duty Satisfiability. Experiments that test the techniques on large security policies demonstrate the scalability of the approach.

On the notion of redundancy in access control policies

The evolution of information systems sees an increasing need of flexible and sophisticated approaches for the automated detection of anomalies in security policies. One of these anomalies is redundancy, which may increase the total cost of management of the policies and may reduce the performance of access control mechanisms and of other anomaly detection techniques. We consider three approaches that can remove redundancy from access control policies, progressively reducing the number of authorizations in the policy itself. We show that several problems associated with redundancy are NP-hard. We propose exact solutions to two of these problems, namely the Minimum Policy Problem, which consists in computing the minimum policy that represents the behaviour of the system, and the Minimum Irreducible Policy Problem, consisting in computing the redundancy-free version of a policy with the smallest number of authorizations. Furthermore we propose heuristic solutions to those problems. We also present a comparison between the exact and heuristics solutions based on experiments that use policies derived from bibliographical databases.

Extending Coverage Criteria by Evaluating Their Robustness to Code Structure Changes

Code coverage is usually used as a measurement of testing quality and as adequacy criterion. Unfortunately, code coverage is very sensitive to modifications of the code structure, and, therefore, the same test suite can achieve different degrees of coverage on the same program written in two syntactically different ways. For this reason, code coverage can provide the tester with misleading information.

AURORA: AUtomatic RObustness coveRage Analysis Tool

Code coverage is usually used as a measurement of testing quality and as adequacy criterion. Unfortunately, code coverage is very sensitive to modifications of the code structure, and, therefore, we can achieve the same degree of coverage with different testing effort by writing the same program in syntactically different ways. For this reason, code coverage can provide the tester with misleading information. In order to understand how a testing criterion is affected by code structure modifications, we have introduced a way to measure the sensitivity of coverage to code changes by means of code-to-code transformations. However the manual execution of the robustness analysis is tedious, time consuming and error prone. In order to solve these issues we present AURORA, a tool that automates the robustness analysis process and leverages the capabilities offered from several existing tools. AURORA has an extendible architecture that concretely supports the tester in the execution of the robustness analysis. Due to this extendible architecture, each user can personalize the robustness analysis to his/her needs. AURORA allows the user to add new transformations by using TXL, which is a programming language specifically designed to support source transformation tasks. It performs the coverage evaluation by using existing code coverage tools and is based on the use of the JUnit framework.

Evolutionary testing of PHP web applications with WETT

One of the current core requirements of web applications is the continuity of the service, because loss in availability can lead to severe economic losses. This is the main reason behind the growing interest in web application testing that offers to researchers several challenges, due to the peculiar nature of these applications. Several classical testing techniques have been extended to deal with web testing. In this paper we propose to extend to web application testing a recent search-based approach that optimizes the generation of the whole test suite. This approach has several advantages over common approaches that optimize the generation of a single test case at a time. We show the technological challenges we have had to face, the architecture of the tool WETT we have developed, and some preliminary results of the experiments.