We're happy to announce that the 3. Arquillian Alpha release was just pushed out the official channels.

News in Alpha3 are:

• JBoss AS Remote 5.0
• JBoss AS 6.0 M4 ready
• GlassFish 3.0 Remote
• Jetty Embedded 6.1 & 7
• Tomcat Embedded 6.0
• Weld EE Mock 1.1
• OSGi Embedded 4.2

A big note for Alpha3 is ARQ-200 : Change version scheme for containers. With this most containers changed their artifact name.

The new scheme is: arquillian-"name"-"type"-"major"[."minor"][."point"]

e.g. arquillian-jbossas-remote-60 -> arquillian-jbossas-remote-6

The version rule is: earliest working version and working up to the next artifact version.

That means arquillian-jbossas-remote-6 should work with 6.5 unless there is another container named arquillian-jbossas-remote-6.5.

See The Complete Container Reference Guide for full description of the containers and their configuration.

If you're interested in the upcoming Arquillian release Road Map, we're now keeping the Jira Road Map up to speed on planned features / releases.

Big thanks to the Arquillian and ShrinkWrap community for helping us with this release!

In alphabetical order: Dan Allen, deruelle_jean, thomas.diesler, agori, Ken Gullaksen, jharting, Sten Aksel Heien,  Nicklas Karlsson, Pete Muir, The specified item was not found., Andrew Lee Rubinger, mwringe.

[ Arquillian ] | [ JIRA ] | [ SPI Javadoc, API Javadoc ] | [ Reference Guide ] | [ Release Notes ] | [ Maven Artifacts ]

Last month, the Arquillian developers got together at Red Hat Summit / JBoss World 2010, hosted at the Seaport World Trade Center in Boston, to Experience Open Source with our community.

We Community Track Nominations what they wanted to hear about at JUDCon. The survey said, "Arquillian." So we unleashed Ike and his fleet of testable containers onto JUDCon and JBoss World.

While Arquillian only appeared twice on the official schedule–once at JUDCon, presented by Aslak and myself, and once at JBoss World, presented by ALR–it managed to make an appearance every hour, in one form or another (including bar discussions). Thanks for encouraging him with all the votes!

On the eve of JUDCon, three of the Arquillian ringleaders (aslak, alrubinger and dan.j.allen) met up at Harvard Square bar for the Boston JBUG to devise a plan to make testing a main focal point of the weeklong conference event:

Not letting a moment slip by, Arquillian led off the community track at JUDCon early the next morning.

Aslak and I wanted to leave a strong impression on the audience. So instead of going on about theory, we prepared a talk on the future of Java EE testing that can be summed up as: demo, demo, demo, demo. With me driving the commands, Aslak pointed at the screen and, in a flash, showed how Arquillian can make child's play out of testing EJBs, JMS, JAX-RS, JPA and even JSF.

While we've come a long way with Arquillian, presenting always gets us thinking of other things we can do with it. (Notice Aslak sporting the black Arquillian shirt).

Ike didn't want to get stuck inside the computer the whole conference, so we printed him on a bunch of shirts and buttons to give away. Our plan was almost foiled because of my absentmindedness, but it was saved when my wife delivered the "bag of goodies" just as the talk was ending. We spread the Arquillian swag around and it scattered off to invade other talks and strike up conversations.

Everytime you turned around, Ike was hitching a ride on someone's backpack.

Making his second apparence on the JBoss Community Asylum, this time under the JBoss moniker, Aslak explained how Arquillian makes the task of testing Java EE applications simple and possible. This would be one of many trips to the microphone throughout the week. But this time, he caught some grief from the jokester hosts poking fun at the project name:

Who is Hark William? Is he a country singer or some sort of character from Star Wars?

Aslak set the record straight.

His name is Ike. And he's from Hollywood. He's an alien that controls everything inside his little world.

If Ike could speak, he would have simply issued the warning:

Don't mock me.

He must have left quite an impression, because the host immediately credited Arquillian as having "a couple of talks today." Sure, that's how we remember it too

Even though the Arquillian team only had one talk at JUDCon, we did have a front row seat in the Code generation world premiere presented by jesper.pedersen from the JBoss JCA Team, showing of their shiny new tool for JCA adaptor source code generation with full Arquillian test support.

So what's the Arquillian project status? "Alpha3 is coming soon. And more containers." (Little did they know, three containers would be added later that night).

The podcast had interrupted the JUDCon hackfest. It then proceeded to ultimately disrupt the hackfest when Emmanuel announced at the top of the hour,

Let's go get some beers.

So all the talk of a hackfest ended up being just that, talk. But wait, not those hard-core Arquillian developers. They're the only ones that stuck around, pressing on even in the absense of beer.

"Why?" you ask. Because we were hell-bent on getting the Tomcat and Jetty container integrations working. I did the Jetty integration while deruelle_jean worked on the one for Tomcat. lincolnthree looked on.

Once we both got green bars, we finally called it a night and headed out for a round of drinks to celebrate.

We took a break the next afternoon to check out the sights and sounds of downtown Boston, which could be seen off in the distance from the conference center.

That evening I headed over to the Red Hat Summit kickoff at the pavilion for my booth duty. kenglxn, one of our top community members, snapped a shot of me sporting our cool Arquillian desktop wallpaper on my Android phone.

Fashioning the Arquillian button, I was soon approached by an attendee who asked me if I had any extra. I asked him if he knew what they were for. He replied,

No. But it looks really cool.

Ike, such a developer magnet

At some point we made our way from the conference center to a bar downtown. Like always, I'm in the bar ranting on about some technology, probably Maven:

We were up early the next morning for the second Arquillian charge. ALR kicked off the conference by showing how developers can achieve rapid development with Enterprise Java by throwing complexity over the wall and using ShrinkWrap and Arquillian, while at the same time marklittle, our CTO, was in the other room explaining how Arquillian fits into our strategy in his JBoss State of the Union address.

Arquillian is central to the evolution of platfoms & relevant for development.

To put it more bluntly, he slipped out,

You need to test the hell out of things.

We agree.

Handling all that complexity for the developer is hard work, though. It really took it's toll on ALR,

Arquillian got a mention in the joint RichFaces 4 / Seam Faces talk and the Seam 3: State of Union talk. All the activity had the developers' interest piqued. When pmuir asked during the the JBoss Developer Story BOF what people wanted to hear more about, someone called out,

I want to hear more about the testing tool.

Once again, Aslak was called to the mic to showcase Arquillian. The timing was excellent because burrsutter, who is currently focused on improving the developer experience, witnessed first-hand how desperately this tool is needed. Afterwards, I said to him,

It's like we just showed up with food to a starving country.

And what are they asking for? More.

Until we meet up again, we'll be hard at work making testing as easy and powerful as possible. That means working closely with our tools guy, maxandersen (left).

Ike sure had a big week. So at the end of it all, we bought him a drink.

The Arquillian are really heating up! Community participation is what makes the success of Arquillian possible. Keep it up folks!

Conference photos | More conference photos | Arquillian swag

When you think of aliens, images of little green men likely come to mind. Following suit, the Arquillian logo and project colors are also shades green. But did you know that Arquillian is "green" as in the environment?

For World environment day (June 5th), Red Hat organized worldwide office events. At the Brno office, jharting and mgencur recreated the Arquillian logo out of plastic bottle caps.

How cool is that? Where will the Arquillian logo show up next? Perhaps on the side of a bus? The invasion continues!

Testing Java EE should be easy. This summer we're going to show you how.

After all, you know you should test. You know it forces you to consider API design, proves your implementation, documents your code and ensures stability during refactoring. And it seems so easy when you are writing basic unit tests. When call graphs branch, you just plug in mock objects.

But unit tests and mocks can only take you so far. Eventually, you need to test your components in the real world. You know, integration and functional tests. But with so much to setup, it's hard to fault even the most persistent developer for giving up. Real world tests are slow to write, slow to execute and push back that ever important deadline.

It's time to change that perception.

Members of the Arquillian project will be making more than a half dozen stops this summer to show developers how to throw complexity over the wall and create enterprise tests with ease--with some talks already on the books.

You'll discover how to skip the build and test in-container, all without having to leave the comfort of your IDE. We'll present an annotation-driven test harness that reduces boilerplate infrastructure code and hooks into common embedded and remote EE containers from a "pojo" environment.

Below is a list of the talks, dates and conference events where Arquillian will land to terminate once and for all those elaborate test assemblies.

Writing a test for a real business object should not create pause. You should be able to tackle an integration test with the same confidence you have when writing a unit test for a calculator class. We're hitting the road to show you how Arquillian and ShrinkWrap provide that experience.

We're thrilled to announce that the Arquillian logo has been chosen.  We received well over 100 responses from the community during the three rounds of feedback on the Arquillian logo drafts. That feedback was shared with the design team, which helped steer them towards a design you felt best represented the project and the software. Thanks to all who participated!

Behold, an alien has invaded your container!

The competition between the universe globe and the alien eyes was very tight. In the end, we decided to put the eyes inside a container and reserve the universe theme for the banner, which you'll get to see when the project page is finished.

We also carefully selected a font face for the project name to match the coolness of the logo.

If you dig the artwork, don't just look at it, show it off! Make it one of your 37 pieces of flair or grab a t-shirt to complete your look from the Arquillian swag shop on CafePress.

At the end of the day, after you close all your browser and IDE windows, we want to make sure you know that Arquillian is ever present in your mind. So, our design team has also prepared a bedazzling desktop wallpaper for you (in lots of resolutions, including one for your smartphone).

Give a shout-out to cheyenneweaver for the hard work she put into creating this artwork (and for putting up with our wayward change requests for two months).

Now we need to work on getting the Arquillian project page together and push out an Alpha2 release.

This post was syndicated from in.relation.to.

I'm happy to announce the first alpha release of Arquillian, an open source (ASL v2) framework for running tests in the container. If you want to read more about Arquillian's mission, and how it fits into our vision for testing at JBoss, read Testing Java EE the JBoss way.

It's one thing to unit test your code outside of the container, but what happens when you run it inside? Does it still behave the same? How about testing against container managed resources? This is where Arquillian comes into its own.

With Arquillian it's just as easy to write integration tests as unit tests. In fact, to minimize the burden on you, Arquillian integrates with familiar testing frameworks, allowing reuse of tools such as the JUnit/TestNG support in your favorite IDE, Maven Surefire, Ant - in fact any tool which supports TestNG or JUnit!

To show you just how simple this is, here's an example test case setup using JUnit: (we'll get to the actual test next)

@RunWith(org.jboss.arquillian.junit.Arquillian.class)
public class TemperatureConverterTestCase {
 
   @Deployment
   public static JavaArchive createTestArchive() {
      return Archives.create("test.jar", JavaArchive.class)
         .addClasses(TemperatureConverter.class, TemperatureConverterBean.class);
   }
 
}

By using JUnit's @RunWith annotation, you tell JUnit to use Arquillian as the test controller. Arquillian will then look for a static method marked with the @Deployment annotation, which creates your micro deployment. In the example above we simply deploy a session bean interface and implementation.

Arquillian hooks into your testing frameworks lifecycle and reacts to events. On the before suite and after suite events the container is started/stopped, while on the before class and after class events your micro deployment is deployed to/undeployed from the container.

The test case is started in the local JVM, and then Arquillian overrides the normal test execution and migrates the test so that it's executed inside the container. By the time the test framework calls your @Test annotated method, the test is running inside the container, giving us the possibility to work with container managed resources. Here's the complete test class with JUnit @Test methods.

@RunWith(org.jboss.arquillian.junit.Arquillian.class)
public class TemperatureConverterTestCase {

   @Deployment
   public static JavaArchive createTestArchive() {
      return Archives.create("test.jar", JavaArchive.class)
         .addClasses(TemperatureConverter.class, TemperatureConverterBean.class);
   }

   @EJB
   private TemperatureConverter converter;

   @Test
   public void shouldConvertToCelsius() {
      Assert.assertEquals(converter.convertToCelsius(32d), 0d);
      Assert.assertEquals(converter.convertToCelsius(212d), 100d);
   }

   @Test
   public void shouldConvertToFarenheit() {
      Assert.assertEquals(converter.convertToFarenheit(0d), 32d);
      Assert.assertEquals(converter.convertToFarenheit(100d), 212d);
   }
}

Note how we can use @EJB to inject the session bean from our deployment into the test case for use in our test method - neat!

The Arquillian TestEnricher SPI supports all the injection annotations from Java EE 6 - @EJB, @Resource and @Inject.

This example test case could run in GlassFish, JBoss AS or OpenEJB as there are no container specific code/configuration at all. The choice is yours. You could even test on multiple platforms!

I want to learn more, where should I go from here?

