使用Chameleon，Shrinkwrap，Drone / Graphene与Arquillian进行Java EE集成测试

最新推荐文章于 2024-06-17 09:43:32 发布

dnc8371

最新推荐文章于 2024-06-17 09:43:32 发布

阅读量101

点赞数

文章标签： java spring 数据库 docker 大数据

从我以前的帖子继续在这里，我想我已经了解了Java EE和也的Arquillian，并测试了一些新的（和令人兴奋的）事，我想与大家分享。

但是，在开始之前，我想首先请您注意以下几点（这些纯粹是我的观点）：

考虑到Oracle 宣布停止对Commercial的商业支持，我想我决定看一下另一个领先的Java EE应用服务器Wildfly ，我感到非常高兴。
在上一篇文章中，我使用嵌入式glassfish进行测试。尽管还提供嵌入式Wildfly，但我个人发现使用远程应用程序服务器进行的测试是如此“真实” ，或者使我们更接近于模拟真实的生产环境。仅作为示例，如果我要测试在Wildfly 10（使用Java Mail，JMS）上运行的应用程序，当前指向数据库'xyz' ，我要做的就是解压缩所使用的相同版本的应用程序服务器在实际环境中（只需使用-test重命名），然后指向'xyz'数据库的另一个副本。

无论如何，让我们开始吧。

在这篇文章中，我将介绍以下内容：

测试场景（覆盖JAX-RS和JSR-352批处理）
非常简单的Wildfly设置
对JAX-RS和JSR-352批处理进行编程
使用变色龙设置Arquillian（包括ShrinkWrap）
设置无人机/石墨烯

该测试是要调用在远程Wildfly上运行的RESTFUL Web服务（这又将调用JSR-352批处理）。但是，与其手动进行测试（即打开浏览器或使用curl ，不如将其编码为Arquillian测试。

因此，这很简单。

安装Wildfly

在撰写本文时，我正在使用Wildfly 10 CR4。

只需将其下载到wildfly.org并解压缩即可。
首先，您需要添加用户。因此，打开一个终端并导航到<unzip location>/bin/并运行./bin/add-user.sh 。只需按照提示进行操作即可。
设置一个JAVA_HOME
首先，您需要添加用户。因此，打开一个终端并导航到<unzip location>/bin/并运行./bin/add-user.sh 。只需按照提示进行操作即可。
要运行wildfly，只需运行./bin/standalone.sh 。但是，请注意，默认情况下，Wildfly以Java EE 7 Web配置文件（ JBoss 2014 ）开头。我可能想使用JMS之类的功能，因此要启动Java EE 7 Full Profile，请执行./bin/standalone.sh --server-config=standalone-full.xml

开发JSR-352批处理

JSR-352批处理（在本文中称为“ 批处理 ”）编程模型非常广泛，但理解和使用起来非常简单。但基本上，您可以遵循读取过程写入模型，也可以遵循自己的批次模型（ Gupta 2013 ）。但是有关更多详细信息，您可以在此处参考Oracle教程。（Kannan 2013）。

在此示例中，我将引导您完成一个非常简单的读取过程写入批处理。

首先，创建一个空的beans.xml以启用CDI。
其次，您需要在META-INF下创建一个文件夹batch-jobs 。如果您使用maven ，则这将归入resources 。
在新创建的forder下，添加一个Job XML。请注意，按照惯例，批处理作业的名称就是作业JSL XML文件名，减去.xml扩展名（ Kannan 2013 ）。因此，假设我们将其testJob.xml 。

testJob.xml注释是交错的。

<?xml version="1.0" encoding="UTF-8"?>
<job id="testJob" 
     xmlns="http://xmlns.jcp.org/xml/ns/javaee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/jobXML_1_0.xsd"
     version="1.0">
    <step id="testStep">
        
        <!--
            Basically the way it works is this.
            
            A reader is executed to read an item, and then passed to the
            processor.
            
            Depending on the checkpoint-policy, a collection of processed
            items are then passed to the writer, to be written. And then
            transaction commit.
            
            Please note in this case since the checkpoint-policy is set to
            'item' and item-count="1", it means that each item processed is
            to be written and transactioni commit.
        -->
        <chunk checkpoint-policy="item" item-count="1">
            <reader ref="testBatchReader" />
            <processor ref="testBatchProcessor" />
            <writer ref="testBatchWriter" />
        </chunk>
    </step>
