Learn From The Tutorials Quickly

PushToTest TestMaker comes with tutorials to rapidly teach you how to develop tests of Web applications, Rich Internet Applications (RIA) using Ajax techniques, SOAP/WSDL-based Web services, Service Oriented Architecture, and Web applications.

Building Tests of Web Applications Using TestGen4Web

Building Tests of Rich Internet Applications Using Ajax and Selenium

Building Tests of SOAP/WSDL Web Services Using soapUI

Building Front-To-Back Tests Using Multiple Test Tools

Additionally, PushToTest provides a set of tutorials, including the videos and screencasts, here.

Understand The PushToTest "Repurposing" Methodology

PushToTest implements a unique Repurposing Methodology to reuse tests as functional tests, load and performance tests as well as business service monitors.

Functional Testing	Ensures that an information system application performs its functions according to your design. An application follows a flow process the user requests according to a defined business process. For instance, a web-based email service delivers messages. The flow of a test simulates the user writing a message and the test validating the message is sent correctly.
Integration, Compatibility and Regression Testing	Ensures the application is compatible with user’s operating environments, browsers and client software. For instance, a web-based email service needs to work successfully on Microsoft Internet Explorer and Firefox browsers.
Load and Performance Testing	Ensures an information system operates functions within an acceptable amount of time to users. A load and performance test identifies the Scalability Index ensuring the application achieves a Service Level Agreement (SLA) as more and more users operate the application concurrently.
Business Service Monitoring	Proves an organization’s application meets the terms of a Service Level Agreement (SLA).

PushToTest is a single platform that enables unit tests to be reused as functional tests, integration tests, load and performance tests and business service monitors. The PushToTest methodology uses unit tests, protocol handlers and data production libraries (DPLs) to enable test reuse on a single integrated test platform.

Testers build tests in a variety of provided ways: using browser-based record / playback utilities for web applications, using a graphical toolkit for SOAP-based web services using scripting languages (JAVA, Jython, JRuby, Groovy and others) for Message Queue (ESB) email and Service Oriented Architecture (SOA) tests. PushToTest runs tests in a TestNode, a distributed web service that operates the test in one or more concurrently running threads (each thread acts as a simulated user).

PushToTest TestMaker operates web application and Ajax tests as load and performance tests by running the tests in a TestNode. The TestNode operates the test using HTMLUnit. HTMLUnit is an open-source framework that provides a programmatic simulation of a web browser. HTMLUnit uses Rhino, the Mozilla JAVAScript engine, to run JAVAScript and Ajax programs. This approach makes it easy to run hundreds to thousands of simulated users in a load and performance test. The alternative would be to run the test by instantiating a browser for each simulated user.

The following charts illustrates the three types of testing that PushToTest provides for Web application tests specifically.

Type 1 is for functional testing of a Web or Ajax application. PushToTest provides Selenium as a plug-in for Firefox. Selenium provides record / playback capability through the browser. Selenium drives the browser as a user would: clicking buttons, filling-in web forms and asserting incorrect responses from the server. This is a great, interactive mechanism showing issues with the test and web application immediately.

PushToTest provides Selenium IDE as an add-on to the Firefox browser. Selenium IDE records tests, provides a test script editor, offers autocomplete for the Selenese command language, offers debugging features such as breakpoints, features logging functions and includes on-line help.

Selenium IDE records user interaction with the Web application into a Selenese test file. Selenese is a domain specific language for testing. For instance, the first command in the test shown above opens the BrewBizWeb example application, loading the sign-in page.

Once you create a test in Selenium IDE the test runs in the Selenium Grid and in the PushToTest TestMaker distributed test environment as a functional test, load and performance test and business service monitor.

Selenium is a plug-in for Firefox. The tests you author in Firefox operate in Microsft Internet Explorer, Opera and Safari, or in the TestNode environment using HTMLUnit / Rhino.

Type 2 is for functional testing across multiple browsers. This testing checks to see how Microsoft Internet Explorer (IE), Opera, Safari and other browsers operate the application. PushToTest operates the Selenese test in a grid of machines using the Selenium Grid system. PushToTest installs the Selenium Grid onto a machine and remotely operates the recorded test using the browser installed on the Grid machine.

Type 3 is for functional testing from remote locations, load and performance testing and business service monitoring. The TestNode operates the Selenese test remotely using HTMLUnit / Rhino. A simple TestScenario document orchestrates which nodes will run the test and how many concurrently running simulated users operate the test. As a functional test, the TestNode operates the test once and reports the results.