You can follow up with some in depth usage scenarios and tests described in these articles:

• Dan Allen - Using Arquillian to test a possible bug in Weld
• Jordan Ganoff - Seam 3 JMS Module Testing with Arquillian
• German Escobar - Testing a JMX Portable Extension for CDI

We also have reference documentation which walks you through the examples from Arquillian, and shows you how to create your own Arquillian test suite. You might also find the Javadoc useful (API, SPI), especially if you plan on adding support for another container. You can also check out the forums and more articles can be found on our community site. If your interested in chatting to us, please drop by #jbosstesting on irc.freenode.net

So, what's next?

Some of the things you can expect from Arquillian are:

• Local run mode -- Sometimes, you don't want to run the test case inside the container itself. A local run mode will be added; a mode where your test controls the deployment but is not deployed as a part of it. This will give you the chance to run a test against, for example, JSF pages or RMI (testing for those nasty Non-Serializable / SessionClosed exceptions).
• Multiple deployments controlled by same test -- Sometimes your micro deployment is not enough to test on its own and you want to package other components as part of the same deployment. For example, you need to test the interaction between two Web applications.
• Support for method argument injection -- In the first alpha we only support field injection. In alpha 2 we will be extending the TestEnricher SPI to include support for method argument injection:

@Test
public void shouldWithdrawFromAccount(@EJB AccountManager manager)
   throws Exception
{
   ...
}

• Test method interceptors -- Another planned enricher SPI is a test method interceptor. With this we can add support for transactions:

@Test
@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
public void shouldWithdrawFromAccount(@EJB AccountManager manager)
   throws Exception
{
   ...
}

• Convention over configuration -- The micro deployments should be as easy as possible to create, so adding support for common conventions should help speed up the test development. For example we can automatically add all classes in the same package as the test class to the deployment
• Arquillian controlled resources -- Sometimes the container requires container specific configuration e.g, java.naming.* parameters needed to create a InitialContext. If the test case has to explicitly deal with this, it places the burden for container portability back on the test case author. Arquillian will provide an extension point to add Arquillian created/managed resources:

// auto creation of InitialContext based on running container, remote or local.
@ArquillianResource
private InitialContext context;
 
// auto creation of URL to a deployed Servlet, including http port/ip etc.
@ArquillianResource(MyServlet.class)
private URL myServletURL;
 
// the bundle context of a deployed osgi bundle
@ArquillianResource
private BundleContext context;

• Add support for more containers -- We will plan to support more containers! Currently we have planned: GlassFish 3 (as a remote container), Jetty, Tomcat, Resin, Felix OSGI. (Hey Spring guys, you're welcome to join in too!)
• Third party integrations -- In the spirit of ease of development, we integrate with existing test frameworks as much as possible, but we are always keen to learn of new frameworks we can integrate with. We already plan to support Selenium for example.
• Support for other build tools -- Arquillian Alpha1 comes with Maven support. In upcoming releases, we will distribute builds targeted toward other build tools like Ant and Gradle (that shout out is for our resident Gradle expert, Jason Porter).
• A project page, logo and artwork -- All good things must look good. That's why the JBoss.org design team is hard at work putting together artwork for the Arquillian project page. Stay tuned!

Where can I see Arquillian in use?

Arquillian is a new framework, but it's going to be put right to work as the workhorse to test all the Seam 3 modules. It will also be our recommended solution for testing your Seam application. (We'd love to see the community try it out for testing Seam 2 applications). We'll also replace the current core of the JSR-299 CDI TCK with Arquillian, likely for the 1.1 version of the TCK. (To provide a little history, Arquillian originated from the JBoss Test Harness that was developed by Pete Muir as the foundation of the CDI TCK).

If you have any thoughts on these ideas, or would like to suggest some new avenues we should explore, please contact us on the Arquillian Development.

And, what's open source with out the community?!

A big thanks to the Arquillian and ShrinkWrap community for helping out on this release by being early adopters, joining in on community meetings, general discussions and writing blogs, articles and patches. In alphabetical order: Dan Allen, Steven Boscarine, German Escobar, Jordan Ganoff, Ken Gullaksen, Pete Muir, Jason Porter, Andrew Lee Rubinger. You guys rock!

[ JIRA | SPI Javadoc, API Javadoc | Reference Guide | Release Notes | Maven Artifacts ]

See the original blog entry to view and post comments.