jonr originally posted this on Jon Rose's Blog.

I thought I would post a holiday treat.  I’ve been hard at work on “FlexMonkey Reloaded.”  It should be out there for use soon.  Here is a screen shot:

jonr originally posted this on FlexMonkey :: Flex UI Testing Tool.

• Added new Sub-Property Verification feature (http://www.gorillalogic.com/books/flexmonkey-docs/sub-property-verification)
• Added retry to VerifyGrid
• Addressed code-gen issues with retry
• Major refactor to all commands to clean-up the code and make them more robust
• Cleaned up command runner and added additional error handling to provide the user with better feedback while playing test through the console

jonr originally posted this on FlexMonkey :: Flex UI Testing Tool.

We’ve released an updated version of FlexMonkey (4.1.1) that now supports multi-windows in Adobe AIR.  The new multi-window support only works with Flex 4 applications, as the underlying automation manager support for this is only available in the new version of the SDK.  The version also includes a handful of minor bug fixes and a nice new roll-over popup that provides you with automation / component details when recording a verify.

Make sure to update both the SWC library and the AIR Console.  You can access the latest software at: http://www.gorillalogic.com/flexmonkey

To take advantage of the Adobe AIR multi-window support you will need to include additional automation SWCs in your compiler arguments:

-include-libraries “../libs/automation_monkey4.x.swc” “${flexlib}/libs/automation/automation_air.swc”"${flexlib}/libs/automation/automation_airspark.swc”

As always, you can use the Setup Guide under the Project > Properties window to update both your FlexMonkey SWC file and get the latest compiler arguments.

jonr originally posted this on FlexMonkey :: Flex UI Testing Tool.

FlexMonkey is a very useful tool for Flex developers, as it makes testing much easier, yet FlexMonkey is also a real-world Flex application itself.  This post aims to provide a high level overview of the FlexMonkey architecture, so you can begin to understand how it works – it is a summary of a recent doc published by Stu Stern, the FlexMonkey project founder.

It is not essential for users to fully understand the ins-and-outs of FlexMonkey to be able to use it for testing.  However, understanding how it works is a great way to learn more about the Flex platform and have a leg up on solving any issues you might encounter working with the tool.  A deep understanding of the architecture will also make it much easier to record and playback tests on custom components.

FlexMonkey utilizes the Flex automation framework provided by Adobe to enable visibility into the application being tested.

Automation Framework

The automation framework is a Flex / AIR component level API provided by Adobe that assists tools like FlexMonkey in providing record and playback functionality with visual components (i.e. classes that extend from UIComponent, as all the Flex SDK visual components do).

• Access to the Automation Framework: Adobe packages the automation framework with Flash Builder Pro.  They do distribute the SWC archives and delegate source outside of Flash Builder, but without a Flash Builder license the AutomationManager limits the number of record and playback events that can be done in a single session.
• Delegate Classes: The automation framework instruments components through delegate classes.  These classes use [Mixin] metadata that causes them to be statically initialized at the startup of the application.  They have the component specific logic to accomplish record and playback.
• Automation Children Methods: The automation framework uses three key methods to crawl the application component tree: getAutomationChildern(), getAutomationChildAt(index:int), and numAutomationChildren(). These methods can be implemented directly on the component classes (e.g. DataGrid, Label, and any other classes that extend UIComponent) or in the delegates.

FlexMonkey

FlexMonkey gives you the tools to create powerful tests.  Here are the major pieces of FlexMonkey:

• Console: The main part of FlexMonkey users interact with is the Adobe AIR console.  It is used to record and edit tests.  Developers and QA professionals can also use the console to run tests on their local machine.
• MonkeyLink: MonkeyLink is compiled into the application being tested.  It communicates with the AIR console and FlexMonkey Ant task to create and run tests.
• Commands: In record mode FlexMonkey creates commands that are used to do the playback of the recorded user interactions. The latest release supports “retry” for more consistent results when running tests.
• Verification: As with any testing framework, assertions of a certain state are the ultimate goal.   FlexMonkey provides verification of property values, bitmaps on the screen, or DataGrid values.
• Continuous Integration: The FlexMonkey project includes support for automating tests within a Continuous Integration environment.  FlexMonkey can generate ActionScript versions of the test from the AIR console.  It also provides Ant tasks for running them.  There are example projects for Flex and AIR Continuous Integration configurations on the FlexMonkey download page.
• Environment File: MonkeyLink packages a FlexMonkeyEnv.xml file that describes the component tree to the automation framework.  The standard file works for all of the standard custom Flex components.  If you need to automate custom components, then this file may need to be modified.

The dependencies for FlexMonkey can be included in an application using the “-include-libraries” Flex compile directives.  These dependencies should only be included in developer and QA builds – never in a production release of the application being tested.

Hopefully, you now have a general understanding of how FlexMonkey works.  If you’d like more introductory on FlexMonkey check out the GorillaLogic.com website.

jonr originally posted this on FlexMonkey :: Flex UI Testing Tool.

Gorilla Logic is excited to announce that we’ve released FlexMonkey 4.1.  FlexMonkey is used for testing Flex and AIR based applications, providing functionality to record, playback, and verify Flex UI interactions.

In this release we’ve aimed to make everything easier for FlexMonkey users.  We’ve simplified the setup process, made test playback more robust, added better debugging tools to the user interface, and made the FlexMonkey code easier to access and work with.  In addition, we’ve improved our Flex 4 support and added full continuous integration support for Adobe AIR.

FlexMonkey 4.1 Highlights

• Feature Updates:
  • More Robust: With a number of internal code updates, we’ve made it easier for you to create robust tests that do not require ‘pauses’ and other additional steps to consistently run successfully.  Thus, removing any dependency on application performance across machines.
  • Retry on Command: Last year, we added the option to ‘retry’ when verifying values, where the user can set an interval and number of attempts to check for the proper value.  This was a key addition that enabled FlexMonkey users to better deal with the asynchronous nature of Flex.  We’ve now expanded this functionality to also be the default option on FlexMonkey commands.
  • Verify Grid Command: We’ve added a command to make it easy to verify values on Flex 3/ Halo DataGrids.  In the past, it required a bit of ‘trickery’ to test DataGrid values with FlexMonkey.  Now, DataGrid values can easily be checked with the new Verify Grid option in the FlexMonkey console.
  • Flex 4 Scroller: FlexMonkey relies on the Flex automation framework provided by Adobe, which includes ‘delegate’ classes for the standard SDK components that make them ‘testable.’ Unfortunately, there is not currently a working delegate for the Flex 4 Scroller component.  So, we’ve included our own in this release so that Flex 4 code that includes Scrollers can now be tested.
  • Automation Tree Viewer: The FlexMonkey console will now allow you to view the tree of components in your application, as the automation library sees them.  This is a key new feature in helping you debug record and playback issues.
  • Environment File Viewer: Modifying the environment file is required to automate custom Flex components for testing.  The environment file viewer allows you to quickly and easily see what version of the file is being used when testing your application.
  • Log File viewer: We’ve added a log file window to allow you to effortlessly see log output from the FlexMonkey console.
• Source Code Tree Clean-up: We’ve greatly simplified the project structure making it easy for any Flex/AIR developer to build and work with the FlexMonkey code.  This was a priority to us for a few important reasons: 1) We wanted the community to be able to easily contribute their own enhancements to FlexMonkey. 2) Having quick access to the code makes it less painful to debug issues when they are encountered.
• AIR Support: We’ve dramatically improved our support for testing Adobe AIR applications.  We now provide a full sample test project for Adobe AIR that demonstrates a working continuous integration example for Mac OSX and Windows.
• Continuous Integration: In addition to the continuous integration updates for AIR applications, we’ve improved our Flex CI support for Linux and Mac OSX and updated the sample project to show you how to use the latest.
• Simplified Configuration: We’ve simplified the setup process to start using FlexMonkey by removing unneeded options, like the SWF Target window, which could only test a very small subset of simple Flex applications.  In addition, we’ve included a configuration / setup guide directly in the application to interactively walk users through setting up their applications for testing with FlexMonkey.
• Documentation Updates: We’ve made a full pass at improving the FlexMonkey documentation, including providing a comprehensive guide on how FlexMonkey works.

You can find the FlexMonkey project at: http://www.gorillalogic.com/flexmonkey/

FlexMonkey is built and open-sourced by Gorilla Logic, Inc.

admin originally posted this on Saturnboy.

The AIR Install Badge is a very handy little flash application for delivering AIR applications to your users via the web. The badge allows your users to download and install both your application and the Adobe AIR runtime. Additionally, the install badge will automatically prompt users to upgrade if a previously installed version is detected. At Gorilla Logic, we use the AIR Install Badge on the FlexMonkey download page (free registration required).

Alas, flash is opaque to analytics. We have no idea what our users are doing inside the AIR Install Badge application. Are they installing? Or upgrading? No problem, we just need to write some code…

The Code

Using flash’s ExternalInterface, we can manually push the data out of flash and into javascript. Once we have the data in javascript, we have total control. One option is to use google analytics to store our badge data. In the case of FlexMonkey, we send the badge data along with the user’s credentials to our CRM platform, SalesForce.com.

Step 1: First, open AIRInstallBadge.as and add this to the top:

import flash.external.ExternalInterface;

Step 2: Next, add the ExternalInterface call to the top of the handleActinClick() function in AIRInstallBadge.as:

protected function handleActionClick(evt:MouseEvent):void {
    if (action == 'install' || action == 'upgrade') {
        //send data to js
        ExternalInterface.call('badgeJS',action);
    }
    ...
}

