Matt at Appcelerator pointed me to a discussion of Automated Testing of Appcelerator With Selenium on the Appcelerator user forums. I am very interested in ways to use Selenium for testing Appcelerator applications.

From TestMaker's perspective a Selenium test is a unit test of a Web application or Ajax application. TestMaker already provides Test Runners for TestGen4Web, soapUI, and the Java 6 ScriptEngine support for unit tests written in Java, Jython, JRuby, Groovy, and a bunch of others.

It seems to me that the forum members have already hit upon some of Selenium's limitations and design problems:

a) Selenium was not really developed for Ajax, and vice versa. Ajax frameworks like Appcelerator implement their own eventing mechanism and Selenium has no idea of how this works. For instance, when an Appcelerator log-in page changes the DOM to reveal site content Selenium IDE does not notice the change. Selenium IDE will sometimes record a 'click' when 'clickAndWait' is appropriate. I find myself adding 'waitForElementPresent' commands that look for the logout element in the user interface to appear to signal that we've successfully logged-in. As a tester I need to resolve the differences between the Selenese model of my application and the actual application state. This is not fun, error prone, and difficult to teach. Appcelerator does a good job of providing quality element ID values. Consequently I find myself in Firebug and Firefox a lot more than I should to get my Selenium test to run properly.

b) Selenium has no apparent way to provide a test with operational data. I am in the process of writing Data Production Libraries (DPLs) for Selenium IDE as a user extension. My first DPL reads from comma-separated-value (csv) flat files. The DPL opens a file and provides getNext and getPrevious methods to retrieve data from the csv file. I had to write this entirely in JavaScript and it was not fun. I will contribute these to the Selenium project in the next few weeks.

c) Selenium IDE recorded test scripts need to be exported into a scripting language format to implement business test flows. Conditionals, looping, and branching are possible using community contributions. For example, the Selenium Wiki includes a flow control extension.

For the past month I have been working on a design that enables TestMaker to operate Selenium tests. Here is what we have in mind:

1) Browser compatibility tests using Selenium IDE and Selenium RC.

2) Load and performance testing using Selenese scripts and TestMaker.

3) Service monitoring using Selenese scripts and TestMaker.

If this interests you then please participate! The enhancement ticket at design notes for Selenium in TestMaker are at http://bugs.pushtotest.com/ticket/136

-Frank

I'll be giving a keynote talk on SOA Development In The Real World at TIBCO's user conference next week. This will be based on the work PushToTest did to surface the developer productivity and performance differences between TIBCO, BEA, Oracle, and IBM platforms for SOA development. All of the research is available under a free open-source license at http://soakit.pushtotest.com.

If you are attending TUCON then please let me know and I will be glad to meet with you personally.

-Frank

Here are the details:

BPEL Basics for Java Developers Webinar

WHEN: Thursday, April 17, 2008 at 2pm EDT, 11am PDT, 18:00 GMT

WHERE: Online web meeting. Register at https://www1.gotomeeting.com/register/316860522

WHO: Ron Romano, Principal Consulting Architect, Active Endpoints, Inc.

WHAT: Business Process Execution Language (BPEL) Basics for Java Developers. This free, educational webinar is being presented as a service to the Java development community and will introduce developers to the concepts and techniques they need to understand in order to effectively create a new generation of applications based on web services. BPEL for Java Developers maps common Java techniques to their equivalent concepts in BPEL, enabling developers to transition to orchestrating web-services quickly and easily.

WHY: Java is an imperfect development language for creating SOA-based applications. BPEL has been developed as an open standard to address the need for a robust environment to create services-based applications. This webinar introduces Java developers to SOA-based service orchestrations developers by discussing BPEL in terms that Java developers already understand.

This week I was the speaker at SkillsMatter.com in London. I gave a talk on the PushToTest test methodology and free open-source test automation tools to check Web applications, Web services, and Ajax applications for function, scalability, and performance. SkillsMatter is the new European partner to PushToTest to offer training on our products. In June I am back in London teaching our popular Open-Source Test Automation Bootcamp.