PushToTest TestMaker shows the success / failure and duration for each step within the test for functional tests. For load and performance tests the TestNode operates the test in sets of concurrently running simulated users. PushToTest summarizes the results into a Scalability Index.

For service monitoring the TestNode operates the test periodically. PushToTest shows a dashboard for each monitor.

The TestNode running a test in HTMLUnit and Rhino is a different environment from Firefox. HTMLUnit and Rhino emulate most of the browser functions but not all functions. For example, each browser implements its own JAVAScript engine, HTML DOM rendering engine, Security and browser features. Many times testers will need to use a DOM, HTML and JAVAScript debugging tool such as Firebug and a network protocol analyzer (such as the Network Monitor in TestMaker or Wireshark / Ethereal) to debug the Selenese test and configure the HTMLUnit to operate the test.

Lastly, PushToTest provides the Data Production Library framework to provide tests with operational test data at test runtime. You will need an operational data strategy to identify the test data your test needs and how to identify and locate the data.

By understanding the PushToTest reuse methodology your organization and your teams’ efforts will be understood, compelling and supported, as it progresses to success.

Appropriate Architectures for TestMaker

Software developers, QA technicians, and IT managers have many architectural patterns to build software applications. PushToTest TestMaker provides testing and remediation against the following popular architectural patterns, plus many more.

The Domain Model uses an application server, servlet engine, EJB / Plain Old JAVA Object, Model View Controller, Workflow and Object-Relational Mapping technology to coordinate data, stored in a relational database. The user interface is a Web browser using HTML / HTTP protocols. PushToTest drives Domain Model applications using HTTP protocols.

The Enterprise Service Bus Model (ESB) uses a centralized service bus to transform and deliver messages between a set of installed and reusable services. Each service uses the most appropriate protocol (for instance, soap, POP / IMAP, HTTP and Ajax) for its application. PushToTest drives ESB applications using multiple native protocols and accessing services through standard bus adaptors.

The Enterprise Web 2.0 Model uses enhanced Web browser functions to provide an enhanced user experience and new functions. For instance, a Web browser provides live maps using Ajax protocols between a browser, servlet interface, XML parser and POJO. PushToTest drives Web 2.0 applications using multiple native protocols, including the Ajax, RSS and HTTP protocols as shown below.

The virtualization model uses shared virtual containers to operate multiple services. For instance, in one virtual container an application operates an instance of the Domain Model and in a second container an application operates an ESB Model. PushToTest provides a distributed set of TestNodes to drive applications and services deployed in a virtualized model.

The PushToTest environment provides scalability, performance and service monitor tests for the Domain, ESB, Enterprise Web 2.0 and Virtualization Models.

Software developers introduce extensions to the Domain, ESB and Enterprise Web 2.0 Models everyday, including new protocols, new user interfaces and new encoding styles to message between consumers and services. The PushToTest environment provides an open-source platform and test runtime to build tests for these models. The environment is fully extensible to support new protocols, interfaces, encoding styles and libraries.

PushToTest TestMaker is a distributed test runtime. TestMaker operates tests developed in scripting languages (Java, Jython, JRuby, and many others) or tests recorded in Selenium, soapUI, and TestGen4Web. The following illustrates a typical use of the TestMaker platform:

1) Author a new test using Selenium in Firefox. Save the test to a Selenese file.

2) Write a TestScenario to give the PushToTest test runtime all the instructions it needs to operate the Selenium test. The TestScenario identifies the Selenium test file and the location of one or more TestNodes.

3) The PushToTest test runtime makes a SOAP request to the TestNode and passes the Selenium test file to the TestNode.

4) The Selenium test communicates over native Web and Ajax protocols to the Application or Service under test. The TestNode provides Protocol Handlers (PH) and Data Production Libraries (DPLs) to help the Selenium test use the needed operational test data and native communication protocols of the Application or Service under test.

5) As the test operates, the PushToTest Monitor (PTTMonitor) observes resources of the server running the Application or Service and the TestNodes operating the test. At the end of the test the TestMaker Results Analysis package correlates the monitor data to the operation of the test use cases for automatic root cause analysis and mitigation.

6) As the test operates the PushToTest test runtime takes snapshots of live test results data and begins to analyze the results. The TestMaker Results Analysis engine generates up to 350 different reports to understand the results and deliver actionable knowledge.

7) The whole of the PushToTest TestMaker platform may be run as a Software As A Service (SAAS) using the PushToTest As A Service (PAAS) and Governance Statistics Result Set (GSRS) SOA interface. This provides full integration with build environments, continuous integration environments, and registry/repository services.

PushToTest TestMaker delivers a rich environment for developing tests including these resources and abilities:

• • Friendly graphic user interface
• • Build tests in a variety of scripting languages including JAVA, Jython, Python, Ruby, Groovy, JAVAScript and many more
• • Extensible library of protocol handlers (HTTP, HTTPS, soap, XML-RPC, SMTP, POP3 and IMAP)
• • Web browser Recorder and Playback utility (Seleniu, TestGen4Web)
• • Fast and Easy Test Creation for SOAP/WSDL and REST-based Web services (soapUI)
• • New Agent Wizard, featuring an Agent Recorder to write scripts automatically
• • Console to run tests in a distributed test environment; called TestNetwork
• • Library of fully functional Example Test Agent Scripts
• • Shell scripts to run test agents from the command-line and from unit test utilities
• • Web Service interface to run PushToTest As A Servivce (SAAS) - The PAAS Interface
• • Monitoring of CPU, Network and Memory utilization concurrently with operation of tests

TestNodes For a Distributed Test Environment

PushToTest runtime is a distributed environment to operate tests. PushToTest TestMaker is built on the PushToTest TestNetwork foundation enabling tests to run on one or more TestNodes; which is the distributed TestMaker environment.

PushToTest runtime provides a distributed test environment using TestNodes. A TestNode is the PushToTest runtime environment implemented in Java and runs anywhere Java runs including Windows, Linux, Solaris, Macintosh and more. The PushToTest console communicates with TestNodes over SOAP protocols using port 80, therefore, changes to firewall settings to distribute a set of TestNodes is not necessary.

The TestNode environment works equally well for software developers, QA technicians and IT managers. For instance, TestMaker users install TestNodes on a set of remote machines to see, from many different vantage points, how well applications are serving the users. TestMaker users also install a set of TestNodes on a rack of servers within a QA lab to generate high level concurrent use of an application with high level scalability and performance testing. Lastly, TestMaker users install TestNodes on a series of different networks to identify service performance of network service providers.

From Record/Playback to Test Object Scripting

PushToTest built TestMaker for use by software developers, QA testers, and IT managers. These three groups often have a wide variety of skills, backgrounds, and skills. TestMaker delivers a set of record/playback utilities to graphically create test use cases quickly and easily. In modern Web applications, Service Oriented Architecture (SOA,) and complex information systems, record/playback may be a good way to start but often test authors need an object-oriented test scripting system to accomplish tests of modern applications and services.TestMaker provides native support and architectural patterns for all the popular scripting languages, including JAVA, Jython, Groovy, PHP, Ruby and many others for the tests that require srcipting for functional testing. TestMaker includes a Transformer to automatically transform recorded tests into Java or Jython test scripts and classes. See the Options drop-down menu -> Transformer command in TestMaker.

Tests of Web applications, Rich Internet Applications, REST, and SOA applications require communication over the native protocols of the systems, including HTTP, HTTPS, SOAP, XML-RPC, Telnet and email protocols. TestMaker deliver an extensible protocol handler library (Test Object Oriented Library (TOOL)) that comes fully integrated to enable your test use case scripts to speak these native protocols to the application under test.

TestMaker makes it easy to transform unit tests into data-driven functional tests. TestMaker delivers Data Production Libraries (DPLs) to provide tests with operational test data from comma separated value files, relational databases, and Web services. DPLs are used to provide tests with input data and validation data. DPLs also make it easy to reuse a test between development, staging, preproduction and production environments by simply changing the source of the DPL data at test time.

The test runtime environment automatically turns these same functional unit tests into load tests, scalability and performance tests, regression and remediation tests and service monitors for QA technicians, IT operations managers and CIOs. These runtime load tests and service monitors integrate into Service Registry / Repository products, database and application performance optimization and root-cause analysis tools.

For example, software developers introduce extensions to the Domain, ESB and Enterprise Web 2.0 Models, including new protocols, new user interfaces and new encoding styles to message between consumers and services. The PushToTest environment provides an open-source platform and test runtime to build tests for these models. The environment is fully extensible to support new protocols, interfaces, encoding styles and libraries.The PushToTest runtime uses a TestScenario XML document to define scalability, performance and service monitor tests. The Governance platform stores the TestScenario XML document, which is the key to turning unit tests into functional, regression and load tests and service monitors.

PushToTest provides many options to build tests:

• • Use Selenium or TestGen4Web plug-ins to Firefox to author tests.
• • Use the included Recorder Wizard, automatically build tests that require no programming experience.
• • Start from scratch and write a script or class that implements a JUnit TestCase in any of the supported languages. Plus, TestMaker delivers a library of product handlers, called the Test Object Oriented Library (TOOL), of native SOA and Web service protocols including HTTP, HTTPS, soap, XML-RPC and email protocols.

This unique approach from PushToTest provides a new way to leverage any enterprise's software development, QA and IT efforts resulting in major cost-savings to the company.

How To Succeed with PushToTest TestMaker

PushToTest provides Open Source Test (OST) technology and services to help you and your organization succeed. We are often asked:

"What skills and background does it take for my team to be successful with PushToTest TestMaker?"

Match The Tools and Methodology To Your Team's Skills

The goal of most organizations is to predictably provide information services to customers, vendors, employees and partners. Many times this means developing test skills in your own team (internally or outsourced to an off-shore partner).

Budget The Right Amount of Time

PushToTest TestMaker is a platform for testing a wide variety of software applications. PushToTest recommends budgeting an appropriate amount of time for your team to learn the platform. The following table summarizes previous experiences PushToTest had in working with customers:

3 - 10 Days	Train Your Team: Sometimes your organization is missing the skills to be successful or they need a rapid jumpstart to succeed. PushToTest recommends a 3-Day Training Course on PushToTest TestMaker complemented with 5 or more days of PushToTest Global Service Consulting to help your Engineering Support Technician install and configure PushToTest and help your Test Engineers build and operate their first test. In addition, a support agreement to provide your team with access to PushToTest’s Technical Support through email, phone, instant messenger and Web conference.
2 - 3 Days	Identify the Issues in Your Application: For instance, identify broken and invalid HTML in your web pages, servlet redirection issues, URL parameters, cookies for session management, custom security protocol headers and security tokens.
2 Days	Identifying the Widgets in Your Application: For instance, Yahoo User Interface (YUI) or Google Web Tookit (GWT) each bring dependencies on JAVAScript libraries and server included files.
1 - 2 Days	Identifying Application Dependencies: Tests frequently succeed or fail based on the availability and accurate function of your application’s dependencies on other applications and services.
3 + Days	Team Performance Speed: The speed your team implements changes in your QA, Pre-production and Production Environments will impact test development and operation. For instance, one PushToTest customer took 6 hours to implement a change to fix one broken HTML tag for its log-in page.
1 - 2 Days	Remote Access and Assistance: Be prepared to provide remote access to one or more services, either through web desktop sharing, public service access or VPN access.

Off-Shore Test Development Service Available

Did you know that PushToTest offers offshore test development and support at very competitive rates?

- Test development (scripting)
- Selenium, soapUI, TestGen4Web, HTMLUnit, TestMaker and others
- On-going test maintenance
- Tool augmentation, enhancement, and integration
- Integrate testing into your build environment
- New feature development
- Transform your tests into data-driven test

To learn more see:
http://www.pushtotest.com/services

Optimizing Your HP/Mercury Tools with PushToTest

Enhance your HP/Mercury LoadRunner testing and QualityCenter processes across the full SOA life cycle with PushToTest TestMaker.

Organizations with investments in HP/Mercury solutions often find that they are unable to achieve agility, efficiency, and economy when confronted with test, monitoring, and operational management requirements in Service Oriented Architecture (SOA,) Rich Internet Applications (RIA) using Ajax, and Web services. PushToTest delivers solutions for organizations to extend the value of their HP/Mercury solutions and increase their existing skilled teams by adding fast, fun, easy, and inexpensive open-source test tools that leverage and extend HP/Mercury solutions.

PushToTest TestMaker provides an modern text, validation, monitoring, and operational management solution for HP/Mercury testing and IT Governance frameworks, including QualityCenter (TestDirector), QuickTestPro (QTP), Performance Center (LoadRunner) and Systinet. PushToTest TestMaker solutions create immediate value in your teams by enhancing the functionality of these leading tools to test Web, SOA, RIA/Ajax, and Web services across the full lifecycle of design, change, operations, and maintenance processes.

Here are three key integration points for maximizing the value of HP testing tools for SOA with PushToTest TestMaker:

1) Provides a Virtual Services Environment for QTP and LoadRunner for Functional and Load testing. TestMaker repurposes unit tests and tests build with Selenium, soapUI, and TestGen4Web to simulate user behavior, including operation of ESB and BPM technology. Repurposing enables your developers, QA testers, and IT managers to have a common framework throughout the Software Development Life Cycle (SDLC.) TestMaker is ideal for agile environments where developers and architects build tests first.