</job>

TestBatchReader.java 。当读者返回null时，批处理将停止处理。这是一个非常简单的示例，仅返回一个最大为100的Integer 。但是它可能比这复杂得多，例如读取文件等。

package id.co.lucyana.hr.batch;

import javax.batch.api.chunk.AbstractItemReader;
import javax.inject.Named;

@Named
public final class TestBatchReader extends AbstractItemReader {

    private int counter = 0;
    private static final int MAX_COUNTER = 100;

    @Override
    public Object readItem() throws Exception {
        while (this.counter < MAX_COUNTER) {
            ++this.counter;
            return this.counter;
        }
        return null;
    }
}

TestBatchProcessor.java 。没做什么

package id.co.lucyana.hr.batch;

import javax.batch.api.chunk.ItemProcessor;
import javax.inject.Named;

@Named
public final class TestBatchProcessor implements ItemProcessor {

    @Override
    public Object processItem(Object item) throws Exception {
        return item; // do nothing here
    }
}

TestBatchWriter.java 。同样，这可能非常复杂，例如写入基础数据存储区等。

package id.co.lucyana.hr.batch;

import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.batch.api.chunk.AbstractItemWriter;
import javax.inject.Named;

@Named
public final class TestBatchWriter extends AbstractItemWriter {

    @Override
    public void writeItems(List items) throws Exception {
        Logger.getLogger(TestBatchWriter.class.getName()).log(Level.INFO, items.toString());
    }
}

这是用于您的批处理编程。现在让我们从JAX-RS开始，以触发Batch运行。

开发一个宁静的Web服务

JAX-RS已经有一段时间了，所以我不会为您带来任何细节。但是，基本上我们要实现的就是能够调用Restful Web服务，并将作业名称作为参数来触发批处理。

这是ApplicationPath

package id.co.lucyana.hr.util;

import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;

@ApplicationPath(value = "resources")
public class ApplicationConfig extends Application {
}

并且，这是JAX-RS端点，接收作业名称作为参数

package id.co.lucyana.hr.batch;

import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.batch.operations.JobSecurityException;
import javax.batch.operations.JobStartException;
import javax.batch.runtime.BatchRuntime;
import javax.ejb.LocalBean;
import javax.ejb.Singleton;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;

@Singleton
@LocalBean
@Path(value = "batch")
public class BatchManager {

    @Path(value = "start")
    @GET
    @Produces(value = "application/json")
    public long start(@QueryParam("job") String job) {
        Logger.getLogger(BatchManager.class.getName()).log(Level.INFO, 
                BatchRuntime.getJobOperator().getJobNames().toString());
        try {
            return BatchRuntime.getJobOperator().start(job, new Properties());
        } catch (JobStartException | JobSecurityException e) {
            Logger.getLogger(BatchManager.class.getName()).log(
                    Level.SEVERE, e.getMessage(), e);
            return -1l;
        }
    }
}

好吧，现在深吸一口气……然后进行测试！！！

设置Arquillian，Chameleon，石墨烯，无人机，硒

在完成所有这些开发之后，现在该测试我们编写的内容了，我们将在实际运行的应用程序服务器上对其进行测试。

我们要做的第一件事是设置Arquillian / Chameleon

如果您看一下我以前的文章，提到那里的pom.xml ，您可能会注意到，有很多有关散布在其中的容器的信息，例如org.jboss.arquillian.container等。Chameleon隐藏了这些信息，使在容器之间移动变得如此容易（ Knutsen 2015 ）。

因此，对我的pom.xml的更改如下。