Harry Wood attended my talk and posted a blog entry about his experience at http://www.harrywood.co.uk/blog/2008/04/11/unit-testing-soa-and-mule-talks

-Frank

Mule makes an open-source Enterprise Service Bus (ESB) and SOA development platform. Held at the Hilton Hotel in San Francisco over 2 days, Mulecon attracted approximately 400 delegates, including Mule staff. I was very glad to go as the conference let me talk to several Mule ESB users. I had to do a fair amount of begging to get an invitation since PushToTest is the author of the SOA Knowledge Kit, a TIBCO commissioned comparison of commercial SOA/ESB development platforms. (PushToTest will be an exhibitor at TUCON later this month, and I might be in their keynote session.) Maybe someday I will be appointed an ambassador to something. :-)

The presentations varied between Mule staff talking about Mule and the product roadmap and customers talking about their use of Mule. The Mule staff seemed to be singing from the same songbook: Mule claims 13,000 deployments of Mule ESB, Mule 2.0 is not compatible with 1.4 but the migration should not be too difficult as the concepts are the same, Mule Enterprise Edition, Saturn and Mule HQ releases coming late this year.

A Room Full of Architects

It did not take long for me to realize that Mulecon delegates are mostly software architects. Typical questions I heard goes like this:

"Your company inherits a big bank and needs to decide between JMS and Advanced Message Queue Protocol (AMQP) for a universal protocol for your bank. Which would you pick?"

and

"How do you empirically come to a model that will let you uncover the performance characteristics and measurements?"

These are the kinds of discussions that make my wife immediately yawn and roll her eyes! Geeks, there's a lot of 'em in this room.

ESB, Grid, AMQP Approaches

Conversations about hub-and-spoke, virtual circuits, and bus architecture seem to be over. Just about everyone I met expects a heterogeneous architecture where parts of a system are hub-and-spoke and others are bus-based. Easy service interfaces now exist between each type of architecture using daemons and local brokers. Jahan Moreh, VP of Engineering at U1, had a very basic message "Provided the underlying products are good you won't have a problem."

Jahan was more sanguine about guaranteed deliver and performance. In essence "performance and guaranteed delivery are in conflict." Choose one but don't expect both. I very much want to do primary research to determine a standards way to profile performance in a guaranteed delivery setting. Hopefully one of our customers will commission a PushToTest study. (hint, hint.)

I learn about AMQP at Mulecon. AMQP is a protocol-level standards initiative to provide a messaging infrastructure. Jahan told me "AMQP tries to do something very important but may not be attainable. Because they are at the protocol level they may wind up being extensions on the side. I would bet on the JMS side."

POJOs Rule, But Where Is BPM?

Eugene Ciurana of LeapFrog gave a talk about LeapFrog's use of Mule. I just saw Eugene at TheServerSide.com Java Symposium in Las Vegas last week. Boy does Eugene get around!

LeapFrog is marketing a child's toy that features downloadable content – not bad for products that must cost less than a few dollars to manufacture! The backend system to support this effort uses ESB technology to provide flexibility to LeapFrog's software developers and reliability in operating the service and applications.

Many of the question-and-answer sessions at Mulecon include a question on Business Process Management (BPM) such as: "What are you doing for BPM in your architecture?" Eugene took one of these.

This question echoes what I had learned in Las Vegas: Java architects and developers are frustrated looking for Business Process Management (BPM) standards and tools. Brian Sletten's talk at TSSJS was titled "Avoiding ESBs" but could have been better described as "I'm sick and tired of waiting for vendors to give me a decent Business Process Management (BPM) platform!"

At Mulecon, Rory dela Pax of Biogen Idec, told me that "Mule is good at doing some workflow. But, all of us are struggling with BPM. We do a separation of skills strategy rather than overloading the ESB with these tasks."

Over the years I have seen most of the platform vendors try to provide the Java development community with set of products, best practices, framework, and code to implement applications that deliver business flows. I am specifically remembering the failures of JBI, JEMs, BPEL, SCA, and WS-*. None have come together to offer a standard. I sense a lot of anger and disappointment at all the failed attempts. Mostly disappointment from me.

