Test Virtualization Server and Integration Testeran IBM + HCL product

In today’s world of Information Technology,

applications are evolving at an ever-faster pace. These

applications are used internally within the organization

and by its customers and these applications are vital

for the success of the business, ultimately acting as a

differentiator from the competition. The earlier quality

applications can be deployed, the more profitable it is

for the organization.

These applications build on a complex, interconnected

set of services that includes disparate technologies,

developers, deployment topologies and organizations.

Developers and testers are under immense pressure to

deliver quality applications on time. Thererfore,

software quality management becomes even more

important and proper practices need to be adhered to

across the whole development lifecycle of the

application.

Testing needs to start early, but this is challenging,

especially when testing from the user interface (UI) in

the traditional way. The UI needs to be ready. The

backend systems to the UI need to be deployed in the

test environments in order to test end-to-end with

maximum coverage.

INTRODUCTION

The UI is like the tip of an iceberg; the majority of code

lies underneath the UI, so waiting for the UI to be

ready to test the entire system is a huge risk. Moreover,

most defects in complex integration projects happen

at the interface between component interactions, so

testing from the UI gives very little information about

the underlying component behavior. Testing needs to

happen closer to these components. Code should not

be thrown over the fence into system integration

testing (SIT) environments, without component

integration testing (CIT). CIT should weed out these

interface defects thus allowing for smoother testing in

the SIT phase.

CHALLENGES

But organizations face major challenges when it comes to testing in parallel with development. Well-known issues

are:

• All environments are not ready for integration testing to occur

• Environments need to be shared across teams and therefore not available at all times through the development

lifecycle

• Not all components have been developed and deployed for end to end testing to occur

• Applications interface with costly third-party services which therefore restricts the volume of testing and

potentially these third-party services require scheduled access

• Test data can easily become corrupted when sharing environments. Developers and testers again need to

schedule access to test environments to overcome data issues.

Service virtualization is a technology that can help

your organization become more efficient and quality

focused in the face of ever increasing complexity. With

service virtualization, developers and testers create

virtual components that can be shared, enabling

parallel development across the team. And because

virtual components mimic real-world services,

applications, or entire systems, they can help to

remove delays in the testing process. These

components also run on commodity hardware and

decrease the cost of supporting multiple test

environments, which can decrease the concerns of

operations related to capacity, scalability, and security.

Service virtualization can help you improve your test

management by:

• Allowing integration testing to be performed earlier

by virtualizing unavailable service interfaces that

need to be called in your environment

• Increasing the availability of a test environment by

using virtual services to mimic dependent

environments

MANAGING COMPLEXITY

• Enabling developers and testers to share their

virtual components to perform integration test

earlier as well as develop code in parallel

• Enabling collaboration between testers and

developers for a better understanding of the system

under test and to develop and deploy quality

applications faster

• Facilitating continuous integration. Continuous

integration is a software development practice that

requires team members to integrate their work

frequently, ideally daily. Integrations are verified by

an automated build that runs regression tests to

detect integration errors as quickly as possible

Test Virtualization Server enables you to test software

earlier and more frequently in the development

lifecycle. It helps you in modelling and simulating real

system behaviour to eliminate application test

dependencies and reduce infrastructure costs. With a

script-less wizard-driven authoring environment and

70+ technologies and protocols available it is uniquely

positioned to accelerate test productivity and software

delivery.

Test Virtualization Server supports databases, Society

for Worldwide Interbank Financial Telecommunication

(SWIFT), Web Services, SOAP, REST, TCP/IP and a

number of enterprise messaging solutions such as

Java Message Service (JMS), TIBCO EMS and IBM MQ

and more.

TOOLS FOR THE JOB

No need to modify application

code

Variety of tools to enable

creation of virtual service e.g.

recording

Frees projects from external

constraints e.g. databases, app

servers

Simplifies management of Stub

execution

Enables traceability over where

stubs are running

Provides audit of who ran stubs

and when

Enables simple versioning of

stubs

Removes delays caused by late

delivery of external interfaces

Speeds up development of

stubs for testers and developers

Stubs can be reused and

embellished to support

different test cycles

Allows control over datasets

being used across an

environment

Enables erroneous data to be

played back into systems

HIGHLIGHTS

Integration Tester is a scripting-free environment for

developing tests for service-oriented architecture

(SOA) messaging and business process integration

projects. Tests can be built by recording existing

system behaviours or from requirements, by entering

the data to send and the data that is expected in return.

Integration Tester is compatible with a number of

enterprise messaging solutions (for example, JMS,

TIBCO EMS, IBM MQ) by using a collection of

protocol-specific or format-specific plug-ins

These guidelines drive efficient and expedient

integration testing, and should be applied to the

customer’s testing process and infrastructural

requirements.

• Do not wait for the UI to automate your tests: Our

tools are designed for integration testing. They do

not require a user interface to be in place on your

System Under Test (SUT). Often, by the time a UI is

in place it is then far more costly to test.

• Test early and often: Testing earlier in the lifecycle

means that defects are less expensive to resolve. As

integration tests run much faster than normal

automated UI tests, you should plan to run

regression test cycles as often as is necessary. RIT is

designed to work with most of the popular

Continuous Integration tools (e.g. Jenkins).

• Evolve your tests and stubs as you progress through

the lifecycle: Developers can use our tools for initial

testing and begin by creating very simple tests with

deterministic stubs. These test assets (test, stubs

and data); can be passed along to teams further

down the lifecycle who can add further “life-like”

qualities to the basic tests. This ensures that there is

consistency and efficiency to the automation test

cycle. Leverage tests to create test suites,

performance tests, template and stubs

• Plan for flexibility by stubbing strategically: Our

virtualization (stubbing) capabilities mean that

testers and test managers can think differently

about their approach. They can begin to plan to

mitigate the unavailability of interfaces to test

against. For example, if it is anticipated that the risk

of environment unavailability for a particular

interface is high, then you should plan to stub it

before it becomes unavailable. This means that

when the inevitable happens, testing can continue.

Efficient planning with stubs promotes test

environment agility.

GUIDELINES FOR SUCCESS

Removes the need for costly

3rd party interface leasing

Lets developers get on with

developing code not stubs

Puts testers back in control and

removes dependency on other

teams

Easily simulate “+1” changes to

interfaces and environments

Enables multi-interface,

complex and stateful simulation

easily

Limits risk and lowers

integration issues when going

into production

Test Management

BPMWeb Services

TIBCORV/EMS

SOAP/XMLOver JMS

TCP/IPIBMMQ

JDBC Web MethodsJMS

Defect Management

Source Control

Integration Tester

DataManagement

ContinuousIntegration

UI Testing

Where Does Integration Tester Fit?

WX

43

72