{"id":1427,"date":"2012-06-07T10:00:00","date_gmt":"2012-06-07T10:00:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/java-ee-6-testing-part-i-ejb-3-1-embeddable-api.html"},"modified":"2012-10-22T05:42:22","modified_gmt":"2012-10-22T05:42:22","slug":"java-ee-6-testing-part-i-ejb-31","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2012\/06\/java-ee-6-testing-part-i-ejb-31.html","title":{"rendered":"Java EE 6 Testing Part I – EJB 3.1 Embeddable API"},"content":{"rendered":"
One of the most common requests we hear from Enterprise JavaBeans developers is for improved unit\/integration testing support.
\nEJB 3.1 Specification<\/a> introduced the EJB 3.1 Embeddable API for executing EJB components within a Java SE environment. <\/p>\n

Unlike traditional Java EE server-based execution, embeddable usage allows client code and its corresponding enterprise beans to run within the same JVM and class loader. This provides better support for testing, offline processing (e.g. batch), and the use of the EJB programming model in desktop applications.
\n […]
\n The embeddable EJB container provides a managed environment with support for the same basic services that exist within a Java EE runtime: injection, access to a component environment, container-managed transactions, etc. In general, enterprise bean components are unaware of the kind of managed environment in which they are running. This allows maximum reusability of enterprise components across a wide range of testing and deployment scenarios without significant rework. <\/i> <\/p>\n

Let\u2019s look at an example. <\/p>\n

Start by creating a Maven project and add the embeddable GlassFish dependency.
\nI chose to use TestNG<\/a> testing framework, but JUnit<\/a> should work just as well. <\/p>\n

<dependencies>\r\n    <dependency>\r\n        <groupId>org.glassfish.extras<\/groupId>\r\n        <artifactId>glassfish-embedded-all<\/artifactId>\r\n        <version>3.1.2<\/version>\r\n        <scope>test<\/scope>\r\n    <\/dependency>\r\n    <dependency>\r\n        <groupId>org.testng<\/groupId>\r\n        <artifactId>testng<\/artifactId>\r\n        <version>6.4<\/version>\r\n        <scope>test<\/scope>\r\n    <\/dependency>\r\n    <!--\r\n        The javaee-api is stripped of any code and is just used to\r\n        compile your application. The scope provided in Maven means\r\n        that it is used for compiling, but is also available when\r\n        testing. For this reason, the javaee-api needs to be below\r\n        the embedded Glassfish dependency. The javaee-api can actually\r\n        be omitted when the embedded Glassfish dependency is included,\r\n        but to keep your project Java-EE 6 rather than GlassFish,\r\n        specification is important.\r\n    -->\r\n    <dependency>\r\n        <groupId>javax<\/groupId>\r\n        <artifactId>javaee-api<\/artifactId>\r\n        <version>6.0<\/version>\r\n        <scope>provided<\/scope>\r\n    <\/dependency>\r\n<\/dependencies><\/pre>\n
Here\u2019s a simple Stateless<\/code> session bean:    
 
<\/div> <\/div><\/p>\n
@Stateless\r\npublic class HelloWorld {\r\n    public String hello(String message) {\r\n        return \"Hello \" + message;\r\n    }\r\n}<\/pre>\n
It exposes business methods through a no-interface view<\/a>.
\nThere is no special API it must use to be capable of embeddable execution.    <\/p>\n
Here is some test code to execute the bean in an embeddable container:    <\/p>\n
public class HelloWorldTest {\r\n    private static EJBContainer ejbContainer;\r\n\r\n    private static Context ctx;\r\n\r\n    @BeforeClass\r\n    public static void setUpClass() throws Exception {\r\n        \/\/ Instantiate an embeddable EJB container and search the\r\n        \/\/ JVM class path for eligible EJB modules or directories\r\n        ejbContainer = EJBContainer.createEJBContainer();\r\n\r\n        \/\/ Get a naming context for session bean lookups\r\n        ctx = ejbContainer.getContext();\r\n    }\r\n\r\n    @AfterClass\r\n    public static void tearDownClass() throws Exception {\r\n        \/\/ Shutdown the embeddable container\r\n        ejbContainer.close();\r\n    }\r\n\r\n    @Test\r\n    public void hello() throws NamingException {\r\n        \/\/ Retrieve a reference to the session bean using a portable\r\n        \/\/ global JNDI name\r\n        HelloWorld helloWorld = (HelloWorld)\r\n                ctx.lookup(\"java:global\/classes\/HelloWorld\");\r\n\r\n        \/\/ Do your tests\r\n        assertNotNull(helloWorld);\r\n        String expected = \"World\";\r\n        String hello = helloWorld.hello(expected);\r\n        assertNotNull(hello);\r\n        assertTrue(hello.endsWith(expected));\r\n    }\r\n}<\/pre>\n
The source code is available on GitHub<\/a> under the folder ejb31-embeddable<\/code>.    <\/p>\n
For a step by step tutorial with a JPA example take a look at Using the Embedded EJB Container to Test Enterprise Applications<\/a> from NetBeans docs.    <\/p>\n
While this new API is a step forward, I still have an issue with this approach: you are bringing the container to the test. This requires a specialized container which is different from your production environment.    <\/p>\n
In Java EE 6 Testing Part II<\/a>, I will introduce Arquillian<\/a> and ShrinkWrap<\/a>.
\nArquillian, a powerful container-oriented testing framework layered atop TestNG and JUnit, gives you the ability to create the production environment on the container of your choice and just execute tests in that environment (using the datasources, JMS destinations, and a whole lot of other configurations you expect to see in production environment). Instead of bringing your runtime to the test, Arquillian brings your test to the runtime.<\/p>\n
Related Posts<\/strong> <\/p>\n