<?xml version="1.0" encoding="UTF-8"?>
<!-- omitted -->

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.jboss.arquillian</groupId>
                <artifactId>arquillian-bom</artifactId>
                <version>1.1.8.Final</version>
                <scope>import</scope>
                <type>pom</type>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.jboss.arquillian</groupId>
            <artifactId>arquillian-bom</artifactId>
            <version>1.1.9.Final</version>
            <type>pom</type>
        </dependency>
        <dependency>
            <groupId>org.jboss.arquillian.junit</groupId>
            <artifactId>arquillian-junit-container</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.arquillian.container</groupId>
            <artifactId>arquillian-container-chameleon</artifactId>
            <version>1.0.0.Alpha5</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

<!-- omitted -->

并按以下方式配置arquillian.xml （如果使用Maven，则位于test/resources下）：

<?xml version="1.0" encoding="UTF-8"?>
<arquillian xmlns="http://jboss.org/schema/arquillian"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://jboss.org/schema/arquillian http://jboss.org/schema/arquillian/arquillian_1_0.xsd">
    <defaultProtocol type="Servlet 3.0" />

    <container qualifier="wildfly" default="true">
        <configuration>
            <property name="chameleonTarget">wildfly:10.0.0.CR4:remote</property>
            <property name="username"><!-- your username goes here --></property>
            <property name="password"><!-- your password goes here --></property>
        </configuration>
    </container>
</arquillian>

现在，记住我们试图模拟的是，好像用户输入一个URL来调用JAX-RS Web服务，并传递一个作业名称来启动批处理作业。但是，我们希望将其编码为JUnit测试。为此，我们将使用石墨烯，无人机和硒的组合。您可以在此处阅读有关它们的更多详细信息。但基本上，这些技术是Arquillian测试平台的一部分，专门用于Web UI测试。

首先，我们需要修改pom.xml并添加以下内容：

<!-- omitted -->
    <dependencyManagement>
        <dependencies>
            <!-- omitted -->
            <dependency>
                <groupId>org.jboss.arquillian.selenium</groupId>
                <artifactId>selenium-bom</artifactId>
                <version>2.43.1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>       
        <!-- Omitted -->
        <dependency>
            <groupId>org.jboss.arquillian.graphene</groupId>
            <artifactId>graphene-webdriver</artifactId>
            <version>2.0.3.Final</version>
            <type>pom</type>
            <scope>test</scope>
        </dependency>
<!-- omitted -->

并在我们的arquillian.xml添加代码段。

<?xml version="1.0" encoding="UTF-8"?>
    <!-- omitted -->
    <extension qualifier="webdriver">
       <!--<property name="browser">firefox</property>-->
       <property name="remoteReusable">false</property>
   </extension>
</arquillian>

注意：我无法使“ Firefox”正常工作。 因此，默认情况下为'htmlUnit' 。

一切都很好，最后一部分是编写实际的Arquillian测试。

编写Arquillian测试用例

首先，我需要分享。那就是将应用程序打包为EAR。我尝试将其部署为（EJB）JAR，JAX-RS不起作用，然后仅作为WAR，Batch不起作用。因此，出于该测试的目的，我以EAR的身份进行了部署，并且所有人似乎都很高兴（ Nozaki 2015 ）。

因此，让我们编写Arquillian测试代码。评论交错。

package id.co.lucyana.hr.batch;

import id.co.lucyana.hr.util.ApplicationConfig;
import java.net.URL;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.container.test.api.RunAsClient;
import org.jboss.arquillian.drone.api.annotation.Drone;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.arquillian.test.api.ArquillianResource;
import org.jboss.shrinkwrap.api.Archive;
import org.jboss.shrinkwrap.api.ArchivePaths;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.EnterpriseArchive;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.jboss.shrinkwrap.api.spec.WebArchive;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.openqa.selenium.WebDriver;

@RunWith(Arquillian.class)
public class BatchManagerTest {

    @Drone
    private WebDriver driver;

