Agile Performance Testing - Testing Experience

Figure 3 – Script line analysis
2.1.2 Creating derivation models
After identifying the test scripts’ common and variable features,
we start creating the derivation models (step 4), which is a task
supported by GenArch plug-ins. In our research, we established
that it is best to create these models manually, since code annotations
used are restricted to Java applications on GenArch. This
meant it was not possible to automatically generate an initial
version using the tool. Models must be created and refined with
the aim of allowing optimum simplicity and flexibility for the final
test script generation.
These models are the central objects of the derivation tool used,
and from these we will be able to derive test scripts according to
our specifications. Therefore creating and refining the models is
an essential task in order to successfully perform derivation. In
the following section, we briefly describe the models used.
Feature Model
This represents all variabilities identified during the previously
performed analysis of the test scripts. It is designed such that
it uses a simple and direct language to allow test engineers to
easily understand its elements and to determine during the instantiation
phase (described later) the desired characteristics to
be included in the new test scenario.
3.4 - Feature Model Example
Architecture Model
This model visually represents SPL’s implementation elements. It
does so in a way that allows mapping out the relation between
implementation elements (solution space) and features found
in the feature model (problem space). Like the other derivation
models, this one must also be manually created based on the results
of the analysis made in the previous step. This model is basically
made up of a set of test script templates that are processed
to generate tests for specific web applications.
Configuration Model
Finally, we define the last model required for our approach, the
www.testingexperience.com
so-called configuration
model. This model specifies
the existing relationships
between the elements
from SPL’s architecture and
feature models. It is considered
a fundamental tool to
connect the problem space
(feature model) with the
solution space (architecture).
The configuration model
displays the mapped relationships
in a tree-view
format, just like the architecture
model does. However,
it shows an explicit indication
of the architecture
dependencies to identified
features. It contains only
those architectural
elements that have
explicit dependencies
to a feature to
be instantiated; all
others are considered
mandatory features
and will be included
for every new
SPL instance.
2.1.3 Customizable
test template
specification
3.5 - Architecture Model Example
The next step of our
approach involves
the specification
of test templates, 3.6 – Configuration Model example
which is necessary
to enable the implementation elements (classes, interfaces, features
and files) to be customized during a new instance or product
derivation. Templates shall be defined following the items
identified as variabilities (from stage three), and considering
these aspects during implementation. The aim is to include the
maximum number of elements and to thereby minimize the
work to be done by the engineers for the derivation of a new instance.
2.2 Test script derivation
Once all models and templates have been created and refined in
a way that represents the implementation and variabilities of the
software product line’s architecture, the GenArch tool is ready for
the derivation of new instances / products of the SPL, which in
our case will represent performance test scripts.
In the next sections, we will present the final steps of our approach,
which are needed in order to correctly create and derive
a new instance by using the GenArch tool. We will also indicate
which actions need to be performed by the engineer after the
new instance has been derived.
2.2.1 Test script generation
In the fifth step of our approach, the following actions shall be
performed with the intent of allowing the creation and derivation
of a new instance:
(1) Initially, the engineer must create a feature model instance
in order to decide which variabilities will be part of the generated
test script and supply it to the derivation tool, specifying
for each selected variability its attributes value (if required).
The Magazine for Professional Testers
53