Who’s On Phirst

In our quest to better support AIX 5L V5.3 as both a server and client platform for Phurnace Deliver, we recently got a new piece of hardware, an IBM Power 520 Express. I am the one that usually sets up any new hardware, so the job of installing and configuring AIX fell to me. I soon found that AIX is a completely different animal than Linux. The majority of my previous *nix experience has been with Red Hat. Those of you with more Unix or AIX experience than I are probably laughing at my predicament. The more charitable among you (or those of you that also started in bash on Linux) may feel a pang of pity as you remember your first days trying to navigate the Korn shell. Where’s my auto-complete? Why isn’t the up key working? I can’t use the arrows to get to my typo? No wget? No vim? No samba? No sudo? My god…I can’t even SSH or SCP! Thankfully the good folks at IBM have provided a couple of downloadable content packs to ease the transition from Red Hat to AIX: The AIX Toolbox for Linux Applications and The IBM AIX Expansion Pack.

The IBM AIX Expansion Pack features a bunch of optional packages, most of which I didn’t need. I was able to find the following packages that have been very useful: OpenSSH & OpenSSL for AIX; several versions of the Java SDK for AIX (32-bit & 64-bit); Firefox 2.0 for AIX.

But The AIX Toolbox for Linux Applications made me feel like I had clicked together my little ruby Converse clad heels and said “There’s no Desktop like Gnome. There’s no Desktop like Gnome.” It was chock full of useful Linux applications, libraries, and utilities that made my transition to AIX much smoother. You can get a full alphabetical list here. This is where you’ll find things like wget, diffutils, alternative shells (hooray bash!), Gnome, vnc and a ton of other really useful stuff. So if you’re used to Linux and find yourself working in AIX, check out both offerings. It will save you a boat load of time.

In AIX
Comment (0) Read More...

In my previous post, "Automatically generate XPath Expressions in Java,” I showed you how you could use Java to automatically generate XPath expressions from a single xml document or a group of XML. So now you have your XML files and the XPath expressions to validate them…but how do you do it?

Below is a sample Java class for verifying your XML using XPath expressions. Enjoy!

In Xpath Expressions, XML
Comment (0) Read More...

Being the honorary dev environment manager at Phurnace is a lot like being the employee of the month at a pig farm. Sure it sounds prestigious, but it really just means that you are able to deal with a lot of crap and you never mention how much it stinks. On the plus side, holding this title has given me a lot of insight into what our customers experience on a day to day basis. J2EE web application environments are difficult to manage. While the common commercial offerings provide great performance and availability for your web applications, the management and configuration of these platforms seems to have escaped the consideration of vendors for the most part. It doesn’t take long to become hopelessly mired in a deep directory tree digging through XML or a labyrinthine administration console that might as well be written in cuneiform.

The inclusion of Properties File Based Configuration (PFBC) in WebSphere 7.0 signifies a change in how platform providers view configuration challenges. They have recognized the pain and are now starting to address it. The aim of PFCB is to make the configuration data more accessible to users by storing it in key value pairs that are a little easier to read and understand than XML might be. The interface between these properties files and your application server configuration is a command line tool aptly named the Properties File Based Configuration Tool (PFBCT). The PFBCT is an extension of the wsadmin scripting interface and has 4 main modes of operation:

• applyConfigProperties - applies properties in a specific properties file to the configuration
• deleteConfigProperties - deletes properties in your configuration as designated in a properties file
• extractConfigProperties - extracts configuration data in the form of a properties file
• validateConfigProperties - verifies that the properties in the properties file are valid and can be safely applied to the new configuration

On the surface this sounds great. We have the methods we need to collect, test, update, and delete configuration information, and it seems pretty straight forward. This approach is similar to the approach of Phurnace Deliver because it abstracts the configuration data from the configuration mechanism. This makes configuration data easier to propagate in a large environment or port during environment updates.

Ultimately, I have to chalk this one up as a swing and a miss for IBM. PFCB (and its associated ‘T’) fails to simplify configuration management. In light of the following, I feel it complicates it further.

• The implementation is woefully inefficient - One of our fundamental beliefs as a company is that SCRIPTING IS NOT THE ANSWER and IBM has not given us a reprieve with this new tool. The implementation relies on the CLI and is very reminiscent of the wsadmin interface. In fact the only palpable difference is that the wsadmin syntax has been replaced with a different, but equally confusing PFBCT syntax. For example, to create a properties file for a server object you’d have to execute the following using the tool:
  AdminTask.extractConfigProperties('-propertiesFileNserver1Config.props, -configData Server=server1')
• The abstraction stops at resource attributes. You’ll notice from the example above, the object ‘server1’ must be explicitly declared in order to act on it. So if you have dozens of application servers and you need to collect configuration data from all of them, it requires dozens of individual PFBCT executions. In Phurnace Deliver, you just need to supply connection information and Deliver interrogates the server, gives you a choice of nodes to work with, and you’re off to the races, collecting the configuration data for all servers on the node or a subset of servers that you define. You also can get all the configuration data from Cluster, Cell, and Node scoped resources in your environment in the same shot.
• PFBCT supports only the most commonly used configuration attributes. Most notably absent are the attributes pertaining to Service Integration Busses.
• Absolutely no reporting of changes made. Nothing has been done to provide administrators with a summary of the changes made on execution. Instead, the PFBCT assumes you’re cool with “no news is good news.” When your company’s point of transaction is on the line, is that really sufficient?

On the one hand it’s heartening that IBM recognizes and has started addressing the problems associated with managing complex application server environments. On the other hand, this solution is anything but complete and seems like little more than an afterthought. I’ll be interested to see where they go from here. In the meantime I’ll stick with Phurnace Deliver.

In WebSphere 7.0, Properties File Based Configuration PFBC
Comment (0) Read More...

Anyone who’s worked with J2EE application servers has more than a passing familiarity with XML. It’s the weapon of choice for configuration in the 3 platforms I’ve spent most of my time working with; JBoss, WebLogic, and WebSphere. When I first started working at Phurnace, I would verify these files by hand using a diff tool that could handle single documents or a directory tree. I would compare a ‘known good’ configuration to the configuration produced by Phurnace Deliver. This worked great while I was getting my feet wet and finding my way around each platform’s configuration peculiarities.

For obvious reasons, this method sucked a lot after I got a handle on the different configuration conventions used by each platform. The process was incredibly monotonous and error prone. My mind would start to wander as I robotically clicked through the differences in dozens of XML files. Most of the time the differences were expected due to system generated unique IDs or environmental differences. I decided I needed to automate this process simply because I dreaded doing it manually. Because we were dealing with XML, XPath seemed to be the obvious choice for programmatic validation. So I just needed to whip up some XPath expressions and a simple Java class to resolve them and I was done. No bubbles, no troubles. Right?

Well I was forgetting that a WebSphere profile with one node and one server contains more than 100 individual XML files ranging in size from <1K to 600K+. If I thought using the diff tools was tedious, it was nothing compared to generating thousands of XPath expressions by hand. Plus, every time the product expanded into new areas of configuration, I was looking at hours of updating the automation data to keep it current. I needed a tool that would generate these XPath expressions for me. I had some specific needs that weren’t addressed by the sample classes and open source solutions I was finding on the web so I decided to write my own. Keep in mind:

 

