Skip navigation
1 2 Previous Next


27 posts

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 HeienNicklas 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 ]


Ike Goes Emotional!

Posted by aslak Jul 21, 2010

For the observant viewer, you might have noticed the little colored ball in the top right corner of the Arquillian badge on the Arquillian site. For the not so observant one, this is what it looked like:



The ball is the Hudson build indicator. It tells you the status of the latest Arquillian build.


We're proud to show off our latest build status, so now we're taking it one step further...


Meet Emotional Ike!

SUCCESS: Latest build was a complete success. Ike is pleased!

UNSTABLE: Latest build has failing tests, be careful. Ike is giving you a warning for this time..

FAILURE: Latest build failed. Ike is pissed! If you see this, you should run and hide.

UNKNOWN: For some reason the status of the latest build is unknown. With all the uncertainty and doubt, Ike sings the blues.



So if ever in doubt, head over to the Arquillian site to check out Ike's mood in the right side menu.



Big thanks to cheyenneweaver for the awesome graphics! She should be ennobled for all her great work... I'm not going to say to much, but just maybe one day she will...

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

Tomorrow is going to be an eventful day for Arquillian. Aslak and I will kick the day off with a presentation demo of Arquillian at JUDCon. Aslak will walk you through what Arquilian is doing while I drive the screen. We're planning to capture a screencast of the presentation (keep your fingers crossed). We'll also have more shirts to give away. Ike is on the back, and he has a message for you.



If you're at JUDCon, be sure to stick around for the JUDCon hackfest in the evening to hack on Arquillian with the project developers (Aslak, ALR, Pete, myself and more) from 7:30PM to 2AM EST. Other projects joining the hackfest include ShrinkWrap, Seam, JBoss AS and JBoss Cloud. The ideas are sure to be flowing!


If you're unable to make the trip to Boston for JUDCon, you don't have to miss out! We'll be on freenode IRC in #jbosstesting, #seam-dev and other channels throughout the hackfest. There will also be forum and JIRA activity throughout, no doubt, and Skype is another option. So this is both global event and local event!


Grab your code. It's on.

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.


Arquillian bottle caps logo


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

Another mark in the calendar for the Arquillian team, 1.0.0.Alpha2 has just been released!

The Second fleet of the first wave has arrived!


(... Ooh boy, what a ride! Our transwarp speed engine went critical, had to eject the core and hustle a local merchant at a nearby tradestation for a new coil. A long story for some other time...)


Highlights of the release:


  • @Run(AS_CLIENT) mode: Arquillian only controls the lifecycle of your @Deployment, the test case executes in your local JVM.   
    • Excellent for testing Remote EJBs, WebServices and web pages.


public class LocalRunServletTestCase
   public static WebArchive createDeployment() 
      return ShrinkWrap.create("test.war", WebArchive.class)

   public void shouldBeAbleToDeployWebArchive() throws Exception
      String body = readAllAndClose(
            new URL("http://localhost:8080/test/Test").openStream());

            "Verify that the servlet was deployed and returns expected result",


<?xml version="1.0"?>
<arquillian xmlns=""




The containers you can depoy to in this release:


  • JBoss AS 6.0 Embedded AS
  • JBoss AS 6.0 Remote
  • JBoss AS 6.0 with lifecycle(start/stop as part of the test run)
  • JBoss AS 5.1 Remote
  • JBoss AS 5.1 wth lifecycle(start/stop as part of the test run)
  • JBoss Reloaded (MicroContainer + VirtualDeploymentFramework)   
    • Test your deployers and MC beans !
  • Weld SE
  • GlassFish Embedded 3.0
  • Apache OpenEJB
  • Apache OpenWebBeans


Arquillian no longer exposes the containers dependencies transitively, so you can control which container point release v. or logging framework the Arquillian integration should use. This might sound more complex at first, but see the "Complete Container Reference" in the Reference Guide for Maven examples on how to set this up for each container.