    @Deployment
    public static Archive<?> createTestArchive() {
        // just add classes required in your test
        final JavaArchive ejbJar = ShrinkWrap.create(JavaArchive.class, "ejb-jar.jar")
                .addClass(ApplicationConfig.class)
                .addClass(BatchManager.class)
                .addClass(TestBatchReader.class)
                .addClass(TestBatchProcessor.class)
                .addClass(TestBatchWriter.class)
                .addAsManifestResource("test-persistence.xml",
                        ArchivePaths.create("persistence.xml"))
                .addAsManifestResource("META-INF/beans.xml", 
                        ArchivePaths.create("beans.xml"))
                .addAsManifestResource("batch-jobs/testJob.xml")
                .addAsResource("ValidationMessages.properties");

        /*
         * Embedding war package which contains the test class is needed
         * So that Arquillian can invoke test class through its servlet
         * test runner
         */
        final WebArchive testWar = ShrinkWrap.create(
                WebArchive.class, "test.war").addClass(BatchManagerTest.class);
        
        final EnterpriseArchive ear = ShrinkWrap.create(EnterpriseArchive.class)
                .setApplicationXML("test-application.xml")
                .addAsModule(ejbJar)
                .addAsModule(testWar);
        return ear;
    }

    @Before
    public void beforeEachTest() {
        this.driver.manage().deleteAllCookies();
    }
    
    /*
     * So that we do not hard-code the URL, simply use @ArquillianResource
     */
    @Test
    @RunAsClient
    public void shouldBeAble(@ArquillianResource URL url) {
        this.driver.get(url.toString() + "resources/batch/start?job=testJob");
        String pageSource = this.driver.getPageSource();
        System.out.println(pageSource);
        Assert.assertTrue(true);
    }
}

请注意@ArquillianResource的使用，它使我们不必对应用程序URL进行硬编码（ Knutsen 2012 ）。

结果

是的！就是这样了。确保已启动并运行Wildfly，现在可以运行测试了。 Shrinkwrap将打包您的EAR，然后Arquillian / Chameleon将其远程部署到正在运行的Wildfly服务器，然后作为客户端 ，Drone / Graphene / Selenium将调用URL来运行名为testJob的批处理。

以下是其余结果的摘要：