Eugene answered the BPM question by telling the delegates that LeapFrog pushes all of its development to Plain Old Java Objects (POJOs.) They actively separate every application from each other. LeapFrog then uses Mule routers to define the inputs and outputs. Eugene said "We are not doing any transactional data at Leapfrog. Our support is for the toy devices." He added that Leapfrog has a separate side of the IT house for Oracle tools and BPEL.

Mule and Clustering

Rory dela Pax of Biogen Idec gave a brief talk on their migration from BEA WebLogic Integration (WLI) to Mule. The migration came about like many companies adopting an open-source project: A developer mentioned it during a water break conversation. The environment was ripe: Biogen Idec found WLI to be "a bit on the heavy side, unstable, and has not scaled well." They were also leery of the rumors of the Oracle buy-out since late 2006. They found that Mule has a one-for-one match in capabilities, plus they see Mule as lightweight, stable, and scalable.

I can understand lightweight and stable, but the scalability claim seemed to need some proof. Rory tells me they achieve scalability by using WebLogic Server (WLS) 8.1 SP6's clustering. They deploy their Mule application as a WAR file in a cluster of JVMs in WLS. There are no separate JVMs in their environment. I imagine the gaul the WLI product manager must feel at being swapped out. :-)

Still, there is a lot that Biogen Idec needs to learn about clustering. They still need to define the best way to cluster. Rory told the delegates "We don't know how to do that." They would like to define clustering methods in environments where message sizes grow larger. Right now their application uses simple verb+link combinations. The incoming request is to approve an invoice and the response contains a link to bring the user's browser into the application.

Rory told me some of the downsides to using this WLS clustering approach. For example, they use Quartz as a scheduler. In this WLS clustering set-up changing the Quartz schedules means redeploying the application to the cluster.

Moving Up To Mule 2.0

Mule 1.4 uses DTDs to define pretty much everything – settings, configuration, deployments. Mule 2.0 delivers XML Schema based configuration that leverages Spring's "Extensible XML Authoring." The result is less cumbersome class names because of namespace support. They are updating their Eclipse support to provide auto-completion and context-specific help. Mule 2.0 features transport-specific endpoints and connectors and now everything is done through typed properties. There is a lot of extensibility because each module/transport comes with its own schema. Mule 2.0 lets you implemtn your own schema too.

Some additional changes in Mule 2.0: CXF supercedes XFire (XFire is still available,) there is a new expression evaluator framework, streaming improvements, auto-transformation, and lots of bug fixes. Plus, Mule 2.0 has 30% more unit tests over 1.4. Mule uses Spring to implement Beans. Mule uses session and entity (data) beans inside the Mule container or through proxies to external data services.

Mulecon left me a few questions:

1. How important was the Spring-based approach to building services to Mule's popularity and success?
2. Is anyone, I mean anyone on Earth, using OpenESB from Sun? None of the Mule users had any experience with it.
3. How are Mule and Mule users testing Mule for scalability and performance? Mule 2 provides hundreds of unit tests but apparently no performance tests, at least none that I could find.
4. What are the tradeoffs of an ESB versus Gigispaces, Tangosol and other grid environments?

Mulecon impressed me with its quality presentations and delegates. I will keep it in mind when PushToTest does its first user conference, PTTCon, or PushCon, of TestCon, or who knows!?

-Frank

We've been making very good progress in building TestMaker 5.2. I'm feeling like a proud father and want to show off my child's cleverness. In TestMaker 5 we introduced a new system of ScriptRunners. This is an extensible facility to operating externally created functional unit tests within a PushToTest TestMaker test. We bundled Eviware soapUI and SpikeSource TestGen4Web with TestMaker and provided ScriptRunners for each. As a result of the latest work TestMaker tests share data between ScriptRunners through a Data Production Library (DPL.) For instance, a functional test first makes a SOAP-based Web service request to learn product information codes and then makes a Web application (HTTP) request to make sure customers are finding the products.



PushToTest orchestrates a Functional test by defining the operating parameters and use cases in a TestScenario document in XML format, as illustrated above.

The test identifies a PushToTest Data Production Library (DPL) that will be the exchange medium between the soapUI TestCase and the TestGen4Web recorded test. The soapUI TestCase reads the data value for the SOAP request from a Properties file in the soapUI project. The soapUI TestCase receives the SOAP response and saves the response parameter to the DPL.

The TestScenario instructs PushToTest to then run the recorded TestGen4Web unit test. The test uses the DPL data from the soapUI test to make an HTTP Get request to the Web host. That concludes the functional test.

I am happy to make the above example available for immediate free download at http://downloads.pushtotest.com/tm5/EndToEndTestExample.zip

You will need the latest TestMaker 5.2 (pre-alpha) version to operate the example. See the faq for instructions on getting the code.

Enjoy.

-Frank

Over the past year PushToTest observed a trend among the 160,000 people in our open-source community: Software developers, QA testers, and IT managers are looking for a better way to develop, orchestrate, deploy, and manage services. The Composition Approach to Building Large-Scale SOA introduces a new service composition approach to building SOA services, explains composition, and provides a methodology and test kit to evaluate today's tools for developer productivity and ease of deployment/management.

Last week, TIBCO hosted me on a Webcast to talk about Service Virtualization, Service Composition, and the SOA Knowledge Kit. The Webcast is now available at:

http://media.tibco.com/video/tibco_031808/index.html

 

-Frank

I often get asked questions like "What does PushToTest do?" PushToTest is a test automation solutions business. We surface scalability and performance problems in Web-based information systems. Our PushToTest solution drives a Web system like a real user and correlates the activity to identify broken functions and hot spots of performance issues. The same system then operates tests periodically through the day to monitor an enterprise's services and provide proof-of-service reports. See our "white paper", http://downloads.pushtotest.com/PushToTest_WhitePaper.pdf for a more complete answer. I often get asked a follow-up question that is usually asked like this: "I was wondering if you could provide me a sample of the outputs the system generates (or can generate)." The PushToTest software produces a summary report that shows the Scalability Index to the application, the resource utilization as the test operated, and the performance as load increased. This summary report is an HTML document and is easily shared among your team members. "Click here", http://downloads.pushtotest.com/tm5/ExampleSummaryReport/index.html for an example summary report. I often also get asked about the PushToTest methodology and techniques to find and solve performance issues. The question is often asked like this: "Once you run a test and the results are not acceptable then how do I leverage the PushToTest tools to find the code that is running slow?" PushToTest version 5.1 keeps track of the steps for each transaction. For instance, the following snippet of a TestScenario implements a test use case where four steps are required for each transaction.

<test>
   <run name="Open Account" testclass="com.pushtotest.WebAppTest"
method="testOpenAccount" langtype="java" />

   <run name="Transfer Funds" testclass="com.pushtotest.WebAppTest"
method="testTransfer" langtype="java" />

   <run name="Check Transfer" testclass="com.pushtotest.WebAppTest"
method="testValidateTransfer" langtype="java" />

   <run name="Close Account" testclass="com.pushtotest.WebAppTest"
method="testCloseAccount" langtype="java" />

</test>

In the above test PushToTest operates four steps: Open Account, Transfer Funds, Check Transfer, and Close Account. PushToTest keeps track of the total transaction time and the time for each step. The time of each transaction and step is stored in the transaction log file. When a particular step takes longer than expected you can break open the transaction logs for the application server and learn what was going on at that point in time. We have been hard at work over the past two months building an Enhanced Results Analysis engine. The new feature will appear in PushToTest version 5.2. It is already working and we are happy to provide it to anyone that "asks", http://www.pushtotest.com/ask_a_question. The new engine makes it much easier to visualize broken functions and hot spots to performance. Consider the Step Report that visually charts the average duration of each step across 10 equal periods of time of a test. The reporting is great but that still leaves the correlation effort up to a software engineer. And, it is a manual process to go from PushToTest logs to the application server logs. Our planned solution is to incorporate "Glassbox", http://www.glassbox.com into PushToTest version 5.2. Glassbox watches a Java application server for performance hotspots as a test operates and identifies the objects and database connection level issues causing the hotspots of performance. "Click here", http://bugs.pushtotest.com/ticket/61 to learn about the integration project. To learn more about Glassbox "click here", http://www.glassbox.com/glassbox/Download.do?mediaItemId=173 to read the Glassbox user guide. One final question I usually hear goes like this: "Where exactly are your developers located? In other words when you leverage out-of-country developers, where are they and if the customer wanted US based developers can you accommodate that." PushToTest outsources its customer engineering to our Costa Rica-based partner "Avantica", http://www.avantica.net. Costa Rica is a 4-5 hour flight to the United States and Canada. The country is on Central Time (GMT -6) and their English is very good. We normally need about one week to plan for our engineers to be in your office. -Frank

