Agile manifesto defines principles for a light-weight software development process aiming at an improved customer satisfaction. Automated testing plays an important role in fulfilling these principles, because it enables efficient execution of test scripts for checking the quality of delivered software. However, the implementation and the maintenance of the test scripts can be very tedious and error-prone. In order to deal with that, model-based testing extends the automated test execution by test design and test implementation. Thus, model-based testing can speed up the test automation and improve the maintenance of test scripts. Nevertheless, introducing model-based testing requires some initial and some continual efforts, like creating test models, buying or developing tools, etc. In this talk, we will discuss how model-based testing can support agile development without conflicting with the principles of agile manifesto.
As the complexity of software rises, novel software development techniques are required in order to cope with the technical and the organizational challenges in the development process. Model-based software development (MBSD) proposes using abstract models for better communication, for maintainable software specification and for efficient code generation. In this context, model-based testing (MBT) proposes using models for automating some of the testing activities, e.g. test case generation, evaluation of test results, which are tedious and error-prone tasks if they are manually done. In order to profit from model-based techniques in development process, however, some efforts must be expended, e.g. for introducing tools, for training developers and testers, for creating and maintaining models, etc. That is why MBSD is said to be a “heavyweight” technique for creating better software.
In contrast, agile manifesto [
We believe that, model-based techniques can help in dealing with these challenges. In the rest of paper, we will discuss how agility and model-based paradigm fits together. Thereby, we will mainly focus on the integration of model-based testing in agile development process as an enabling technology for the principles of the agile manifesto.
In 2001 seventeen software experts, who have
introduced well-known agile methods (e.g. Scrum,
Test driven Development (TDD), Extreme
Programming (XP) etc.) have defined common
principles for a lightweight development process. The
new development paradigm should be an alternative to
documentation-driven, heavyweight software
development processes. They called these principles
“agile manifesto”. Agile manifesto includes the
following principles (based on [
Existing agile methods aim at enabling these
principles. For example, Scrum promotes the close
collaboration of customer or product owner at identifying
software functionalities to be implemented in the next
development cycles [
We believe that model-based techniques can help in combining the different tasks in agile development by using abstract models as primary development artifacts. Models can support communication between team members and customers, documentation of customer requirements and design decisions and automation of code generation and testing. Thus, model-based techniques can enable an integrated development throughout the whole project. As next, we want to focus on how the documentation of customer requirements and their validation can be supported by model-based testing while following principles of agile manifesto.
With the emerging popularity of model-based
software development, the usage of models in
software testing is also desired. There are several
definitions of model-based testing (MBT) in the
literature, but the common understanding is that MBT
is “the automation of test design of black-box tests”
[
There are three main advantages of MBT, which make this technique interesting: a) enabling high coverage, b) need for lower effort and c) enabling early testing. Because MBT uses sophisticated algorithms and tools for automatic test generation, far more test cases than while manual testing can be generated. This way a very high coverage of the system specification and/or requirements can be reached. While test cases are not designed and implemented manually anymore, the effort for this task is significantly low. This works under the assumption that the modeling effort is lower than the manual test design activity. Last but not least the early creation of test models supports the validation of requirements even before the system is implemented.
Using MBT, the requirements can be captured and communicated in form of models. Unified Modeling Language (UML) provides many types of visual diagrams for describing the desired structure and behavior of software. Most of the diagrams have a quite simple syntax and fairly clear semantics such that customer and developer can easily learn how to express their requirements more precisely, thus enabling the principle close collaboration. The changes in requirements can easily be made on the already created models, thus improving fast adaptation. Models can also support the conversation between team members, where the results of a discussion can be edited into the models immediately. Also the simplicity principle can be supported by models by using the abstraction, modularization and decomposition features of modeling.
There are different scenarios for creating and using
models in MBT [
Models having a well-defined syntax and semantics
can be handled by computers, which obviously bring
efficiency into the test process. The state-of-the-art
modeling techniques support creating good design.
Depending on the context of development, formal or
semi-formal notations can be used. The more formal
the models are, the better automatable are the test
activities. Especially the automation of the test design
task, which is the most costly and time consuming part
in testing [
Within MBT several coverage criteria for selecting test cases can be used. One possibility is to cover the customer requirements, which directly correlates with several agile principles. The customer satisfaction and close collaboration principles are supported by refining and understanding customer requirements while modeling them and showing that those requirements were successfully tested. The usage of different selection criteria and possibly combining them leads to higher defect detection rate and therefore facilitates working software. Due to changeable coverage criteria and automated test case generation, the test team can conduct different testing scenarios and gain experience for further development cycles and projects. This flexibility and configurability of MBT enables reflection in agile development.
As discussed in the last section, MBT can definitely enable many principles of the agile manifesto. The main advantage of MBT for the agile world is the usage of models as primary artifacts and the automation of several test activities. This way MBT fits very well with agility!
However, MBT is not for free. Introducing MBT
into the agile development process requires some
initial and continual efforts as discussed in [
At first sight, these efforts seem to be not proportional to the lightweight development purposes of agile manifesto. However, test automation is an indispensible part of agility enabling the efficient and effective process. Fewster and Graham said in 1999 that “automating chaos just gives faster chaos”. MBT is an attempt to make test automation more systematic, more maintainable.
In this paper, we have discussed how agility and
MBT conceptually fits together. A concrete approach
for combining agility and MBT can be read in [