The team has been hard at work and the friuts of those are here as a present for you in the form of FlexUnit 4.1 Release Candidate 2. We really hope that this will be our final release candidate before we go gold in early 2011!

Without further ado, head on over to the downloads section and grab a copy!

Catch the change list after the jump.

It took us a little longer to get this one out the door than we wanted ( we do have lives you know) but also there is quite a list of updates and bug fixes

1. FIrst pass to update build to produce Sonatype bundles.  Integration with core still outstanding.
2. Removed extraneous version.properties file.
3. Updated build for core to produce both as3 and flex artifacts as well as test project to test both.  Updated dependent projects to use as3 version of core only.
4. Updated to use the 0.90 SWC
5. Updated main build script to ommit flex/as3 section in final name since it’s no longer a concern.
6. Fixed error being thrown by FlexCoverListener by linking CoverageAgent into listener.  Still no luck on closing the CoverageViewer.
7. Fixed error being thrown by FlexCoverListener by linking CoverageAgent into listener.  Still no luck on closing the CoverageViewer.
8. Updated main build to provide a hook to bundle sonatype artifacts into a zip for easier distribution.
9. Updated glob for core libraries to be included in standard distribution zip.
10. Update version # as to not confuse Nexus for bundle uploads.
11. Fixed case insensitive dataProvider and order issue.
12. Fix for issue where IExternalDependencyData interface could not be properly used with Theories
13. Additional fix to possible condition created when a top level error occurs
14. Addition of new method to mock for implementation of interface
15. Added uncaught error handling to all runners
16. Fixed bug where instances of IExternalDependencyData were evaluated twice. Also fixed crashing bug in FlexUnitCore due to scope conflict
17. Added theory for external dependency data
18. Added metadata improvements to 4.1
19. Updated Theory
20. Updated build file to include new metadata files
21. Added metadata code hints into the build file
22. More helpful error messages when parameterized test initialization fails.
23. Updates for FlexMonkey
24. Fix for build issue around unknown error
25. Fixes for runtime filtering issues with parameterized tests that load external data
26. Fixed errant trace, comment and extra var in suite
27. removing old files from turnkey
28. Updated turnkey to work with the latest libraries
29. fixing libraries for turnkey

So grab the new bits in the downloads section and give them a run for their money. We wanna make sure this build is ready to go out to the masses.

Thanks, and See you again in the New Year!

Go to the Downloads section to grab the new FlexUnit 4.1 RC1 code!

Right now the FlexUnit team is quite small and 120% of our time is occupied with development and user support. Unfortunately this means that the best engineered plans for good documentation seem to get farther behind as the days go on.

We are looking for a few people who would be willing to own large chunks of the documentation. We would arrange conference calls as needed with the developers of key sections to talk through approach, technical details and future plans. The goal would be to ensure you have a full understanding and access to anyone you need when writing. Ultimately, it would also give you a few things.

First, you would have unlimited access to learn FlexUnit at a very, very deep level. Second, you could help create a volume of work (I am hoping we can produce both wiki content and eventually a comprehensive PDF book) which will continue to be attributed to you. Third, that attribution plus future recommendations from myself and others on the team and in this industry are guaranteed (and very helpful for future interviews).

Anyone who is seriously interested should leave a comment on this post and I will reach out to you immediately.

If you want to take a look at our current efforts, head over to http://docs.flexunit.org/

Thanks,

Labriola

You can download the latest bits from the flexunit.org download site.

Beta 2 resolves a myriad of small bugs and adds minor features  including:

• Fixed order of parameterized test versus order of data supplied
• Added additional debug output during headless xvnc execution
• Improved formatting of parameterized test names
• Added a new interface IExternalDependencyData for simplified loading of external data during Parameterized Tests and Theories
• Added comments and resolved many PMD warnings
• Additional feedback with mis-configured Rules
• Fixed BeforeClass and AfterClass duplicate execution with Parameterized Tests
• Fixed a crash using Before and After with Parameterized runner
• Updates to the sample CI project and build scripts to simplify builds without PMD
• Updated Ant task to support Flex 3 and 4 for Flash and AIR

Improved External Data Loading for Parameterized Testing and Theories

One of the only API changes in FlexUnit 4.1 beta 2 from beta 1 is the addition of a new interface named IExternalDependencyData. With the addition of this interface, you now have two ways of getting external data into Parameterized Tests and Theories.

Option 1 is to use the IExternalDependencyLoader, which allows a separate class to load the dependency and then assign it to a static variable on the class when complete. This was available in FlexUnit 4.1 beta 1 and is still a great choice in a number of situations where you may have customer setters or other such functionality on the test.

public static var dataRetriever1:IExternalDependencyLoader = new ParamDataHelper( "PurelyFakeExample.xml" );
[Parameters(loader="dataRetriever1")]
public static var someData:Array;

public function TestParameterized( param1:int, param2:int ) {
_input = param1;
_expected = param2;
}


The IExternalDependencyLoader interface works with the Theory and Parameterized test runners to facilitate asynchronous loading of data points before testing begins.

Option 2 is IExternalDependencyData which extends IExternalDependencyLoader to simplify the syntax for the average case. It makes the test case more readable by eliminating the extra static variable which isn’t needed in most cases and allows the test to gather its data directly from the helper class. Here is an example of using this interface in a variety of situations.

[Parameters]
public static var dataRetriever:IExternalDependencyData = new ParamDataExt( "someFakeDataPath.stuff" );

public function TestParameterized( param1:int, param2:int ) {
_input = param1;
_expected = param2;
}


or

public static var dataTwo:IExternalDependencyData = new ParamDataExt( "someFakeDataPath.stuff" );

[Test(dataProvider="dataTwo")]
public function timesTwoTest( value:int, result:int ):void {
assertEquals( 2*value, result );
}


As you can see, the syntax really just eliminates the use of an extra static variable in most situations. The original interface is still available and supported but we suspect the IExternalDependencyData will be the right choice in most situations.

Now, get the latest bits from flexunit.org download site and give us some feedback.

You can download the latest bits from the flexunit.org download site.

Here are a few feature descriptions and bullet points of some of the new features in the FlexUnit 4.1 world.

Parameterized Testing

There are times when you need to repeat a test across a series of data points. Imagine a class that does a complex calculation based on input values. It is likely that you would want to test hundreds or thousands of different input values, checking each of their expected outputs to feel comfortable that this class was behaving properly. Or, perhaps you have a whole series of components which implement an interface and you wish to verify that setting the ‘x’ property on each of those objects dispatches and expected event or updates a given property. These are both cases where Parameterized testing can simplify your life.

Parameterized testing in FlexUnit works by allowing you to specify arguments to be passed to a constructor (we call it JUnit style), or arguments which will be passed to a method (TestNG Style). Here is a quick sample of the approach:

Constructor (JUnit Style):

[Parameters]
public static function data2():Array {
return [ [ 3, 6 ], [ 4, 8 ], [ 5, 10 ], [ 6, 12 ] ];
}

private var _input:int;
private var _expected:int;

public function TestParameterized( param1:int, param2:int ) {
_input = param1;
_expected = param2;
}

[Test]
public function doubleTest():void {
assertEquals(_expected, _input*2);
}


Method (TestNG Style):

public static function dataThree():Array {
return [ [ 0, 1, 1 ], [ 1, 2, 3 ], [ 2, 4, 6 ] ];
}

[Test(dataProvider="dataThree")]
public function addTwoValuesTest( value1:int, value2:int, result:int ):void {
assertEquals( value1 + value2, result );
}


Parameters are defined by static properties containing arrays of arrays. The framework iterates through the array, calling your methods with the parameters of each inner array. Parameterized testing can be combined with the asynchronous testing for very complex testing.