This morning I am glad to introduce you to a new set of resources to help surface scalability and performance issues in Service Oriented Architecture (SOA.) The SOA Knowledge and Performance Kit is a free open-source resource to show you what it really takes to build services using today's leading SOA development platforms.

The Kit delivers an SOA use case design, source code to the implementations of the use case on Oracle, IBM, BEA, and TIBCO platforms, developer journals describing our experiences step-by-step, a Total Cost of Ownership (TCO) calculator, and performance and scalability tests that leverage the PushToTest test automation platform.

PushToTest looked below the surface-level marketing claims to understand the skill sets, domain expertise, and specialization that it takes to be successful. We discovered a wide variety of experiences: some highly successful and others rife with challenges. We measured the amount of developer effort to implement an SOA use case and summarize the findings in the following total cost of ownership (TCO) comparison chart.

This morning we opened the doors on a new center within the PushToTest Web site for you to learn more about SOA, learn about the new composition approach to SOA development and deployment, and download the kits.

SOA Knowledge and Performance Kit

-Frank

We are getting very close to the PushToTest 5.1 release - hopefully this week! New datasheet and white paper downloads are available to explain PushToTest and open-source test automation:

PushToTest 2-Page DataSheet

PushToTest White Paper: The Importance of Test Automation

Both are in Adobe Acrobat (PDF) format.

-Frank

A lot of QA testers are coming to the realization that testing applications built on Java, Database, and Application Server tools can't get them from here-to-there when using the old-and-trusted record/playback test tools. The problem often starts when a database instance needs to service client Web interfaces with dynamic data at the same time as the middle tier is serving Ajax (XML, String, and JSON) data for rich browser interfaces, and REST and SOAP interfaces with transactional data.

New tools have emerged over the past year - such as soapUI, Selenium, and PushToTest - that are designed for Web application, Web service, and Ajax testing. Pulling these tools and platforms together into something that the average database developer, application engineer, and tester can use requires a lot of effort.

To meet this need, PushToTest is now offering a Bootcamp to train technical folks how to leverage soapUI, Selenium, and PushToTest. Details are found at http://bootcamp.pushtotest.com

-Frank

Last week PushToTest hosted the first of a new series of 2-Day Hands-On seminars on Test Automation. The event sold out and the room was packed with eager students. Some traveled from Michigan to the seminar in Silicon Valley, California.

Here are some of my notes from the seminar:

1) The students at the seminar were from a rich cross section of backgrounds and experiences. We had software architects, software developers, QA testers, database administrators, and project managers. This shows me that test automation is a multi-discipline effort. It is not enough anymore to throw testing over the wall to a bunch of testers and not worry about the results.

2) TestMaker is in better shape that I had thought. In the days that lead up to the seminar I was concerned that the usability in TestMaker would make the hands-on portions difficult to follow. I was happy to none of the students ran into any roadblocks that kept them from completed the workbook of tasks. (This is not to say that we can put off usability improvements in TestMaker. Usability is a big issue in my eyes.)

3) The students universally told me they are not finding commercial test automation tools that are appropriate for Web application, Service Oriented Architecture (SOA,) Ajax, Web service, and Web 2.0 testing. As a result they often have one tool for Web application testing and another tool for Ajax testing.

4) Many students liked the informal style of the presentations. They were looking to gain an understanding of testing in the 21st century and take home tactics and methodology they will use in their own environment.

