PushToTest is open-source test automation for software
developers, QA
testers, and IT
management to test, monitor, and govern information systems.
At any
given time new software needs to be installed, existing software
modules and database software need to be patched, application software
and databases need to be tuned and optimized, and the root-causes of
crashes, downtime and performance bottlenecks need to be analyzed and
resolved quickly.
Software developers use PushToTest to turn their unit tests into functional tests in a test automation platform running on their development machine. PushToTest TestMaker includes Wizards and Recorders to automatically build tests without writing test script code. And for tests that need functions available through scripting, PushToTest TestMaker provides native support for all the popular scripting languages, including Java, Jython, Groovy, PHP, Ruby, and many others. Plus PushToTest supports SOA, Web Service, AJAX, and REST services using HTTP, HTTPS, SOAP, XML-RPC, Telnet, and the email protocols.
The PushToTest test runtime environment automatically turns these same functional unit tests into load tests, scalability and performance tests, regression tests, and service monitors for QA technicians, IT operations managers, and CIOs. PushToTest test runtime load tests and service monitors integrate into Service Registry/Repository products, database and application performance optimization, and root-cause analysis tools.
To jump right-in, follow one of the QuickStart Tutorials or view a video tutorial and presentation on PushToTest Testmaker.
|
Screencast Introduction For TestMaker 4 Users | |
Screencast on Building Load Tests, Functional Tests, Service Monitors | |
Architectural Goals of TestMaker 5 | |
Google TechTalk on TestMaker |
PushToTest TestMaker is designed for your technical skills. Choose from one of the following for details:
PushToTest TestMaker is an open-source end-to-end service governance and test automation platform. PushToTest provides many options to build tests:
This user guide intends to teach you these facets of TestMaker:
This section describes how to install PushToTest TestMaker, how to get started quickly, and how PushToTest TestMaker enables black-box and grey-box testing. Please read the Installation Page for complete installation and integration details.
The
PushToTest
Company distributes a pre-built and ready-to-run binary of TestMaker
under a commercial license found in license.txt.
The commercial license
is free and authorizes you to run up to 200 concurrent virtual users
and 10 concurrently running service monitors. Additional virtual users
and monitors are available for purchase from PushToTest.
The PushToTest TestMaker source code is free and distributed under a
GPL v2 license.
The PushToTest TestMaker installer requires a Java 1.6 or higher
runtime environment. Sun Microsystems makes the Java runtime
environment available at http://www.java.com.
PushToTest
TestMaker is the open-source SOA governance and test automation
platform. The PushToTest runtime identifies scalability, performance,
and reliability issues by conducting end-to-end tests of your services.
PushToTest turns unit and functional tests into scalability and
performance tests and service monitors with no extra effort.
The PushToTest Company distributes this pre-built and ready-to-run
binary of TestMaker under a commercial license found in license.txt.
The commercial license is free and authorizes you to run up to 200
concurrent virtual users and 10 concurrently running service monitors.
Additional virtual users and monitors are available for purchase from
PushToTest. PushToTest TestMaker source code is free and distributed
under a GPL v2 license.
The PushToTest TestMaker installer requires the Java 1.6 or higher
runtime environment. Sun Microsystems makes the Java runtime
environment available at http://www.java.com.
Please run the following installers. Normally you accomplish this by
double-clicking or running the setup script that comes with one of the
following downloads:
The
testmaker_home directory contains the following files and directories:
PushToTest TestMaker comes with everything necessary to build and run tests. PushToTest TestMaker requires Java 1.6 or higher, though the TestNode software may run under Java 1.4 and 1.5 for compatibility with tests compiled under those older versions.
PushToTest requires Java 1.6 or greater. Click here for additional installation and configuration instructions, including instructions for Ant, Maven, jUnit, and other integration.
From time-to-time, PushToTest TestMaker is updated to solve bugs and introduce new features. The PushToTest Web site home page shows the most recent PushToTest version number along with a download link.
Answers to common installation problems are found in the Frequently Asked Questions document.
PushToTest TestMaker is appropriate for testing Web applications, Service Oriented Architecture (SOA) Web Services, Email systems, Java applications, and more. The following lists some of our suggestions for getting started with PushToTest TestMaker:
 |
|
|
|
|
|
|
| Web application test | Web Service and SOA test | Email system test | Java application test | |||
|
Web applications provide users with functions accessible through a Web browser. PushToTest TestMaker features record and playback technology for Web applications. PushToTest TestMaker watches your use of a browser and writes a test agent script. To the Web application, the test agent appears to be a Web browser user. The test agent script is a functional test (also referred to as a unit test). PushToTest TestMaker includes HTTP and HTTPS protocol handlers. These handlers provide support for cookies, redirect commands, authentication and HTML parsing. Follow the tutorial to begin using PushToTest TestMaker in a Web application test environment. To learn more about PushToTest TestMaker in a Web application test environment, examine the Web sample test agents and read the tutorials. |
Web Services and Service Oriented Architecture (SOA) provide server-to-server and application-to-application XML communication. PushToTest TestMaker features the soapUI utility to read a Web Services Description Language (WSDL) definition of a service and build unit and function tests. To the Web Service, the tests appear to be a server or application making requests and expecting well formed responses. PushToTest TestMaker includes SOAP and XML-RPC protocol handlers. These handlers support SOAP document-style (message) encoding, SOAP RPC-encoding, HTTP authentication, SOAP over HTTPS communication, and cookies. PushToTest TestMaker provides XML parsing and query capabilities through the included JDOM, XPATH, Xerces, and JAXB libraries. To begin using PushToTest TestMaker in a Web Service test environment, first use the Tools -> Start soapUI menu command to create a unit and functional test, then run the test in a TestScenario as a functional and load test, and service monitor. |
Email systems provide access to email message stores through email client software and Web browser based email access portals. PushToTest TestMaker includes SMTP, POP3 and IMAP protocol handlers to communicate with an email store. PushToTest TestMaker features record and playback technology to use Web browser-based email access portals. PushToTest TestMaker email protocol handlers support MIME attachments, UTF encoding support, and authentication. To begin using PushToTest TestMaker in an email test environment, read the email sample test agent. Then read and understand XSTest to turn the same test into a scalability/load test. Also read the tutorials to learn how to turn that test into a Quality of Service monitor.
|
Many companies deploy Java applications to provide an intelligent graphical interface to a service. For example, Sun Microsystem's provides a Java desktop application to its engineers to enable bug tracking and change management in its products. The application makes SOAP requests to a service to manage bugs. PushToTest TestMaker (a 100% Java application itself) enables test agent scripts to make direct calls to a Java application's methods. The application responds in the same way it would to a real user. PushToTest TestMaker runs Java application tests using the same functional test (unit test) framework as Web application, Web Service, and email tests. To begin using PushToTest TestMaker to test a Java application, read the sample Java application test agent. Then read the TestScenario tutorial to learn how to turn a unit test into a regression, function and load test, and a service monitor.
|
Testing And Remediation
The test environments described in the previous section demonstrate how PushToTest TestMaker provides a framework and utility for building tests to check services for regression, function, scalability, performance, and reliability. PushToTest TestMaker is a unique solution to test and remediate issues that keep a system from achieving its performance and functional goals. For instance, PushToTest TestMaker generates load on a system by executing a Test Sceanrio, and it correlates the running tests with database-and-application-server monitoring and analysis tools to identify costly transactions, bottlenecks to good performance, and optimizations that prevent downtime.
In a black-box test environment, the test environment generates load on a service by making requests to the service and observing the service's response. Black-box scalability testing observes a service's response performance as the number of concurrent requests increases.These observations facilitate capacity planning and identify the service's ability to "go live" in a production environment. The PushToTest TestMaker test environment conducts black-box tests and much more.
PushToTest TestMaker is also appropriate for grey-box tests. In a grey-box test, the service-under-test may be queried for internal information to help uncover functional and scalability problems. The service-under-test provides state information from its internal operation including performance information from the application and database tiers of the service environment. For example, the service responds to special debugging service requests with CPU utilization, I/O utilization, memory allocation, and transaction states. This extra information allows the Test Environment to provide actionable knowledge in three categories:
This section described how to install PushToTest TestMaker, how to get started with PushToTest TestMaker quickly, and how PushToTest TestMaker enables testing and remediation.
This section provides a high-level view of PushToTest TestMaker and the subsequent section describes PushToTest TestMaker in-depth.
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, 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. | |
 |
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 Model, ESB Model, Enterprise Web 2.0 Model, and Virtualization Model.
Software developers introduce extensions to the Domain Model, ESB Model, and Enterprise Web 2.0 Model 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.
The
PushToTest
runtime uses a TestScenario
XML document to define a scalability,
performance, and service monitor test. The Governance platform stores
the TestScenario XML document. The TestScenario is the key to turning
unit tests into functional, regression and load tests, and service
monitors.
The tests use the native protocols of the services under test. The PushToTest runtime provides an extensible protocol handler library (TOOL) with protocol handlers for HTTP, HTTPS, SOAP, XML-RPC, and the email protocols.
The 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; the distributed TestMaker environment.
The PushToTest runtime provides a distributed test environment using TestNodes. A TestNode is the PushToTest runtime environment implemented in Java and runs anywhere Java runs. The PushToTest console communicates with TestNodes over SOAP protocols using port 80, meaning you typically won't have to make any changes to your firewall settings to distribute a set of TestNodes.
The TestNode environment works equally well for software developers, QA efforts, and IT operations. For instance, TestMaker users install TestNodes on a set of remote machines to see, from many different vantage points, how well their application is serving their users. TestMaker users also install a set of TestNodes on a rack of servers within a QA lab to generate very high levels of concurrent use of an application to do high level of scalability and performance testing. Lastly, TestMaker users install TestNodes on a series of different networks to identify whether one network service provider is providing better service than the others.
The
PushToTest
runtime also includes a monitor capability. The monitors watch for CPU,
network, and memory utilization and are
extensible to provide metrics on other facets of your
application. TestMaker users install monitors on Windows XP, Linux,
and Mac OS X systems. The monitor technology is the base for PushToTest
to provide extended functions, including SNMP agentless monitoring and
interfacing with JMX-enabled management interfaces.
The PushToTest runtime offers a SOAP-based Web Service request using the PushToTest As A Service (PAAS) protocol. PushToTest executes the test and returns a Governance Statistics Results Set (GSRS) response document. Use PAAS and GSRS to integrate PushToTest test and monitor data with analysis tools. For instance, PushToTest integrates with the Software AG X-Registry to provide service governance through test automation and integrates with DBA InfoPower to provide insight and remediation of database bottlenecks.
PushToTest TestMaker delivers a rich environment for developing tests including these resources and abilities:
Many first time PushToTest TestMaker users find that running the included sample test agents is a quick way to learn the PushToTest TestMaker system. Additionally, PushToTest provides recorded screen-cast tutorials. The QuickStart guide, documentation and tutorials also help you to learn PushToTest TestMaker.
PushToTest products are designed for software developers, QA technicians and IT managers. Software developers need a framework to conduct system-level unit tests to check functionality. PushToTest TestMaker provides a functionality test framework by enabling construction of unit tests using a variety of languages including Java, Jython, Groovy, Ruby, JavaScript and many others.PushToTest TestMaker agent scripts developed by software developers for unit and functionality tests are then reused by QA technicians to run scalability and performance tests. IT managers run the same agent scripts in the PushToTest TestMaker environment as quality-of-service monitors. This unique approach from PushToTest provides a new way to leverage any enterprise's software development, QA and IT efforts resulting in new, huge cost-savings.
PushToTest TestMaker is written in Java and runs everywhere Java runs, including Windows, Linux, Solaris, Macintosh and more.
The
PushToTest Company distributes a pre-built and ready-to-run binary
of TestMaker under a commercial license (detailed in license.txt). The
commercial license is free and authorizes you
to run up to 200 concurrent virtual users and 10 concurrently running
service monitors. Additional virtual users
and monitors are available for purchase from PushToTest. PushToTest
TestMaker source code is free and distributed under a GPL v2 license.
The PushToTest Company provides a meeting place for the hundreds of
developers that contribute to the open-source project and the 130,000
users that share their knowledge and answer questions about PushToTest
TestMaker. PushToTest provides professional support services, technical
support, and Global Services.
A list of frequently asked questions (FAQ)
Known problems and incomplete features in this release of PushToTest TestMaker
Read the documentation on the docs.pushtotest.com site
Building test agents to check email services for scalability and functionality
Learn about the changes and new features since the previous PushToTest TestMaker release
Additionally, check the testmaker_home/docs/lessons directory for tutorials and articles on using PushToTest TestMaker.
|