18:07:00,585 INFO  [org.jboss.as.server] (management-handler-thread - 2) WFLYSRV0010: Deployed "a3ee3dad-d71c-41b0-9f57-9ae6e7ffe859.ear" (runtime-name : "a3ee3dad-d71c-41b0-9f57-9ae6e7ffe859.ear")
18:07:06,137 INFO  [id.co.lucyana.hr.batch.BatchManager] (default task-1) []
18:07:06,332 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [1]
18:07:06,333 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [2]
18:07:06,333 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [3]
18:07:06,334 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [4]
18:07:06,334 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [5]
18:07:06,334 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [6]
18:07:06,334 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [7]
18:07:06,335 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [8]
18:07:06,335 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [9]
18:07:06,335 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [10]
18:07:06,335 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [11]
18:07:06,336 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [12]
18:07:06,336 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [13]
18:07:06,336 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [14]
18:07:06,336 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [15]
18:07:06,337 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [16]
18:07:06,337 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [17]
18:07:06,337 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [18]
18:07:06,337 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [19]
18:07:06,338 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [20]
18:07:06,338 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [21]
18:07:06,338 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [22]
18:07:06,338 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [23]
18:07:06,339 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [24]
18:07:06,339 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [25]
18:07:06,339 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [26]
18:07:06,339 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [27]
18:07:06,340 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [28]
18:07:06,340 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [29]
18:07:06,340 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [30]
18:07:06,340 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [31]
18:07:06,341 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [32]
18:07:06,341 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [33]
18:07:06,341 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [34]
18:07:06,341 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [35]
18:07:06,341 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [36]
18:07:06,342 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [37]
18:07:06,342 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [38]
18:07:06,342 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [39]
18:07:06,343 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [40]
18:07:06,343 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [41]
18:07:06,343 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [42]
18:07:06,344 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [43]
18:07:06,344 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [44]
18:07:06,344 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [45]
18:07:06,345 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [46]
18:07:06,345 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [47]
18:07:06,345 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [48]
18:07:06,345 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [49]
18:07:06,346 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [50]
18:07:06,346 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [51]
18:07:06,346 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [52]
18:07:06,347 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [53]
18:07:06,347 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [54]
18:07:06,347 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [55]
18:07:06,347 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [56]
18:07:06,348 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [57]
18:07:06,348 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [58]
18:07:06,348 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [59]
18:07:06,348 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [60]
18:07:06,349 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [61]
18:07:06,349 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [62]
18:07:06,349 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [63]
18:07:06,349 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [64]
18:07:06,349 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [65]
18:07:06,350 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [66]
18:07:06,350 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [67]
18:07:06,350 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [68]
18:07:06,350 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [69]
18:07:06,350 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [70]
18:07:06,351 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [71]
18:07:06,351 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [72]
18:07:06,351 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [73]
18:07:06,351 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [74]
18:07:06,352 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [75]
18:07:06,352 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [76]
18:07:06,352 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [77]
18:07:06,352 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [78]
18:07:06,352 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [79]
18:07:06,352 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [80]
18:07:06,353 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [81]
18:07:06,353 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [82]
18:07:06,353 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [83]
18:07:06,353 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [84]
18:07:06,353 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [85]
18:07:06,354 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [86]
18:07:06,354 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [87]
18:07:06,354 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [88]
18:07:06,354 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [89]
18:07:06,354 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [90]
18:07:06,355 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [91]
18:07:06,355 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [92]
18:07:06,355 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [93]
18:07:06,355 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [94]
18:07:06,356 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [95]
18:07:06,356 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [96]
18:07:06,356 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [97]
18:07:06,357 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [98]
18:07:06,357 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [99]
18:07:06,357 INFO  [id.co.lucyana.hr.batch.TestBatchWriter] (Batch Thread - 1) [100]
18:07:06,885 INFO  [org.wildfly.extension.undertow] (ServerService Thread Pool -- 72) WFLYUT0022: Unregistered web context: /test

资源资源

Allen等人，2014年， “使用无人机和石墨烯进行功能测试” ，红帽公司，2015年11月23日访问
Gupta，A，2013年， “ Java EE 7中的批处理应用程序–理解JSR 352概念：TOTD＃192” ，Oracle.com，2015年11月10日访问
JBoss，2014年， “入门指南– Wildfly 8” ，JBoss.org，2015年11月10日访问
男，Kannan，2013年， “ Java EE 7.0中的批处理概述” ，Oracle.com，2015年11月10日访问
Knutsen，A，2012， “在服务器上运行测试时， @ ArquillianResource java.net.URL” ，JBoss Developer，2015年11月23日访问
纳特森（ Knutsen），A，2015年， “ Arquillian Blog：Arquillian Container Chameleon 1.0.0.Alpha6 Released” ，红帽公司，2015年11月23日访问
Nozaki，K，2015年， “ Arquillian EJB-JAR / EAR测试示例” ，Kohei Nozaki的博客，2015年11月23日访问
Oracle，2013年， “ Java EE和GlassFish Server路线图更新” ，Oracle.com，2015年11月10日访问

翻译自: https://www.javacodegeeks.com/2015/11/java-ee-integration-testing-arquillian-using-chameleon-shrinkwrap-dronegraphene.html

dnc8371

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
使用Chameleon，Shrinkwrap，Drone / Graphene与Arquillian进行Java EE集成测试

从我以前的帖子继续在这里，我想我已经了解了Java EE和也的Arquillian，并测试了一些新的（和令人兴奋的）事，我想与大家分享。但是，在开始之前，我想首先请您注意以下几点（这些纯粹是我的观点）：考虑到Oracle 宣布停止对Commercial的商业支持，我想我决定看一下另一个领先的Java EE应用服务器Wildfly ，我感到非常高兴。在上一篇文章中，我使用...
复制链接

扫一扫