5) Several of the students are working in SOA environments and were interested to learn about TestMaker integration with registry/repository products. See here for details

The next seminar events are in London, New York, and then back in Silicon Valley. For details check http://www.pushtotest.com/Docs/training/seminarform.

-Frank

PushToTest is partnering with ReplicateTech to provide virtual and dynamic testbeds using PushToTest TestMaker 5. Our first step in this partnership is to develop knowledge of how TestMaker operates in the ReplicateTech environment. Today we completed installation of the PushToTest TestMaker 5 environment and the Sun Blueprints Petstore 2 (beta) onto the ReplicateTech lab.

Sun has very much moved the Petstore forward from the current 1.3 version. Petstore 2 is an entirely new application that delivers a rich Internet application using Web 2.0 technologies: AJAX, RSS, mashups, and client-side animation.

We are going to create a set of TestMaker test scripts to test the Ajax capabilities of Petstore 2. We should be ready in a day or two with these scripts to conduct our first scalability test.

Our plan is to use the "snapshot" capability to record the initial state of the Petstore and its Derby database. Then to operate the test at 10 levels of concurrent requests and 3 varieties of sequences. ReplicateTech uses VMWare so the snapshot capabilities will make rolling-back the Petstore to a known initial state easy.

I will be keeping a diary of the experience and use it to write an article for one of the on-line developer communities and to be incorporated into the TestMaker documentation.

Feel free to post your comment about this project.

-Frank

Elliotte Harold put together a good summary of the state of native XML database technology here. His announcement of the information to the XQuery-talk email list elicited a big response. XQuery-talk is a list started by Jason Hunter of MarkLogic and is populated by the architects, developers, and consultants in the native XML database market. The list is a good place for users to post questions to get at comparisons of capabilities among the native XML database products.

I waded into the discussion with some thoughts of my own:

---

For a topic titled "The State of Native XML Databases" the conversation seems to be more about semantics. From my perspective the state of native XML databases is pretty poor. There is not that much uptake on native XML databases from enterprises, developers, and architects.

It seems to me that native XML databases would be in a much better state when the following happen:

1) The Implementations Provide The Full Benefits of The Data Model.

The XML data model is wonderfully rich and flexible. There is big divide that developers have to overcome when going from the XML data model to an XML database. It is not a given that XQuery is way to implement a database for the XML data model. When I was at the W3C Plenary 2 years ago there was plenty of energy in discussing alternatives to XQuery and XSLT. And I would prefer to write code today, not wait another 7 years for a standard like XQuery to emerge.

It seems to me that developer marketing from the native XML database vendors and open-source projects is mostly disingenuous when they position their products as a general-purpose database. In my experience most of the native XML database projects come to the XML data model from a different perspective and that impacts their implementation of the data model as an XML database. For instance, there is still argument on this list about the best way to create a collection with one perspective using XML Schema and others arguing for an language semantics approach. (By the way, neither work for me as a Java developer. I want to from object definitions and maybe Java annotations to a collection.)

As a developer I would prefer to know which native XML database is suited to my application. For instance, Ilya's application requires node-level locking and my design for the next generation of TestMaker requires roles-based securing at the XML document level. In the RDBMS marketplace I have many resources to show me which databases are appropriate for my applications. The native XML database marketing needs something similar.

2) The lack of thought leaders

Where are the Tim Bray's, the Adam Bosworth's, and Erik Meijer's, the Sam Ramji's for the native XML database space? I had great hope for Jason Hunter but even his star is taking a while to cross over from the Java to the native XML db space.

The native XML database space needs someone of reputation and standing in the Java and .NET developer community to stand-up and show some great and practical applications.

3) The lack of tools

I like some of the tools I have seen. The Progress tools set is nice. I would love to see native XML database support with a flexible binding system in NetBeans, in Visual Studio, Eclipse, IntelliJ.

4) The lack of a clubhouse

I want a place to meet up with all of you! JavaOne, JavaPolis, JAOO, and QCon are my place to meet up, share ideas, and exchange solutions in the Java space. I would love to have XMLOne once a year!

