Explicite Local EJB not injected with Arquillian

Question

I use Arquillian to test an stateless session bean that has an explicit local and remote interface. But in the test Arquillian does not \"inject\" anything in a field that has t

Answer 1

Try to change TestServiceImpl->TestServiceBean it looks that embedded glassfish have specific requirements to bean name

Answer 2

You could use one of the following:

• Add a beans.xml file to the deployment:

  return ShrinkWrap.create(JavaArchive.class, "test.jar")
                  .addClasses(
                          TestServiceLocal.class,
                          TestServiceRemote.class,
                          TestServiceImpl.class)
                  .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
  

  This enables the CDITestEnricher of Arquillian, which is far more capable than the EJBTestEnricher. It can handle @Inject annotations (obviously), but also @Resource and @EJB annotations as well (see the section on Resources injection in the CDI spec). The container then treats both the @EJB annotated fields in your test class instance as injection points and injects the dependencies.

• Specify the mappedName property for the @EJB annotation for the field with the portable JNDI name of the deployed bean. In your case, it will look something like:

  @EJB(mappedName="java:global/test/TestServiceImpl!com.acme.TestServiceLocal")
  private TestServiceLocal testServiceLocal;
  

  You'll need to ensure that the portable JNDI name is the same as that the one generated for your deployment. I've merely specified the one that was generated for my "com.acme.TestServiceLocal" interface.

Answer 3

In addition to the answers you must also ensure you use the correct @Deployment setting is correct. To inject locally you must ensure you have @Deployment(testable=true) (note that this is the default).

From Aquillian docs:

In-container mode: @Deployment(testable = true)

As we mentioned above, we need to repackage your @Deployment, adding some Arquillian support classes, to run in-container. This gives us the ability to communicate with the test, enrich the test and run the test remotely. In this mode, the test executes in the remote container; Arquillian uses this mode by default.

See the Complete Protocol Reference for an overview of the expected output of the packaging process when you provide a @Deployment.

Client mode: @Deployment(testable = false)

Now this mode is the easy part. As opposed to in-container mode which repackages and overrides the test execution, the as-client mode does as little as possible. It does not repackage your @Deployment nor does it forward the test execution to a remote server. Your test case is running in your JVM as expected and you're free to test the container from the outside, as your clients see it. The only thing Arquillian does is to control the lifecycle of your @Deployment.

Here is an example calling a Servlet using the as client mode.

This does not help the OP (they had the correct settings) but I hope it helps those arriving from Google, as I did.