As a software developer all I need is a test automation tool that:
- Downloads for free and installs in minutes
- Runs on my desktop or laptop development machine
- Comes with its source code and active community support
- Turns my unit tests into functional tests
- Supports the languages I know how to program, including Java, Python, Groovy, PHP, Ruby, Spring, and many others
- Supports Web applications, Service Oriented Architecture (SOA,) Web Service, AJAX, Web 2.0, and REST services using their native protocols (HTTP, HTTPS, SOAP, XML-RPC, and the email protocols, SMTP, POP, and IMAP)
- Plugs into my build environment, continuous integration environment, and source code repository
- Correlates load generated against my software to the application server activity to find the root-cause of performance bottlenecks and suggests object and thread-level optimizations
- And, lets me hand-off my tests to QA to operate as smoke
tests, load tests, and regression tests, and IT as a service monitor.
PushToTest Reduces The Complexity of Testing
PushToTest TestMaker reduces the complexity of testing by supporting your existing techniques, languages, and architecture to get you from start-to-test rapidly and easily. Write unit tests in your choice of framework, including JUnit, TestNG, and others.
TestMaker enhances your unit tests by providing protocol handlers to speak the native Web, SOA, Ajax, Web Service, REST, Email, and custom network protocols of the application or service. Additionally, TestMaker enhances unit tests with a Data Production Library (DPL) to provide test data as input to the test and data to validate the test results.
PushToTest TestMaker is a distributed test environment that takes your unit tests and wraps them in a TestScenario.
A TestScenario operates the unit tests as a functional test by operating a sequence of unit tests once, as a load test by operating sequences of the unit tests in concurrently running threads, and as service monitors by running the unit tests periodically.
The TestScenario defines which TestNodes will operate the test. Each TestNode is the distributed PushToTest TestMaker environment. (Installing TestMaker installs a TestNode on your development machine by default.) When the TestScenario begins it moves the unit test and any other resource files to the defined TestNodes. The unit test speaks the native protocols of the application under test. The TestNodes provide the unit test data through the DPL, operates the unit tests, and logs the results.
As the TestScenario operates the test, a monitor watches the application host and logs usage and resource statistics. TestMaker correlates the monitored data to the unit test operation to identify performance bottlenecks and available optimizations.
Consider the following Java example unit test that uses a TestMaker HTTP protocol handler to test a Web application.
package com.pushtotest;
import com.pushtotest.tool.protocolhandler.ProtocolHandler;
import com.pushtotest.tool.protocolhandler.HTTPProtocol;
import com.pushtotest.tool.response.Response;
import junit.framework.TestCase;
public class WebAppTest extends TestCase {
private HTTPProtocol http = null;
public WebAppTest(String testName) {
super(testName);
}
protected void setUp() throws Exception {
String url = "http://examples.pushtotest.com";
http = ProtocolHandler.getProtocol("http");
http.setUrl( url );
}
protected void tearDown() throws Exception
{}
/**
* Test of calcInvoiceAmount method of the service
*/
public void testCalcInvoiceAmount() {
System.out.println("calcInvoiceAmount");
int PONum = 135;
String expResult = "1000";
String result = http.connect();
assertEquals(expResult, result);
}
}The setUp() method instantiates a TestMaker HTTP protocol handler object and points it to the Web application URL. The testCalcInvoiceAmount uses the protocol handler to make a request to the application and asserts an exception if the result is not equal to 1000.
TestMaker uses the unit test as a load test in the following TestScenario:
This TestScenario instructs TestMaker to distribute the WebAppTest.jar containing your unit test to the TestNode on localhost (the default TestNode installed with TestMaker on your development system.) The TestNode then instantiates 50 concurrently running Threads (crlevel value="50".) Each thread instantiates a WebAppTest object, calls the setUp() method at the beginning of the test, and then repeatidly calls the testCalcInvoiceAmount method during the duration of the test. At the end of the test the TestNode calls the tearDown() method, ends the 50 running Threads, and then repeats the process at 100 Threads.<testscenario xmlns="www.pushtotest.com/tm5"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="www.pushtotest.com/tm5"
version="2.0">
<basics>
<name>DPL Test</name>
<defaultdirectory>./dpltest</defaultdirectory>
</basics>
<testnodes>
<node name="localhost"
location="http://localhost:8080/TestNetwork/ws/TestNode"/>
</testnodes>
<resources>
<jar path="./WebAppTest.jar"/>
</resources>
<loadtest>
<testusecase>
<dimensions>
<!-- The count of sequences the test operates concurrently -->
<crlevels>
<crlevel value="50"/>
<crlevel value="100"/>
<crlevel value="150"/>
</crlevels>
<usecases>
<usecase name="TestInvoicesCase">
<sequence name="TestInvSequence" proportion="100">
<setUp testclass="com.pushtotest.WebAppTest"
method="setUp"
langtype="java" />
<test>
<run testclass="com.pushtotest.WebAppTest"
method="testCalcInvoiceAmount"
langtype="java" />
</test>
<tearDown testclass="com.pushtotest.WebAppTest"
method="tearDown"
langtype="java" />
...
As the test operates TestMaker consolidates the logged result data and timing values and presents a real-time graph of the throughput of the application under test.
TestMaker consolidates the monitored resource usage of the application server hosting the application under test and correlates the load test activity to the obeservations of the backend system.
TestMaker turns test results data into actionable knowledge, including charts and graphs that show the scalability index, result timing distribution, and performance timing by operation. TestMaker reports results in PNG graphic file format, comma separated value (CSV) format for import into spreadsheets and other data analysis tools, and logs data to XML files, and relational database (RDBMS) tables. TestMaker results analysis identifies areas in the application to optimize to resolve performance bottlenecks.
See the PushToTest TestMaker tutorials to learn how to add a DPL to this unit test.
PushToTest TestMaker is Easy To Use
PushToTest comes with an easy-to-use graphical user interface, installers, tutorials, screencasts, and example code for every aspect of the PushToTest TestMaker platform.- Plugs it into your continuous integration environment,
source code repository, and build system
- TestMaker is a 100% Java application and runs everywhere Java runs, including Windows, Unix, Linux, Mac OS X. TestMaker requires and comes with Java 1.6.
Create Tests and Service Monitors Without Coding
TestMaker provides Recorders and Wizards to watch your use of an application or service to create a unit test of a Web application, Ajax application, and SOAP-based Web Service automatically.
Use the integrated Firefox TestGen4Web plug-in to record Web application test use cases with no programming experience required.
Use the integrated Eviware soapUI utility to build test use cases for SOAP-based Web services. WSDL goes in, test use cases come out.
Additionally, the included Network Proxy Recorder watches the network-level interactions between Microsoft Internet Explorer browser or desktop applications and creates a new unit test script in Jython for you automatically.
Finally, use the TestMaker unit test Wizard to write a script or class that implements a JUnit TestCase in any of the supported languages.
PushToTest Improves The Speed of Development and Deployment
PushToTest TestMaker helps you set the requirements for a test automation platform, evaluate, and make recommendations. PushToTest is the fastest way to speed your development and deployment projects.- No Expense,
No Budget, No Fees to Get Started Today - The PushToTest
Company distributes pre-built, tested, and ready-to-run
binary of TestMaker under a free commercial
license. 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. Click
here for details. PushToTest TestMaker source code is free
and distributed under a GPL v2 license.
- 2-Days From
Start-To-Test - PushToTest gets software
developers, architects, QA testers, and IT managers from start to
testing in the span of a 2-Day
training course. The course is taught in your
facilites, at PushToTest's Silicon Valley offices, at Skills
Matter
(our European partner) training facilities in London, or by Web
conference.
- The PushToTest environment is fully extensible to support new protocols, interfaces, encoding styles, and libraries. Click here for details on accessing the source code and building TestMaker.
Learn More With PushToTest Screencasts
 Screencast
Introduction For TestMaker 4 Users |
| Google
TechTalk on TestMaker |
| Screencast
on Building Load Tests, Functional Tests, Service Monitors |
| Architectural
Goals of TestMaker 5 |
TestMaker is a test automation framework and utility to help you understand and solve functionality, scalability and performance of services. Get started today... download TestMaker.
Get hands-on today... download TestMaker
