Throwing complexity over the wall: Rapid development for enterprise Java (JavaOne 2010)
1 like637 views
The document discusses the challenges of enterprise software development and introduces Arquillian, a container-oriented testing framework that simplifies integration testing for Java EE applications. It emphasizes the importance of focusing on core business logic while minimizing unnecessary complexities, encouraging the use of tools like Shrinkwrap for streamlined deployment. The presentation includes a demo, benefits of Arquillian, and an invitation to engage with the community for further learning and collaboration.
Throwing complexity over the wall: Rapid development for enterprise Java (JavaOne 2010)
- 1. Throwing Complexity Over the Wall: Rapid Development for Enterprise Java Dan Allen Andrew Rubinger JBoss, by Red Hat JBoss, by Red Hat mojavelinux ALRubinger
- 2. Agenda #arquillian ● Enterprise software development challenges ● Component models as a solution ● Tools that help you develop & test with confidence ● ShrinkWrap - Skip the build ● Arquillian - Test in-container ● Demo, demo, demo ● Arquillian's interchangeable parts ● Q & A (or more demos) 2
- 3. General categorization of software ● Core concerns ● Cross-cutting concerns ● Plumbing 3
- 4. What should you code? ● Core concerns ● Business logic ● Domain-specific ● Why? ● Nothing can do this for you ● It's what you are paid to do ● It's a good investment of time ● You get to 100% done sooner 4
- 5. What should you avoid? ● “Conceptual weight” ● Cross-cutting concerns ● Plumbing ● Unnecessary LOC ● Write less = maintain less ● Improve signal-to-noise ratio 5
- 6. Components models as a solution ● Component ● Follows standard programming model ● Encapsulates business logic ● Packaged in deployable archive ● Container ● Host process for deployed applications ● Provides services and a runtime for components ● Gives you powerful mechanisms for free 6
- 7. So what is Java EE, really? A standards-based platform that allows us to write business logic as components 7
- 8. s ing mis What's been from Java EE? ^ 8
- 9. A component model for your tests 9
- 10. Unit tests vs integration tests Unit Integration ● Attributes ● Attributes ● Fine-grained ● Coarse-grained ● Simple ● Complex ● Single API call ● Component interactions ● Perception ● Perception ● Fast, fast, fast ● Sloooooooow ● Easily run in an IDE ● Run in an IDE? How? 10
- 12. Common integration testing challenges ● Bootstrap a container environment ● Run a build to create/deploy application archive ● Mock dependent components ● Configure application to use test data source(s) ● Deal with (lack of) classpath isolation ● URLs, host names and ports, oh my! 12
- 13. The testing “bandgap” Complexity ( Mental Effort) Functionality Setup & configuration Unit Tests Integration Tests System Tests 13
- 14. What if integration testing could be...? ● as easy as writing a unit test ● run in the IDE (incremental builds, debugging, etc) ● ramped up in phases ● portable 14
- 15. An in-container approach to integration testing 1. Start or connect to a container 2. Package and deploy test case to container 3. Run test in-container 4. Capture and report results 5. Undeploy test archive Bring your test to the runtime... ...instead of managing the runtime from your test. 15
- 16. Reducing enterprise testing to child's play Arquillian's test continuum Complexity ( Mental Effort) Functionality Setup & configuration Unit Tests Integration Tests System Tests 16
- 17. How do we get there? 17
- 18. Skip the build! Test in-container! 18
- 19. Step 1: Liberate your tests from the build! ● Builds are laborious ● Add overhead ● Slow down test execution ● Coarse-grained packaging ● Keep it manageable! ● Well-defined “unit” ● Classpath control 19
- 20. Project lead: Andrew Lee Rubinger http://jboss.org/shrinkwrap n. a fluent API for creating archives such as JARs, WARs and EARs in Java 20
- 21. Benefits of ShrinkWrap ● Incremental IDE compilation ● Save and re-run ● Skip the build! ● Simple, fluent API ● Container deployment adapters ● Micro deployments ● Export and debugging 21
- 22. Fluent archive creation final JavaArchive archive = ShrinkWrap.create(JavaArchive.class, "slsb.jar") .addClasses(Greeter.class, GreeterBean.class); System.out.println(archive.toString(true)); Yields output: slsb.jar: /com/ /com/acme/ /com/acme/app/ /com/acme/app/ejb3/ /com/acme/app/ejb3/Greeter.class /com/acme/app/ejb3/GreeterBean.class 22
- 23. Micro deployments ● Deploy components in isolation ● Test one functional unit at a time ● Don't need to wait for full application build/startup ● Incremental integration ● Hand pick components & resources ● No “big bang” integration 23
- 24. Build, what build? @Deployment public static Archive<?> createDeployment() { return ShrinkWrap.create(JavaArchive.class) .addClasses(Greeter.class, GreeterBean.class); } 24
- 25. Skip the build! @Deployment public static Archive<?> createDeployment() { return ShrinkWrap.create(JavaArchive.class) .addPackage(TemperatureConverter.class.getPackage()) .addManifestResource(EmptyAsset.INSTANCE, "beans.xml"); } 25
- 26. Step 2: Gut the plumbing! ● Start/connect to container ● Package & deploy archive ● Inject resources ● Test logic ● Cleanup resources ● Undeploy archive ● Stop/disconnect from container 26
- 27. Project lead: Aslak Knutsen http://jboss.org/arquillian n. a container-oriented testing framework that enables developers to create portable integration tests for enterprise applications; manages the lifecycle of a container and enriches, deploys and runs tests against it 27
- 28. Arquillian project mission Make integration testing a breeze! 28
- 29. Prove it. @RunWith(Arquillian.class) public class GreeterTestCase { @Deployment public static Archive<?> createDeployment() { return ShrinkWrap.create(JavaArchive.class) .addClasses(Greeter.class, GreeterBean.class); } @EJB private Greeter greeter; @Test public void shouldBeAbleToInvokeEJB() throws Exception { assertEquals("Hello, Earthlings", greeter.greet("Earthlings")); } } 29
- 30. Prove it. @RunWith(Arquillian.class) public class GreeterTestCase { @Deployment public static Archive<?> createDeployment() { return ShrinkWrap.create(JavaArchive.class).addClass(Greeter.class) .addManifestResource(EmptyAsset.INSTANCE, "beans.xml"); } @Inject Greeter greeter; @Test public void shouldBeAbleToInvokeManagedBean() throws Exception { assertEquals("Hello, Earthlings", greeter.greet("Earthlings")); } } 30
- 31. DEMO! 31
- 32. Benefits of Arquillian ● Write less (test) code ● As much or as little “integration” as you need ● Looks like a unit test, but you're in a real environment! ● Easily lookup component to test ● No hesitation when you need a resource ● Run same test in multiple containers ● It's a learning environment 32
- 33. 33
- 34. Supported unit testing frameworks JUnit TestNG >= 4.6 >= 5.10 34
- 35. Test run modes ● In-container ● Test bundled with @Deployment archive ● Archive deployed to container ● Test runs inside container alongside application code ● Invoke application code directly (same JVM) ● As client ● @Deployment archive is test archive (unmodified) ● Archive deployed to the container ● Test stays back, runs in original test runner ● Interact as a remote client (e.g., HTTP client) 35
- 36. Container modes ● Embedded ● Same JVM as test runner ● Test protocol either local or remote ● Lifecycle controlled by Arquillian ● Remote ● Separate JVM from test runner ● Arquillian connects to running container ● Tests executed over remote protocol ● Managed ● Remote with lifecycle management 36
- 37. Supported containers ● JBoss AS 5.0 & 5.1 – Managed and remote ● JBoss AS 6 – Managed, remote and embedded ● JBoss JCA – Embedded ● GlassFish 3 – Remote and embedded ● Weld – SE embedded and EE mock embedded ● OpenWebBeans – embedded ● OpenEJB 3.1 – embedded ● OSGi – embedded ● Tomcat 6, Jetty 6.1 and Jetty 7 – embedded ● More on the way... 37
- 38. Container SPI, not just for Java EE public interface DeployableContainer { void setup(Context context, Configuration configuration); void start(Context context) throws LifecycleException; ContainerMethodExecutor deploy(Context context, Archive<?> archive) throws DeploymentException; void undeploy(Context context, Archive<?> archive) throws DeploymentException; void stop(Context context) throws LifecycleException; } 38
- 39. Power tools: test framework integration ● Test frameworks are services too! ● Extends test component model ● Examples: ● JSFUnit* ● Cobertura* ● Spock* ● Selenium* ● HTTPUnit ● DBUnit * available 39
- 40. Arquillian... ● is a container-oriented testing framework ● provides a component model for tests ● handles test infrastructure & plumbing ● ships with a set of container implementations ● provides a little bit of magic ;) 40
- 41. We're in print! LOOK INSIDE! Enterprise JavaBeans 3.1, Sixth Edition O’Reilly - Andrew Lee Rubinger, et al http://community.jboss.org/groups/oreillyejb6th 41
- 42. Get involved! ● Download us! ● ShrinkWrap - http://jboss.org/shrinkwap ● Arquillian - http://jboss.org/arquillian ● Participate with us! ● Community Space ● Fork us! ● Meet us! ● #jbosstesting channel on irc.freenode.net ● Write for us! ● Share your stories – Blog! Tweet! #arquillian 42 ● Document how it works
- 43. Emotional Ike Now available as a Hudson build plugin! 43 http://github.com/arquillian/arquillian-extensions
- 44. Q & A (or more demos) http://jboss.org/arquillian http://jboss.org/shrinkwrap
- 45. 45
- 46. 46
- 47. 47