2) TestMaker works with QualityCenter test management processes. TestMaker tests are artifacts stored in QualityCenter or TestDirector. An easy service interface lets Quality Center operate these tests. These test artifacts return data directly back into QualityCenter. This is ideal for returning functional testing, regression, load and performance test results back into QC.

3) Integrates with Systinet for SOA Governance and Validation. TestMaker tests interoperate with Systinet Registry/Repository as a key point of policy validation for services. TestMaker provides a PushToTest As A Service (PAAS) service interface to the Systinet registry. This is ideal for test automation in SOA environments.

To learn more see:
http://www.pushtotest.com/services/hpmercury

Pay-As-You-Go OnDemand Test Services Available

Pay-as-you-go testing is now available from PushToTest. Have a test to run but you do not have the budget to buy an entire test package? PushToTest Test OnDemand is now available!

PushToTest TestOnDemand (TOD) provides organizations with test solutions on an as-needed, on-demand basis. TestOnDemand delivers a global test capability that is fully scriptable, fully functional, multi-protocol, and a complete solution to meet your performance test needs.

- Test development (scripting)
- Selenium, soapUI, TestGen4Web, HTMLUnit, TestMaker and others
- On-going test maintenance
- Tool augmentation, enhancement, and integration
- Integrate testing into your build environment
- New feature development
- Transform your tests into data-driven test

To learn more see:
http://ondemand.pushtotest.com/

QuickStart Packages Available

PushToTest provides a complete suite of software and services to helpyou succeed in surfacing performance issues in your IT systems. PushToTest software provides an integrated solution for testing and monitoring your services, including Web applications, Web Services,
Service Oriented Architecture (SOA,) and Ajax. Through our unique approach our goal is to overcome the common hurdles to achieving effective IT testing, monitoring and management.

PushToTest designed special QuickStart packages to specifically meet your test needs and budget. Browse all of the QuickStart packages at:

http://www.pushtotest.com/Downloads/starterpacks

For example, the Proof Of Concept (POC) QuickStart is ideal for medium and large size organizations that need to:

- Quickly and easily conduct a Proof Of Concept (POC) test of the function and scalability of a Web service, SOA, Ajax, and SOAP-based Web service using the PushToTest Platform

- Certify an SOA, Web service, and Ajax application is ready-for-deployment

- Test a SOAP-based Web service for functionality and regression

With the Proof Of Concept (POC) QuickStart you get everything you need to immediate develop and operate tests:

- PushToTest TestMaker Platform to author functional tests, includes browser record/playback test authoring, script-driven authoring, and data-driven test authoring

- Up to 200 Simulated concurrently running users for load and performance tests

- Eviware soapUI Pro to author tests of SOAP-based Web services. soapUI Pro gives you everything soapUI provides plus: Test Coverage Reports, Mock Services, Virtualized Services, XPath Operators, Datasources, and Groovy Script Repository functions.

- Distributed TestNode Environment to operate tests on your laptop, in a test lab, and globally

- Results analysis engine to do root-cause analysis and mitigation

- Unlimited number of test controllers

- Bronze Support of soapUI Pro and the PushToTest environment via telephone, email, instant messenger, and Web conference

- On-site training for soapUI Pro and the PushToTest environment. Advanced training available.

Available upgrade paths:

- The Proof Of Concept (POC) QuickStart provides Bronze Support of soapUI Pro and the PushToTest Environment with 1 business day response. For faster support response time upgrade to the Enterprise QuickStart.

- Of course, Proof Of Concept (POC) QuickStart customers may upgrade to any of the other QuickStarts at any time!

http://www.pushtotest.com/Downloads/starterpacks

Additionally, compare the PushToTest product and service offerings at:

http://www.pushtotest.com/Downloads/compare

What If My Team Just Doesn't Get It To Work?

If your team is not able to build and operate tests within 5-7 business days, then we recommend you give PushToTest a call. PushToTest offers expert services to get you up and running tests quickly and efficiently. We have been providing this kind of help to organizations for years. Sometimes your team just needs a little more training, othertimes your team needs a jump-start where PushToTest Services builds your first test as a model for future tests. PushToTest even offers a complete "TurnKey" option where PushToTest experts build, operate, and analyze your application and service performance and optimize the service for better performance and scalability.

Please click here to tell us about your challenges and receive our free response.

Additional documentation, product downloads and updates are at www.PushToTest.com. While the PushToTest testMaker software is distributed under an open-source license, the documenation remains (c) 2008 PushToTest. All rights reserved. PushToTest is a trademark of the PushToTest company.