And what's open source without the community?!


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


In alphabetical order: Dan Allen, German Escobar, Ken Gullaksen, Sten Aksel Heien, Alejandro Montenegro, Pete Muir, Jesper Pedersen, Andrew Lee Rubinger, Juergen Zimmermann.


And of course thanks to the Seam 3 team for helping with early SNAPSHOT testing, big help!


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.


Real World Java EE Testing (slides)pmuirMay 8, 2010JBoss in Bossa
Real Java EE Testing with Arquillian



Jun 3, 2010Jazoon
The Future of Java EE Testing



Jun 21, 2010JUDCon
Throwing Complexity over the Wall:
Rapid Development for Enterprise Java
alrubingerJun 23, 2010JBossWorld
Real Java EE Testing with Arquillian and ShrinkWrap (recording)dan.j.allenAug 13-15, 2010No Fluff Just Stuff
Arquillian Invasion:
Reducing Enterprise Testing to Child's Play



Aug 18, 2010JBoss Community:
Webinar #6
Throwing Complexity over the Wall:
Rapid Development for Enterprise Java



Sep 19-23, 2010JavaOne


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.

Today I bring good news to all the fellow Arquillians out there. We just got our own project site!


The project site is the place to go to find all information about the project. It has the typical items like:


  • Overview
  • About the project
  • Features
  • Downloads
  • Documentation
  • Building from source
  • Links to the:   
    • Community space (SBS)
    • Source control (SVN)
    • Issue tracker (JIRA)
    • CI builds (Hudson)


But to keep things interesting, we've also aggregated rolling information, such as:


  • Latest blog entires from the community blog
  • External articles feed
  • Recent commits in source control (with links to JIRA issues)
  • Ohloh project stats
  • Current build status (The blue orb in the corner of the Ohloh stats)


The Arquillian complements the project site as host of the dynamic community content--our forums (discussions), community articles and blog entries. The information on our old "wiki home page" will eventually be phased out and replaced by the community space + the project site.


See something that's missing? Want something changed? As always we would like the communities feedback on where to go from here. Please don't hesitate to let us know!


Now head over to the Arquillian project site and poke around.


Look for the link on the right to find cool Arquillian swag and a wallpaper for your desktop!

I will use the opportunity to give a big thanks to cheyenneweaver for the great artwork and to dan.j.allen for bringing life to the site! Now, let's get back to those new features!


[ Arquillian Project Site | Arquillian Community Space ]

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


Cool software projects have cool logos. We recently The specified item was not found. an alpha release of Arquillian, a project that's going to revolutionize Java EE integration testing. Now we need to make Arquillian cool


We are in the process of establishing Arquillian's visual identity, its logo. We've already been through a couple rounds of grayscale design comps with cheyenneweaver from the JBoss Community design team, who is designing the Arquillian logo. Throughout the process, we've asked community members to provide feedback on the comps to help steer the design process. You can follow some of the progress in Arquillian logo or the #arquillian Twitter hashtag. We're casting a wider net this time by asking readers of this blog to chime in.


The themes we are pursuing are:


  • aliens
  • remote control
  • in container


Here are the round 3 logo candidates:









Follow the link to the poll below to let us know which ones you like best and why.


  • Arquillian logo poll (Round 3) - no longer active


Once we collect enough feedback, we'll send it over to Cheyenne and let you know which ones made the cut. Thanks for participating!


See the original blog entry to view and post comments.

This post was syndicated from


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)


public class TemperatureConverterTestCase {
   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.


public class TemperatureConverterTestCase {

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