At first glance, those of you familiar with theories might see a lot of similarities to parameterized testing; they also allow a developer to create methods and a constructor that accept parameters. A theory is different in how the data is defined and in the way a test fails. A theory is akin to a mathematical theory wherein any failure means the whole theory is bad. Further, theories are often reversible. For instance, a valid theory might entail testing a math class by first multiplying two numbers and then dividing the product by the first number. If your code is valid, you should get the second number back. Testing this across a potentially infinite number of values is the real of a theory.

Whereas theories see all of the datapoints as input to a single test, which passes or fails as a whole, parameterized testing expands your set of parameters to individual tests allowing you to understand which cases fail and succeed individually. Parameterized tests are more useful in cases where you have a fixed data set with known specific values which represent a valid outcome.

External Data for Parameterized Testing and Theories

Executing tests across large data sets necessarily involves maintaining that data. FlexUnit 4.1 allows the data for Theories and Parameterized tests to be loaded from an external source.


public static var dataRetriever1:IExternalDependencyLoader = new ParamDataHelper( "PurelyFakeExample.xml" );
[Parameters(loader="dataRetriever1")]
public static var someData:Array;


The IExternalDependencyLoader interface works with the Theory and Parameterized test runners to facilitate asynchronous loading of data points before testing begins.

Rules Implementation

When creating large suites of unit tests, you could find yourself duplicating complex setup code many times. Rules offer the ability to factor this code into a separate class and specify logic that will be invoked before or after each test method call, allowing you to alter how a method is called, perform additional setup or even examine and change the result of a test runner.

[Rule]
public var rule1:IMethodRule = new SomeRule();
[Test]
public function test1():void {
}


This feature can be used to create new types of test runners through composition instead of inheritance, allowing more flexibility, less code to maintain and the ability to reuse the rule across many types of runners. The first application of this technology was the auto-creation and verification of Mocks for test cases, however, the next application is a Rule to inject dependencies into cases.

Directory Scanning and Test Loading

Using the FlexUnit Ant tasks, you can point FlexUnit at a directory, which it will recursively scan for tests, build a temporary suite and execute on your behalf, removing the need to maintain static lists of tests in many cases.

<flexunit workingDir="${bin.loc}" toDir="${report.loc}"
haltonfailure="false" verbose="true" localTrusted="true">
<testSource dir="${main.src.loc}" />
<testSource dir="${test.src.loc}">
<include name="**/*Test.as" />
</testSource>
<library dir="${lib.loc}" />
</flexunit>

Performance Improvements

FlexUnit 4.1 now executes FlexUnit 4.x style metadata tests approximately 60% faster than before. New logic that directly monitors the progress of tests throughout the Flash Player frame allows the framework to better utilize the available time, resulting in an additional significant performance boost. Collectively these improvements can halve the execution time on very large suites over previous versions.

UIImpersonator for AS or Flex

Flex developers have had the ability to use the UIImpersonator classes to allow components to interact with the display list since version 4.0. Version 4.1 extends that coverage and allows ActionScript only projects the same access. A new property on FlexUnitCore allows developers to indicate the visual display root of the application, thereby allowing this access.

var core:FlexUnitCore = new FlexUnitCore();
core.visualDisplayRoot = this;


Asynchronous Functionality now Available in Parameterized Testing and Theories

The ability to test asynchronously is imperative in Flash, where operations are often broken across frames. FlexUnit Asynchronous methods are now available in Theories and Parameterized Tests.

Package level assertions

You may have noticed that throughout these examples, we have simply said

assertTrue() instead of Assert.assertTrue()

Package level assertions now exist for all assertion methods, minimizing typing and porting from previous versions of FlexUnit or Fluint.

Timing information during test run

Timing information is gathered internal to the framework during test run, allowing for more accurate measurements of test execution time.

Now, got download the latest bits from flexunit.org download site and give us some feedback.