I spent 2005-6 inside Raining Data and know first hand what it is like to ask a quarter-by-quarter focused management team to invest in developer programs.

A lot of work is still needed to move the state of native XML databases to "excellent".

-Frank

The Server Side ran our announcement of TestMaker 5 today at:

http://www.theserverside.com/news/thread.tss?thread_id=46598

We also issued a press release on the new product. Download the press release

If you are so inclined, please post a reply asking a question or telling of your experience using TestMaker. The more you post the more attention we get.

Thanks.

-Frank

Perry Donham of Aberdeen gave a short Web conference this morning to talk about his upcoming research report on SOA and Web Service QA and Test. The report covers the basics: why test, popular test methodologies, and top testing challenges. One of the interesting factoids to come from the research is the large number of software developers that are testing SOA and Web Service applications. When asked the question

"Who does the testing?" the answers were:

QA: 79%
Developers: 53%
End users: 37%
External beta testers: 17%

That confirms the research we have conducted in the PushToTest community. SOA, Web Services, AJAX, and Web application testing tools normally require technical skills that QA technicians do not posses. My assertion is that developers play an increased role in the lifecycle to build services. We see developers having an increased role in testing.

Astonishing to me is the answer from 37% of respondents that End Users do the testing. How would you like to be a customer of those companies?

-Frank

TestMaker 5 will go into "Release Candidate" distribution this week. This is the final release before we declare it to be the stable release. We are now finished writing the documentation, tutorials, and screencasts. The screencasts provide a visual way to learn TestMaker.

Screencast Introduction For TestMaker 4 Users

Screencast on Building Load Tests, Functional Tests, Service Monitors

Architectural Goals of TestMaker 5

The JavaPolis conference is a once-a-year event in Antwerp, Belgium where 3000+ Java developers meet to talk about the latest technology, patterns, and trends. I gave a talk on the FastSOA patterns. I talked about the scalability and performance problems Java developers encounter when they use the "domain model" of servlet, EJB, and relational database technology to build XML-oriented applications, including SOA and Web services.

JavaPolis video taped my talk and now host the presentation on the Parleys.com Web site.

http://www.bejug.org/confluenceBeJUG/display/PARLEYS/FastSOA?showComments=true

I was very happy to be at JavaPolis, but you may note after watching the video just how bad I was feeling after a night of partying. (It's all Chris' fault.) Wonderful and horrible at the same time! :-)

-Frank

InfoWorld now has a product information page for PushToTest TestMaker. The page includes their review, in which they give TestMaker 4.4.1 an "Excellent (8.7)" rating. The InfoWorld page has a section for reader reviews. If you have anything nice to say about PushToTest then please post your comments here.

The review says in summary: "PushToTest's TestMaker is a powerful, professionally crafted package. There are lots of useful test code examples, and its documentation surpasses all expectations. But it has a steep learning curve, and you'll need to know Python to get the most out of it."

This brought an ear-to-ear smile to my face. They think the current release (4.4.1) is excellent and talk about the learning curve. I can't wait until they see PushToTest Version 5! Version 5 delivers a distributed test environment and a much easier learning curve. Version 5 supports 6 scripting languages (Java, Jython, JRuby, Groovy, Rhino-JavaScript, BeanShell, and others.) Script development is made easier with the TestGen4Web browser plug-in to record scripts and integration and bundling of soapUI, a powerful utility for building functional tests of SOAP-based Web services. Lastly, version 5 delivers an easy way to define a test using an XML Test Scenario format.

The InfoWorld review also gave soapUI an "Excellent" rating. The combination of the two is going to be a killer application for software developers, QA technicians, and IT managers.

Details on PushToTest Version 5 are here.

-Frank

On the second and third day of my coverage of the JavaOne conference I provide an update on the JBI and SCA standards, and examine Tibco's ActiveMatrix product. I examine virtualization technology for deploying SOA services, get an update on DWR 2.0 and delve into the politics behind the JCP. After spending an evening with performance geeks, I presented a BOF on dynamic scripting.

Read the complete report at: http://www.theserverside.com/news/thread.tss?thread_id=45357

-Frank