Test con Wildfly 8 e Netbeans

StackOverflow https://stackoverflow.com//questions/25081378

Domanda

Ho problemi a fare test wildfly sotto Netbeans e Maven.Sono in grado di lanciare l'applicazione da IDE, posso persino eseguire il debug con il debugger NetBeans, tuttavia non appena avvio i test dell'unità, ottengo il seguente errore: 

No EJBContainer provider available: no provider names had been found.
javax.ejb.EJBException
    at javax.ejb.embeddable.EJBContainer.reportError(EJBContainer.java:216)
    at javax.ejb.embeddable.EJBContainer.createEJBContainer(EJBContainer.java:146)
    at javax.ejb.embeddable.EJBContainer.createEJBContainer(EJBContainer.java:102)
    at cz.interactsys.ejb.StatefulSessionBeanTest.setUp(StatefulSessionBeanTest.java:28)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:483)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42)
    at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:27)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:300)
    at org.apache.maven.surefire.junit4.JUnit4TestSet.execute(JUnit4TestSet.java:53)
    at org.apache.maven.surefire.junit4.JUnit4Provider.executeTestSet(JUnit4Provider.java:123)
    at org.apache.maven.surefire.junit4.JUnit4Provider.invoke(JUnit4Provider.java:104)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:483)
    at org.apache.maven.surefire.util.ReflectionUtils.invokeMethodWithArray(ReflectionUtils.java:164)
    at org.apache.maven.surefire.booter.ProviderFactory$ProviderProxy.invoke(ProviderFactory.java:110)
    at org.apache.maven.surefire.booter.SurefireStarter.invokeProvider(SurefireStarter.java:175)
    at org.apache.maven.surefire.booter.SurefireStarter.runSuitesInProcessWhenForked(SurefireStarter.java:107)
    at org.apache.maven.surefire.booter.ForkedBooter.main(ForkedBooter.java:68)
.

Il codice è standard come quanto segue: 

    int numberA = 1;
    int numberB = 2;
    EJBContainer container = javax.ejb.embeddable.EJBContainer.createEJBContainer();
    MyBean instance = (MyBean) container.getContext().lookup("java:global/classes/MyBean");
    int expResult = 3;
    int result = instance.plusOne(1);
    assertEquals(expResult, result);
    container.close();
.

Grazie in anticipo.

È stato utile?

Soluzione

Il problema è che non c'è alcun ejbcontainer in Wildfly. Non sono sicuro di come questo è possibile, dato che EJBConainer dovrebbe essere lì in base alle specifiche della piattaforma. Tuttavia abbiamo bisogno di usare qualcosa di diverso ed è Arquillà. Questo testo è stato ispirato da numerosi altri articoli, Maily Questo , tuttavia la soluzione suggerita qui sta utilizzando la stessa installazione di Wildfly per i test per quanto riguarda la distribuzione regolare che sembra migliore per me. < / P >.

È necessario seguire attentamente i seguenti suggerimenti. Allora funzionerà.

Step Zero - Preparazione: Prepariamo qualcosa che possiamo usare per i test.

Facciamo un progetto regolare di Maven Javaee, I.e.: 

demoproj
demoproj-ear
demoproj-ejb
demoproj-war
.

Sto usando NetBeans, tuttavia i seguenti passaggi non dovrebbero essere molto diversi anche per altri IDES. Creiamo alcune cose come fagioli di entità, unità di persistenza e fagioli di sessione ovviamente per avere qualcosa da testare. Ho creato un'unità di persistenza demo utilizzando NetBeans, un'entità utilizzando il database e un fagiolo di sessione dall'entità.

Step One: Aggiungiamo il seguente codice in POM.XML OD Demoproj (I.e. Il progetto principale): 

<properties>
    <junit-version>4.11</junit-version>
    <arquillian-version>1.1.4.Final</arquillian-version>
    <arquillian-wildfly-version>8.1.0.Final</arquillian-wildfly-version>
    <arquillian-transaction-version>1.0.1.Final</arquillian-transaction-version>  
    <javaee-server-home>/Java/wildfly-8.1.0.Final</javaee-server-home>
</properties>        
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>${javaee-api-version}</version>
        </dependency>
        <!-- -JUNIT-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit-version}</version>
        </dependency>
        <!-- rquillian itself-->
        <dependency>
            <groupId>org.jboss.arquillian</groupId>
            <artifactId>arquillian-bom</artifactId>
            <version>${arquillian-version}</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
        <!-- this is in an extention to arquillian it is optional-->
        <dependency>
            <groupId>org.jboss.arquillian.extension</groupId>
            <artifactId>arquillian-transaction-bom</artifactId>
            <version>${arquillian-transaction-version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!-- this is container adapter for wildfly-->
        <dependency>
            <groupId>org.wildfly</groupId>
            <artifactId>wildfly-arquillian-container-embedded</artifactId>
            <version>${arquillian-wildfly-version}</version>
        </dependency>
        <!-- this is the wildfly emb.container - BUT eventually it is not a fully blown emb.container-->
        <dependency>
            <groupId>org.wildfly</groupId>
            <artifactId>wildfly-embedded</artifactId>
            <version>${arquillian-wildfly-version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>
<build>
    <pluginManagement>
        <plugins>
            <!-- compiler plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${compiler-plugin-version}</version>
                <configuration>
                    <source>${java-version}</source>
                    <target>${java-version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <!-- maven ear plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-ear-plugin</artifactId>
                <version>${ear-plugin-version}</version>
                <configuration>
                    <generateModuleId>true</generateModuleId>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <!-- ejb plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-ejb-plugin</artifactId>
                <version>${ejb-plugin-version}</version>
                <configuration>
                    <ejbVersion>${ejb-spec-version}</ejbVersion>
                </configuration>
            </plugin>
            <!-- war plugin -skinny wars mode! -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>${war-plugin-version}</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                    <packagingExcludes>WEB-INF/lib/*.jar</packagingExcludes>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                        </manifest>
                    </archive>
                    <webResources>
                        <resource>
                            <filtering>true</filtering>
                            <directory>src/main/webapp</directory>
                            <includes>
                                <include>**/web.xml</include>
                            </includes>
                        </resource>
                    </webResources>
                </configuration>
            </plugin>
            <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.17</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.8</version>
            </plugin>
        </plugins>
    </pluginManagement>
</build>
.

Step Two: Aggiungiamo quanto segue nella sezione Dipendenze di POM.XML di Demoproj-EJB: 

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>test</scope>
        <type>jar</type>
    </dependency>
    <dependency>
        <groupId>org.jboss.arquillian.junit</groupId>
        <artifactId>arquillian-junit-container</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.wildfly</groupId>
        <artifactId>wildfly-arquillian-container-embedded</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.wildfly</groupId>
        <artifactId>wildfly-embedded</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.jboss.arquillian.extension</groupId>
        <artifactId>arquillian-transaction-jta</artifactId>
        <scope>test</scope>
    </dependency>
.

Aggiungi questo nella sezione Plugins di Demoproj-EJB: 

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
                <argLine>-Dfile.encoding=UTF-8</argLine>
                <forkCount>1C</forkCount>
                <systemPropertyVariables>
                    <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
                    <jboss.home>${javaee-server-home}</jboss.home>
                </systemPropertyVariables>
                <redirectTestOutputToFile>false</redirectTestOutputToFile>
            </configuration>
        </plugin>
.

Step Tre: Creiamo l'unità di prova. Se usiamo una normale funzione IDE, otteniamo qualcosa come quanto segue: 

package com.demopack.demoproj;

import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;

public class DemoBeanLocalTest {

    public DemoBeanLocalTest() {
    }

    @Before
    public void setUp() {
    }

    @Test
    public void testBusinessMethod() {
    }

}
.

Ora dobbiamo aggiungere @RunWith(Arquillian.class) poco prima dell'intestazione della classe, è necessario rimuovere il costruttore predefinito e aggiungere il seguente codice all'interno della classe di test: 

@EJB
DemoBeanLocal demoBean;

@Deployment
public static JavaArchive createDeployment() {

    JavaArchive jar = ShrinkWrap.create(JavaArchive.class);
    jar.addAsResource("test-persistence.xml", "META-INF/persistence.xml");
    jar.addPackage("com.demopack.demoproj");
    jar.addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");

    return jar;
}
.

Allora potresti aggiungere alcuni metodi di prova come al solito. L'intera classe di test potrebbe sembrare il seguente: 

package com.demopack.demoproj;

import javax.ejb.EJB;
import junit.framework.Assert;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.asset.EmptyAsset;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(Arquillian.class)
public class DemoBeanLocalTest {

    @EJB
    DemoBeanLocal demoBean;

    @Deployment
    public static JavaArchive createDeployment() {

        JavaArchive jar = ShrinkWrap.create(JavaArchive.class);
        jar.addAsResource("test-persistence.xml", "META-INF/persistence.xml");
        jar.addPackage("com.demopack.demoproj");
        jar.addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");

        return jar;
    }

    @Before
    public void setUp() {
    }

    @Test
    public void testBusinessMethod() {

        Assert.assertEquals("test test", demoBean.businessMethod("test"));
    }

}
.

Fase quattro: Quasi fatto, ma una cosa più molto importante è lasciata: sotto Demoproj-EJB Creare la cartella src/test/resources e copiare lì persistence.xml da src/main/resources/META-INF e rinominarlo su test-persistence.xml.

Assicurati che il database sia in esecuzione, viene installato un driver valido, viene utilizzata una corretta origine dati, ecc. Nel mio caso la maggior parte dei problemi è stata causata da problemi di questo tipo.

Questo è! Ora dovresti rendere pulito e costruire su demoproj e se tutto sarà OK, è possibile utilizzare la normale funzione di test NetBeans per quanto riguarda. Divertiti!

Aggiornamento Se si preferisce utilizzare un'istanza remota (su un server remoto o un'istanza in esecuzione sulla stessa macchina), ciò che consiglio a causa di determinati guadagni di prestazione, è necessario modificare le seguenti parti di Il codice:

in Pom.XML nel progetto principale:

Scambio: 

`<artifactId>wildfly-arquillian-container-embedded</artifactId>` for
`<artifactId>wildfly-arquillian-container-remote</artifactId>`.
.

Rimuovi: 

<dependency>
    <groupId>org.wildfly</groupId>
    <artifactId>wildfly-embedded</artifactId>
    <version>${arquillian-wildfly-version}</version>
</dependency>
.

Quindi fai lo stesso in Pom.XML di Demoproj-EJB.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top