Since I only care about the install or upgrade actions, I’ll only send those out to javascript. Re-compile the badge and deploy.

Step 3: Last, add the badgeJS() javascript callback to the page containing the badge and do whatever you want with the incoming badge data:

function badgeJS(action) {
    //do metrics here...
    alert('badge action=' + action);
}

Conclusion

With an hour of effort, and a very small amount of code, we’ve managed to get the useful metrics of installs and upgrades out of the AIR Install Badge and into our analytics engine of choice. A job well done.

jonr originally posted this on FlexMonkey :: Flex UI Testing Tool.

Latest Version of Open-Source Testing Tool for Flex Applications Delivers Full Flex 4.0 Spark Component Support

Broomfield, CO – May 11th, 2010 – Gorilla Logic, an enterprise IT consulting services firm known for its top consulting talent, today announced the availability of FlexMonkeyTM 4.0 Beta 1. The new version provides support for the latest Flex 4 release from Adobe, including the entire Spark component set. With over 6,200 registered users, FlexMonkey has become the industry standard for automated record and playback testing of Adobe Flex interfaces used by companies around the world.

“The FlexMonkey 4.0 Beta 1 release delivers what our users have been asking for: support for Flex 4 including all Spark components. This lets FlexMonkey continue to answer to the Flex community’s need for quality assurance and unit testing for Flex applications,” said Eric Owens, FlexMonkey Guru, Gorilla Logic.

As a leading consulting services firm specializing in enterprise application development using Adobe Flex, HTML5, Java and mobile application development, Gorilla Logic developed FlexMonkey to deliver unparalleled quality to their Fortune 500 clients. In addition to providing a forum for the community of FlexMonkey users to assist each other (FlexMonkey Forum), Gorilla Logic also provides annual support contracts, implementation services and custom enhancement development for clients interested in optimizing their implementation of FlexMonkey.

“We use a continuous integration environment and are deploying FlexMonkey on the desktops of nearly 150 developers. For us, FlexMonkey is an option that cannot be ignored because it was obviously developed with one goal in mind – to facilitate the creation of high-quality Flex applications,” said Josse Brayelle, MAAF Assurances.

FlexMonkey is well suited for use by both developers and QA testers. It provides for regression and functional testing, and can be run from popular build systems and continuous integration environments, like CruiseControl. Gorilla Logic has assisted several companies in setting up their continuous integration environments and ensuring a production quality implementation of FlexMonkey.

In response to FlexMonkey’s value and ease-of use, Jokichi Oguri from HP commented, “The work you guys have done is incredible. May Gorillas rule the earth some day!”

FlexMonkey 4.0 Beta 1 is available today at www.gorillalogic.com/flexmonkey. Gorilla Logic also offers complete FlexMonkey training, implementation and off-shore testing services.

About Gorilla Logic

Gorilla Logic is an enterprise application development services and consulting firm known industry-wide for providing “gorilla” consultants that can dramatically improve development team productivity. Gorilla Logic has long demonstrated their industry-leading expertise in enterprise Java / JEE development, Adobe Flex / RIA development, and mobile device
application development, including the iPhone, Android and Blackberry. Gorilla Logic has been engaged to ensure the success of their most mission critical projects by Fortune 500 companies as well as small and medium-sized businesses and startups in industries ranging from financial services to entertainment to aerospace and the government sector.

Gorilla Logic also develops open source tools for Java, Flex, and iPhone developers.

• FoneMonkey (www.gorillalogic.com/fonemonkey)
• FlexMonkey (www.gorillalogic.com/flexmonkey)
• MonkeyWrench (www.gorillalogic.com/monkeywrench)
• OpenGXE (www.gorillalogic.com/opengxe)

For more information about Gorilla Logic, please visit www.gorillalogic.com or email info@gorillalogic.com.

Gorilla Logic Media Contact
Chad Sanderson
303.974.7088 ext. 7002
chad.sanderson@gorillalogic.com

admin originally posted this on Saturnboy.

When we launched the new and improved Gorilla Logic website, we decided to bring all our open source projects together under one roof. In order to migrate all things FlexMonkey back to our website, we need to get our forum data migrated out of Google Groups. Alas, Google doesn’t provide any way to export data from Google Groups. The only way to preserve the amazing contributions from the FlexMonkey community was to scrape Google Groups. So that’s just what we did.

With a very minimal amount of PHP, I was able to walk the entire FlexMonkey Google Group, scrap all the topics (aka threads) and all the posts inside each thread. The first step was to build a generic scraper class that grabs an html page (using cURL) and parses out all unique outbound links.

Here’s the code for the Scraper class:

class Scraper {
    private $url = '';
    public $html = '';
    public $links = array();
 
    public function __construct($url) {
        $this->url = $url;
    }
 
    public function run() {
        $this->html = '';
        $this->links = array();
 
        //scrape url & store html
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $this->url);
        curl_setopt($ch, CURLOPT_HEADER, 0);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        $this->html = curl_exec($ch);
        curl_close($ch);
 
         //parse html for all links
        $matches = array();
        preg_match_all('#<a.*?href\s*=\s*"(.*?)".*?>(.*?)</a>#i', $this->html, $matches);
 
        if ($matches !== false && count($matches) == 3) {
            for ($i = 0; $i < count($matches[1]); $i++) {
                $href = $matches[1][$i];
                $val = $matches[2][$i];
 
                //unique links
                if (!array_key_exists($href, $this->links)) {
                    $this->links[$href] = $val;
                }
            }
        }
    }
}

In the run() method, cURL is used to grab the html. Next, a regular expression is used to match all outbound links. The links are are stored in a hash, while making sure they point to unique urls.

Built on top of the generic Scraper class is a specialized Google Groups scraper class, aptly named GoogleGroupsScraper. For a given Google Group, the url of the main page (containing a list of most recent topics) is:

http://groups.google.com/group/[GROUP]/topics

And the url of a single topic (aka thread) is:

http://groups.google.com/group/[GROUP]/browse_thread/thread/[THEAD_ID]#

Where [GROUP] is the name of the Google Group, and [THREAD_ID] is some alphanumeric id. Most importantly, at the bottom of the main page is an Older » link that points to the next page of topics. The GoogleGroupsScraper exploits this to spider the entire group, recording topic title and topic url as it walks each page.

Next, each individual topic page is scraped by the GoogleGroupsTopicScraper class and parsed into a list of posts with author name, date, timestamp, etc. The topic scraper uses various regular expressions to extract and massage the html to extract the different parts of each post. In particular, the post body needs a lots of work to strip out any Google Groups specific links and code.

Lastly, the topics and their posts are assembled into an XML document with a nice big CDATA block around the post body to preserve the html content.

Here’s some sample output from the scraper:

<?xml version="1.0" encoding="UTF-8"?>
<scrape group="flexmonkey">
  <topic>
    <title>FlexMonkey User Group is now located at www.gorillalogic.com/flexmonkey!</title>
    <link>http://groups.google.com/group/flexmonkey/browse_thread/thread/fe9ed66bf56db88e#</link>
    <posts>
      <post idx="0">
        <author>Stu</author>
        <email>stu.st...@gorillalogic.com</email>
        <date>February 10, 2010 21:17:52 UTC</date>
        <timestamp>1265836672</timestamp>
        <body>
<![CDATA[
<p>People of FlexMonkey, <p>We have migrated the FlexMonkey discussion forum to <a href="http://www.gorillalogic.com/flexmonkey">http://www.gorillalogic.com/flexmonkey</a>. Please note that you will need to re-subscribe to the new forum to continue receiving FlexMonkey discussion messages. <p>-Stu <br>
]]>
        </body>
      </post>
    </posts>
  </topic>
  <topic>
    <title>Record button clicks based on Ids instead of names?</title>
    <link>http://groups.google.com/group/flexmonkey/browse_thread/thread/4f079b1959374f53#</link>
    <posts>
      <post idx="0">
        <author>Shilpa</author>
        <email>shilpa.g...@gmail.com</email>
        <date>February 9, 2010 23:44:44 UTC</date>
        <timestamp>1265759084</timestamp>
        <body>...</body>
      </post>
      <post idx="1">
        <author>Shilpa</author>
        <email>shilpa.g...@gmail.com</email>
        <date>February 10, 2010 00:05:44 UTC</date>
        <timestamp>1265760344</timestamp>
        <body>...</body>
      </post>
      <post idx="2">
        <author>Gokuldas K Pillai</author>
        <email>gokul...@gmail.com</email>
        <date>February 10, 2010 00:16:34 UTC</date>
        <timestamp>1265760994</timestamp>
        <body>...</body>
      </post>
      <post idx="3">
        <author>Shilpa</author>
        <email>shilpa.g...@gmail.com</email>
        <date>February 10, 2010 01:18:42 UTC</date>
        <timestamp>1265764722</timestamp>
        <body>...</body>
      </post>
...

Finally, there is a very simple PHP driver for the scraper that runs the scraping process:

require_once('GoogleGroupsScraper.class.php');
 
$scraper = new GoogleGroupsScraper('[GROUP]');
$scraper->run();
 
print $scraper->getXML();

And you run it as usual:

php scrape.php > output.xml

Just enter the name of the Google Group you wish to scrap, and away you go. Here are a couple of notes to help you along:

1. [GROUP] is the group name as it appears in the url, so no spaces, etc.
2. It’s not fast, so be patient, or modify the scraper code to generate some intermediate output.
3. Via a browser, Google Group displays 30 topics per page, but via PHP & cURL you only get 10. Probably some Cookie or User Agent magic going on.
4. Not much error handling. The error handling that exists isn’t very good. It will break.
5. Good luck!

Please download the code and use it however you wish. Hopefully, putting the code online and writing this post will save someone else some time when migrating data off Google Groups.

Files

• GoogleGroupsScraper.tgz

jonr originally posted this on FlexMonkey :: Flex UI Testing Tool.

Open-Source Functional Testing Tool for Adobe Flex Applications – New and Improved!

Broomfield, CO – March 3rd, 2010 – Gorilla Logic, an enterprise IT consulting services firm known for its top consulting talent, today announced the availability of FlexMonkeyTM 1.0 GA. With a rapidly growing user base that recently surpassed 5,000 registered users, FlexMonkey is a de facto standard for automated functional testing of Flex applications. After eight months of maturing in a beta status, FlexMonkey is now available for production use by developers and quality assurance professionals everywhere.

“FlexMonkey has been invaluable for us in testing Adobe Air applications. It has found bugs and regressions on several occasions, preventing them from ever reaching customers. And…I had everything I needed to add FlexMonkey tests into our continuous integration environment,” said Michael Portuesi, Principal Engineer, Zoodles.com.

FlexMonkey is an open source testing tool providing record/playback functional testing of
Adobe Flex applications. FlexMonkey 1.0 GA delivers the features and improvements most
requested by the FlexMonkey user community including:

• “Wait For” handling – removes reliance on the PauseCommand by defining conditions that pause a script until true
• Fuzzy Bitmap Compare – the Verify command for bitmap images now allows for user controlled tolerances in color comparisons
• Simplified Setup – new easier process for configuring FlexMonkey testing of an application
• Compatibility – out of the box compatibility with multiple Flex SDKs (3.3, 3.4.1 and
  3.5)
• Code Compiling – easier customization and compilation of FlexMonkey source

“FlexMonkey keeps me from becoming exactly that – a monkey chained to a desk manually testing our software,” said Max Cameron, Co-Founder, Big Bang Technology, Inc. “Simply put, FlexMonkey kicks ass. It softens the enormous overhead of functional testing, and more importantly, it let’s my engineers get some sleep at night.”

FlexMonkey is well-suited for use by both developers and QA testers. It provides for regression and functional testing, and can be run from popular build systems and continuous integration environments, like CruiseControl.

“FlexMonkey 1.0 GA marks a major milestone for the FlexMonkey open source project and the Flex community who have come to rely on it. We encourage all existing users to upgrade to this new version which paves the way for our upcoming FlexMonkey releases for Flex 4, as well as our FlexMonkey/Selenium bridge,” said Stu Stern, CEO, Gorilla Logic.

FlexMonkey 1.0 GA is available today at www.gorillalogic.com/flexmonkey. Gorilla Logic also offers complete FlexMonkey training and testing services. Customers interested in early access to FlexMonkey for the Flex 4 SDK and the FlexMonkey/Selenium bridge should contact Gorilla Logic at www.gorillalogic.com/who-we-are/contact.

About Gorilla Logic

Gorilla Logic is an enterprise application development services and consulting firm known industry-wide for providing “gorilla” consultants that can dramatically improve development team productivity. Gorilla Logic has long demonstrated their industry-leading expertise in enterprise Java / JEE development, Adobe Flex / RIA development, and mobile device application development, including the iPhone. Gorilla Logic has been engaged to ensure the success of their most mission critical projects by Fortune 500 companies as well as small and mediums-zed businesses and startups in industries ranging from financial services to entertainment to aerospace and the government sector.

Gorilla Logic also develops open source tools for Java, Flex, and iPhone developers.
FoneMonkey (www.gorillalogic.com/fonemonkey)
FlexMonkey (www.gorillalogic.com/flexmonkey)
MonkeyWrench (www.gorillalogic.com/monkeywrench)
OpenGXE (www.gorillalogic.com/opengxe)

For more information about Gorilla Logic, please visit www.gorillalogic.com or email info@gorillalogic.com.

###

Gorilla Logic Media Contact
Chad Sanderson
303.974.7088 ext. 7002
chad.sanderson@gorillalogic.com

jonr originally posted this on FlexMonkey :: Flex UI Testing Tool.

What is FlexMonkey?

FlexMonkey is an open source Adobe AIR application used for testing Flex and AIR applications. It provides the functionality to record, playback, and verify Flex UI interactions. It also generates ActionScript / fluint tests that you can easily include within a continuous integration environment.

Who is FlexMonkey for?

Like many in the Flex community, we came to Flex development after many years of developing traditional web applications, where there are multiple tools that allow a developer to simulate a UI client for testing (like HTMLUnit). For testing our Flex user interfaces, we had a strong desire to continue using this paradigm for our developer level testing.

As software consultants, ensuring quality is an important part of what we do. So, we created FlexMonkey to fill the gap between a unit test and what’s really needed to ensure quality (and protect against regression) when developing user interfaces. While we initially created FlexMonkey for developers, many in the FlexMonkey community have found it just as valuable for use in creating QA / Functional tests.

So, we believe that FlexMonkey is useful to both software developers and quality control engineers on Flex development projects.

So, what’s so game changing about it?

If you ask Mike Labriola (one of the Fluint/FlexUnit 4 guys), ‘How do I unit test my Flex user interfaces?’ He will quickly respond, ‘You don’t.’ He won’t tell you this because he doesn’t believe in unit testing (as I can assure you that he strongly believes in Unit Testing), but because there are parts of a user interface that cannot be sufficiently tested with unit tests.

So, as we jump into the reasons why FlexMonkey matters for you, I’ll note that we do not believe that FlexMonkey replaces the need for traditional unit tests. There are still parts of a Flex application that are best tested this way (e.g. service clients, business logic, etc.). If you are building a framework, it’s likely that the majority of your testing will be done through unit tests, but if you are focusing on features and functionality you will likely be able to achieve upwards of 80% of your testing goals with FlexMonkey. Nevertheless, here are the high level places where FlexMonkey changes the game:

1. FlexMonkey fills the gap left between unit testing and a truly successful test suite, as it provides a tool for doing developer level functional tests that replace traditional unit testing activities that developers perform in other tiers of application development.
2. FlexMonkey allows developers to write their user interface code in the most natural way. Typically, when developing a user interface application without a tool to simulate a client of the running application, the code has to be written differently to support testing. This often leads to many unnatural acts, which can be avoided when using FlexMonkey.

   For the Java folks, I like to bring up the SpringFramework here, as it provides us with a powerful example of a framework that largely succeeded because it allows developers to write their code in a natural way. Over the long run, the frameworks and tools that make it possible for developers to work in the most natural way will always win out.

   Tools like FlexMonkey are able to facilitate this simply through the paradigm they provide for testing user interfaces, as they allow developers to test applications without any knowledge of the underlying code.

3. Cost. FlexMonkey is free. So, even though it’s not a perfect tool, it does enable one to build and deploy a successful test suite, a task that is extremely difficult and costly in Flex development without FlexMonkey.

You can find the FlexMonkey project at: http://flexmonkey.gorillalogic.com/

FlexMonkey is built and open-sourced by Gorilla Logic, Inc.