• Coding isn’t my forte. You may find bone-headed logic or hacky work-arounds. But for my purposes it works and it’s quick. Consider it your chance to test the tester and file a bug by leaving a comment. I’d love to get feedback and improve it!
• This is a simplified version of the class I use and it works fine on simple XML. This sample class has some limitations. It doesn’t handle namespace designations and I haven’t added handling for special characters. I encourage you to play around with it and add methods that suit your purposes.

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.apache.commons.lang.StringUtils;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class XPathGenerator {

	/*
	 * fileList - a list of files to generate XPath expressions from xpath - an
	 * xpath instance used to verify generated xpaths
	 */
	private static List fileList = new ArrayList();
	private static XPath xpath = XPathFactory.newInstance().newXPath();

	/*
	 * Simple utility method that checks for whitespace at the beginning a text
	 * node
	 */
	private static boolean isWhiteSpace(String nodeText) {
		if (nodeText.startsWith("\r") || nodeText.startsWith("\t")
				|| nodeText.startsWith("\n") || nodeText.startsWith(" "))
			return true;
		else
			return false;
	}

	/*
	 * Simple utility method to verify brutishly assembled xpath expressions
	 */
	private static void checkXPath(String xpathExpression, Node node) {
		Object xpathCheck;
		try {
			xpathCheck = xpath.evaluate(xpathExpression, node
					.getOwnerDocument(), XPathConstants.BOOLEAN);
			if (xpathCheck.toString() == "true") {
				/*
				 * print the file/xpath combo to use for future verification For
				 * Example:
				 * file:/C:/tmp/sample.xml=/rootNode/firstChild/firstGrandChild
				 * [@attrib="value"][text()="some text"]
				 */
				System.out.println(node.getOwnerDocument().getDocumentURI()
						+ "=" + xpathExpression);
			}
		} catch (XPathExpressionException xpe) {
			System.out.println("\n\n" + xpathExpression);
			xpe.printStackTrace();
		}
	}

	/*
	 * Simple utility method to check for a text node on the currenrt XML
	 * element
	 */
	private static boolean hasValidText(Node node) {
		String textValue = node.getTextContent();

		return (textValue != null && textValue != ""
				&& isWhiteSpace(textValue) == false
				&& !StringUtils.isWhitespace(textValue) && node.hasChildNodes());
	}

	/*
	 * Simple utility to check for attributes on the current element
	 */
	private static boolean hasValidAttributes(Node node) {
		return (node.getAttributes().getLength() > 0);

	}

	/*
	 * Build XPath attribute list for individual XML Element Nodes Iterate
	 * through all attribute nodes and build a string that can be included in an
	 * XPath expression to validate an XML document. Resulting string will look
	 * like: [@attrib1="value1" and @attrib2="value2"] Skip this if the
	 * attribute list is empty.
	 */

	private static String buildAttribString(Node node, String pathExpr) {
		NamedNodeMap nnlist = node.getAttributes();
		pathExpr = pathExpr + "[";

		int attribCount = 0;
		// iterate over attributes
		for (int i = 0; i < nnlist.getLength(); i++) {
			// grab attribute name and value
			String attribName = nnlist.item(i).getNodeName();
			String attribValue = nnlist.item(i).getNodeValue();

			// if we've already added attributes to the path expression append
			// the current one
			if (attribCount > 0) {
				pathExpr = pathExpr + " and ";
			}

			pathExpr = pathExpr + "@" + attribName + "=\"" + attribValue + "\"";
			attribCount++;
		}

		pathExpr = pathExpr + "]";

		return pathExpr;
	}

	/*
	 * processNode checks for attributes and text nodes on an xml node and
	 * process them accordingly
	 */
	public static NodeList processNode(Node node) {

		if (hasValidAttributes(node) || hasValidText(node)) {
			String pathExpr = "/" + node.getNodeName();

			// check for attributes
			if (hasValidAttributes(node)) {
				pathExpr = buildAttribString(node, pathExpr);
			}

			// Make a copy of node to preserve it's state
			Node tmpNode = node;

			// Build pathExpr for XPath Expression by working backward through
			// the XML until we hit the document node.
			while (tmpNode.getParentNode() != null
				    && tmpNode.getParentNode().getNodeType() != Node.DOCUMENT_NODE) {

				tmpNode = tmpNode.getParentNode();
				String nodeName = tmpNode.getNodeName();

				if (hasValidAttributes(tmpNode)) {
					String attribString = buildAttribString(tmpNode, nodeName);
					pathExpr = "/" + attribString + pathExpr;
				} else {
					pathExpr = "/" + nodeName + pathExpr;
				}
			}

			if (hasValidText(node)) {

				/*
				 * Build XPath text value expression to verify text values for
				 * node. This is a little tricky because linebreaks, tabs and
				 * spaces included in the XML document are considered text
				 * nodes.
				 */

				// Copy original node to a textNode to preserve state of
				// original node for future operations
				Node textNode = node;

				/*
				 * This check iterates through child nodes of the original node
				 * until it reaches the next element node. As long as the node
				 * is not null, starts with white space and is not an element
				 * node, move on to the next node
				 */
				while (textNode != null
					      && isWhiteSpace(textNode.getTextContent()) == true
					      && StringUtils.isWhitespace(textNode.getTextContent())
					      && textNode.getNodeType() != Node.ELEMENT_NODE) {
					textNode = textNode.getFirstChild();
				}

				/*
				 * If the text content of the current node is not null, doesn't
				 * start with whitespace and has child nodes, we grab the text
				 * and frame it into an XPath text argument. A sample element
				 * and it's resulting text argument:
				 * 
				 * some text here YIELDS
				 * element1[text()="some text here"]
				 * 
				 * NOTE: The check for child nodes prevents us from creating a
				 * blank text argument for self contained elements (example:
				 * )
				 */
				pathExpr = pathExpr + "[text()=\""
			                   + StringUtils.strip(textNode.getTextContent()) + "\"]";

			}

			checkXPath(pathExpr, node);
		}
		// gather children and return
		return node.getChildNodes();
	}

	// This function takes a group of nodes and generates XPath expressions for
	// them until it runs out of nodes
	public static void processNodeList(NodeList nodelist) {
		for (int i = 0; i < nodelist.getLength(); i++) {
			if (nodelist.item(i).getNodeType() == Node.ELEMENT_NODE
			      && (hasValidAttributes(nodelist.item(i)) || hasValidText(nodelist
					   	.item(i)))) {
				processNode(nodelist.item(i));
			}
			processNodeList(nodelist.item(i).getChildNodes());
		}
	}

	// This function takes the cmd line argument and adds to fileList all files
	// in the directory and it's subdirectory
	private static void processDir(File dir) {
		File[] fileArray = dir.listFiles();

		for (int i = 0; i < fileArray.length; i++) {
			if (fileArray[i].isFile()) {
				if (fileArray[i].toString().endsWith(".xml")) {
					fileList.add(fileArray[i]);
				}
			} else if (fileArray[i].isDirectory()) {
				processDir(fileArray[i]);
			}
		}
	}

	// This starts the process of an individual XML file
	private static void processXML(File xmlFile) throws SAXException,
			IOException, ParserConfigurationException, XPathExpressionException {
		try {
			DocumentBuilderFactory factory = DocumentBuilderFactory
					.newInstance();
			factory.setIgnoringComments(true);

			DocumentBuilder parser = factory.newDocumentBuilder();
			Document doc = parser.parse(xmlFile);

			NodeList startlist = doc.getChildNodes();

			processNodeList(startlist);
		} catch (Exception e) {

		}
	}

	/*
	 * Entry point. Pass in the xml file or top level directory of a group of
	 * files to generate XPath expressions for them.
	 */

	public static void main(String[] args) {
		File startDir = new File(args[0]);
		try {
			if (startDir.isFile()) {
				processXML(startDir);
			} else if (startDir.isDirectory()) {
				processDir(startDir);
				for (int i = 0; i < fileList.size(); i++) {
					processXML(fileList.get(i));
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

In Xpath Expressions, XML
Comment (3) Read More...

As you may, but probably don't know, Phurnace got some Phunding. The management team put in countless hours over the last several months and the process was apparently fraught with twists and turns that would give Gordias pause. Thankfully, our fearless leaders didn't share with us each and every bump in the road. Even more thankfully they didn't share with us those moments, of which I'm sure there were a few, when the road disappeared altogether. I'm a lot like Bill Paxton's character in 'Aliens': I talk a good game and will bust my butt until the bitter end, but am real quick to loudly proclaim "Game Over, man!" when things don't go as planned. Knowing too much would give me fits.

When it comes to spending someone else's money, I think a lot of software companies screw up by making financial choices like the Lohans' make parenting decisions. Instead of worrying about their employee's productivity and professional growth, they want their employees to think their job is cool. Instead of laying the groundwork for long term success, they try to compete with the outrageous perks offered by companies like Google. Don't get me wrong. Fully stocked break rooms, expensive chairs, and ping pong tables are nice. And even though I'm as pale as they come and have a history of skin cancer, I love a good beer bash on a party barge just as much as the next guy. But I would not trade quality hardware or capable new co-workers for any of these fleeting perks. Good employees don't join a company for the parties or bottomless soft drinks. They join a company because they believe in it's products, are optimistic about the company's success, or are intrigued by the professional growth it offers them. The ones that get caught up in the perks are usually the first ones to leave when something new comes along or complain when the company hits leaner times and has to cut back on the cool stuff so they can make payroll.

The culture here is based on honesty and openness. So while the nitty-gritty of start-up funding wasn't revealed to us there has been a lot of discussion of the funding process. The chickens were never counted before they hatched, but we sure did make a lot of plans for exactly how we were going to count those chickens and what we were going to buy with our new found...poultry. O.K. I think I've lost control of the hatching chicken metaphor. Anyway, during these discussions on what was to be done with the funding it became clear to me how much different Phurnace is than some of the other start-ups I've worked at. The coolest thing about this company is that everyone here seems to be in agreement with the long-term plan. By opening up discussion of business decisions to all of us, it's easier for us to see, appreciate, and contribute to the company's growth and success. It's also striking that everyone can now rest assured that a dime is not spent without tracing it back to a concrete benefit for the company. We are making quality hires and investing in an infrastructure that will optimize productivity and yield solid deployment solutions that we can not only sell, but also take pride in. And isn't building something new and cool what working at a startup is all about?

In phurnace
Comment (0) Read More...

Even though it’s been available for a few months, I only recently had time to check out the latest and greatest free virtualization offering from VMWare. I haven’t run it through the wringer completely, but from what I’ve seen there are several new features and improvements that will definitely hasten the upgrade process in our test environment once it clears Beta. Here’s what I like so far:

• A vastly better web console. The console obviously came under some major scrutiny. The 1.0 version wasn’t unusable, but it wasn’t as feature rich and intuitive as the 2.0 console. Everything you need to manage your virtual machines is easily accessible in a clean web app.
• More detailed event reporting. This helps you keep track of changes made to your virtual machines. It also helps you find who started, stopped, or reverted your virtual machines. So now instead of cursing the Void when a VM is reverted out from under you and you lose weeks of unsaved test data, you can find the culprit and break their coffee cup or mess with their chair settings late at night when no one else is around.
• If you are not a late night saboteur and would rather avoid the situation altogether, virtual machine permissions are a lot easier to manage in this release.
• Instead of assigning a single ‘Default Virtual Machine Location’ as you do in 1.0, you organize your virtual machines in one or more datastores. You can then set access permissions on your datastore to keep others from interfering with your diabolical machinations…or software development.
• Virtual Machine memory allocation ceiling has more than doubled. 1.0 capped per virtual machine memory allocation at less than 4 GB. 2.0 bumps this up to 8 GB as long as you have the memory to spare. This is a very big deal for anyone that plans on running multiple virtual machines hosting WebSphere Portal.
• Updates to the VIX API. 2.0 includes support for an updated API (VIX 1.5) with some exciting new features. I am most anxious to get my hands on the Record and Playback features.

The only thing that I hoped was going to be available in 2.0 was support for multiple snapshots per virtual machine. This would make it a lot easier to switch between WebSphere and WebLogic patch levels when tracking down configuration bugs. All in all, I’m very pleased and excited about digging deeper.

In Vmware Server 2.0, Virtualization
Comment (0) Read More...

I dream of buying a dilapidated shack in Middle-Of-Nowhere, Texas. All this shack needs is a small kitchen, a BBQ Pit, a sturdy lawn chair, and a butcher’s block. I would spend the wee hours of the morning prepping brisket after brisket, chicken after chicken, coercing a steady fire into life. When the time was right, the meat would hit the pit, I would plant myself in the lawn chair, and wait. The remainder of my workday would be spent checking the heat, tending to my meaty charges, and whipping up the occasional batch of sauce. I’d close up shop at 2:00 PM or when the meat sells out, whichever comes first.

Unfortunately, this is just a dream and it doesn’t show any signs of turning into a reality any time soon. Until that happens, I have to take solace in the occasional opportunity to cook for friends and family. Phurnace had such an occasion yesterday and I jumped at the chance to spend a day fighting the smoky beast instead of testing software.

 

HOW I COOK A BRISKET:

The Rub:

• 1 cup Paprika
• ¼ cup Kosher or Fine Sea Salt
• ¼ cup Fresh Ground Pepper
• 1 tbsp Granulated Garlic
• 1 tsp Cayenne Pepper

Prepping the meat:
An untrimmed brisket is pretty fatty. I usually trim the fat down to a thickness of about ¼ inch wherever I can. Once it’s trimmed, I’ll flip it over and score the top of the brisket perpendicular to the grain. This kind of gives me a guide for cutting the brisket after it’s done. After it’s trimmed comes the seasoning. I usually coat the entire brisket with a thin layer of mustard. This gives the crust that develops during cooking a little tang and crunch and helps the rub adhere to the brisket. Sprinkle the rub liberally over all surfaces but don’t feel like you need to cram it in every little nook and cranny.

Cooking the meat:
I won’t get into how you build and maintain an indirect fire here because it differs from cooker to cooker. The most important thing to remember is you want to maintain as steady a temperature as possible. I usually shoot for a temperature of 240. Put the brisket on your cooker and add some wood chunks to the fire. I usually use oak and/or apple wood chunks. Check the fire once an hour. Add more charcoal and wood chunks as needed.

Typically the brisket will take about 1.5 hours per pound to cook at this temperature. About halfway through cooking time, I start rotating my brisket every 2 or 3 hours and basting it every hour on the hour. The baste I use is pretty simple and will make your heart explode if you drink it straight. It’s 2 cups of beef broth, a stick of butter, ¼ cup of Worcestershire, ¼ cup of lemon juice, and a couple tablespoons of leftover rub.

When’s it done? Whenever the internal temperature reaches about 160 or you can pierce it with a fork easily and it pulls out with little to no resistance. Let it sit for about a half hour and then slice it, using the score marks you made during prep time as a guide. Slicing against the grain yields the most tender results.

In Brisket, BBQ
Comment (0) Read More...

In my last post I talked about how virtualization changed test lab creation and management. I’m sure the first thing you did after reading the post was download your very own copy of VMWare Server and replace all your hardware with super flexible virtual machines. You’re now basking in the glow of your long term cost savings, marveling at how easy your lab is to maintain, and using some of that extra time and money to bid on my exclusive line of “VMWare Saved My Marriage” T-Shirts available only at my eBay store.

Eventually your boss will notice you’re no longer cursing under your breath and slamming the door to the lab. It’s inescapable. And when the boss man gets wind of spare cycles, he starts thinking crazy thoughts. He starts thinking you now have time for that automation project that’s been on the back burner since 1996. With a heavy sigh and a final farewell to what will inevitably be known as “The period in my life that was great, thanks to Pete Pickerill,” you turn your attention to how you’re going to build a flexible automation framework that runs just as well on your Unix & Linux systems as it does on your Windows systems.

Have I got an open-source project for you! Software Test Automation Framework (STAF) takes care of all the nagging little odds and ends that have very little to do with testing your software. STAF employs a series of pluggable modules (called ‘Services’). Standard services cover most of what you’ll need: file system operations, environment variable management, process execution, logging, and miscellaneous commands like ‘ping’ and ‘zip.’

The command above may seem a little cryptic, but when you break it down into steps it starts to make sense. In the example above:

• STAF is executed on Server1: STAF Server1
• The Filesystem Service (FS) is invoked to copy the file myFile.exe: FS COPY FILE myFile.exe
• The target directory is given: TODIRECTORY /your/dir/here
• The target machine is given: TOMACHINE System2

That’s STAF in a nutshell. You execute the STAF command locally or remotely, you specify the service you want to use, what you want to execute within that service, and provide the necessary variables to complete the task.

Now you may be thinking, “But, Pete! What if the copy fails due to disk space limitations or network interruptions? What if System2 didn’t boot to a usable state? What if it just up and fails for no discernible reason at all?” There, there buddy! It’s alright! STAF gives you very descriptive return codes. What’s more, these can either be returned to STDOUT if you’re using the cli or a scripting interface or as Java Objects if you’re using STAF in a Java class.

Other cool things about STAF:

• Accessible: Java, Perl, Python, Tcl APIS and an Ant task make it very easy to fold STAF into your automation. There’s also an Eclipse plug-in I haven’t had a chance to check out.
• Extensible: Write your own services in Java, C, or C++ to handle testing peculiarities specific to your software.
• Documentation: STAF is managed by IBM and the documentation is the best I’ve ever come across in the Open Source realm. STAF DOCS
• Active Community: STAF is frequently updated and new features and integrations are added all the time. There’s also loads of info in the mailing list. STAF MAILING LISTS & DISCUSSION FORUM

For more examples and info, check out the STAF website, Agile Testing Blog & Performance Wiki.

In Tips, STAF, Software Test Automation Framework, Open Source, agile testing
Comment (0) Read More...

Why buy the cow? Open Source QA Tools can provide a sturdy test and automation framework.

I’ve spent the bulk of my career in QA at startups so I’m not accustomed to operating with an abundance of resources. As such, I’ve researched a ton of free and open source testing tools in the hopes of automating or streamlining the test process to compensate for a lack of manpower. I’ve decided to use my blog posts to detail some of the tools that I have found useful over the years.

At my last job, we built our test lab by cruising Goodwill stores in search of donated systems capable of running Windows 98, NT or 2K with a minimum of upgrades. While our experiences in creating this “Franken-lab” made for a few good stories, we often spent more time dealing with hardware outages and the quirky behavior common in donated technology than we did testing. At the time disk space, memory, and powerful processors were expensive. Even if we were to buy mid-range systems we’d have quickly exhausted our budget. Without enough hardware to cover all of our supported platforms, we’d have had to rely on disk imaging, a process that includes a lot of downtime while one system configuration is being blown away and another written to disk.

VMWare has changed all of this. At Phurnace, my test lab consists of one system with 8GB of RAM, 2 quad-core processors, and a terabyte of disk space. I can run up to about 10 Virtual Machines concurrently so I can use one as my client test platform, use several more to create clustered WebSphere or WebLogic environments to test against, and have a few virtual machines to spare for developers to troubleshoot defects or test code before checking it in.

Benefits of the Virtualized Test Lab:

• Installation of VMWare Server and Virtual Machine creation couldn’t be easier.
• Quickly shift gears. If I get blocked while testing one platform, I can power down those servers and bring up another set of server images in a few minutes without leaving my chair.
• Snapshots! VMWare also allows me to start from a known good base state every time I power on a virtual machine so I know that ‘pollution’ on my test bed will be minimal.
• A basic CLI that allows you to start and stop VMWare images remotely. This has been very handy for test automation
• A library of virtual appliances, some offered for free, that provide pre-installed and configured enterprise applications. I have just started investigating some of these to manage the virtual network my virtual machines are connected too.
• Lots of available help is just a good Googlin’ away. VMWare is very widely used.
• Free! Gratis! On the house! VMWare Server is a free offering that is intended to familiarize users with virtualization. While they have several support subscriptions and product upgrades available at a price, this free offering has more than met our needs.

So check it out here . I recommend it highly.

In Virtualization
Comment (0) Read More...