   private TemperatureConverter converter;

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

   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:



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

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:


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:
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.
private InitialContext context;
// auto creation of URL to a deployed Servlet, including http port/ip etc.
private URL myServletURL;
// the bundle context of a deployed osgi bundle
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 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.

This post was syndicated from


Recently, we've been working hard on a solution to improve the testability of Java EE, and particularly JBoss AS. I'm pleased to say that a critical piece of puzzle, Arquillian, is now available. Congratulations to aslak and the Arquillian for releasing the first alpha of Arquillian! You can read more about Arquillian's mission, and our plans for Java EE testing below; alternatively, there are some quick links at the bottom if you want to dive right in.

The mission of the Arquillian project is to provide a simple test harness that developers can use to produce a broad range of integration tests for their Java applications (most likely enterprise applications). A test case may be executed within the container, deployed alongside the code under test, or by coordinating with the container, acting as a client to the deployed code.


Arquillian defines two styles of container, remote and embedded. A remote container resides in a separate JVM from the test runner. Its lifecycle may be managed by Arquillian, or Arquillian may bind to a container that is already started. An embedded container resides in the same JVM and is mostly likely managed by Arquillian. Containers can be further classified by their capabilities. Examples include a fully compliant Java EE application server (e.g., GlassFish, JBoss AS, Embedded GlassFish), a Servlet container (e.g., Tomcat, Jetty) and a bean container (e.g., Weld SE). Arquillian ensures that the container used for testing is pluggable, so the developer is not locked into a proprietary testing environment.


Arquillian seeks to minimize the burden on the developer to carry out integration testing by handling all aspects of test execution, including:


  • managing the lifecycle of the container (start/stop),
  • bundling the test class with dependent classes and resources into a deployable archive,
  • enhancing the test class (e.g., resolving @Inject, @EJB and @Resource injections),
  • deploying the archive to test (deploy/undeploy) and
  • capturing results and failures.


To avoid introducing unnecessary complexity into the developer's build environment, Arquillian integrates transparently with familiar testing frameworks (e.g., JUnit 4, TestNG 5), allowing tests to be launched using existing IDE, Ant and Maven test plugins without any add-ons.


The Arquillian Mission Statement


The first alpha release of Arquillian gives us support for JBoss AS (remote deployments), GlassFish (embedded deployments), Weld SE (embedded deployments) and OpenEJB (embedded deployments). You can also inject beans and component (using @Resource or @Inject) into test cases.


We'll be adding supported containers in future releases - if you want to see your favorite container on the list, join our community and we can show you how to add support for it. We also plan to add more convention over configuration, meaning you'll only need to specify a single deployment and reuse it in all your test cases. Aslak has written more about future ideas in a Arquillian 1.0.0 Alpha 1 Released! announcing the 1.0.0 Alpha 1 release. In that entry he also provides some examples of how to use Arquillian.


We're strong believers in writing tests, and writing tests which actually test your business logic in the environment it will finally run in, rather than introducing mocked out objects (which may behave differently). While unit testing is important to ensure the correctness of your logic, it does not ensure the correctness of two objects which interact with each other.


With the help of the ShrinkWrap project, Arquillian gives you the ability to create micro deployments around your tests. Micro-deployments are contained sub-sections of your application logic. This gives you the ability to do lower level integration testing on a lower level then normal integration. It is up to you at what level you want to test!


We also know you need a convenient way to run your test quickly, and that is why we are getting JBoss Embedded AS in shape. Embedded AS offers the potential to bootstrap JBoss AS inside the same JVM when you run your test, making it super easy to debug the test. Unfortunately, Embedded AS support didn't make this release (we made a decision to release what we have now, rather than delay), but we will push this out to you as soon as it's ready.


Testing your components and services gets you a long way, but you'll nearly always want to test your presentation tier as well. And that's where frameworks like JSFUnit and Selenium come in - they allow you to exercise the work flows your user will use. Support for both these frameworks is planned, as well as for Mock JSF Objects.


If you like what you've heard so far, but are worried that Arquillian requires build script wizardry to use, let us surprise you again! Being able to run any of these tests from within the IDE is a key goal of Arquillian -- and the key to a rapid development cycle. Arquillian requires no build wizardry! So check out the documentation and give it a try today!


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


See the original blog entry to view and post comments.

Filter Blog

By date:
By tag: