Java SwitchYardTestKit类代码示例

import org.switchyard.test.SwitchYardTestKit; //导入依赖的package包/类
@Override
@Test
public void testDeployment() throws Exception {
    ConnectionFactory cf = new ActiveMQConnectionFactory(AMQ_USER, AMQ_PASSWD, AMQ_BROKER_URL);
    Connection conn = cf.createConnection();

    try {
        Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
        final MessageProducer producer = session.createProducer(session.createQueue(REQUEST_QUEUE));
        final MessageConsumer consumer = session.createConsumer(session.createQueue(REPLY_QUEUE));
        conn.start();

        producer.send(session.createObjectMessage(INPUT));

        Message message = consumer.receive(3000);
        String reply = ((TextMessage)message).getText();
        SwitchYardTestKit.compareXMLToString(reply, EXPECTED_REPLY);
    } finally {
        conn.close();
    }
}
 

import org.switchyard.test.SwitchYardTestKit; //导入依赖的package包/类
@Test
public void testJmsBinding() throws Exception {
    HornetQMixIn hqMixIn = new HornetQMixIn(false)
                                .setUser(ResourceDeployer.USER)
                                .setPassword(ResourceDeployer.PASSWD);
    hqMixIn.initialize();
    
    Session session = null;
    MessageProducer producer = null;
    MessageConsumer consumer = null;
    try {
        session = hqMixIn.createJMSSession();
        producer = session.createProducer(HornetQMixIn.getJMSQueue(REQUEST_QUEUE));
        Message message = hqMixIn.createJMSMessage(INPUT);
        producer.send(message);

        consumer = session.createConsumer(HornetQMixIn.getJMSQueue(REPLY_QUEUE));
        message = consumer.receive(3000);
        String reply = hqMixIn.readStringFromJMSMessage(message);
        SwitchYardTestKit.compareXMLToString(reply, EXPECTED_REPLY);
    } finally {
        hqMixIn.uninitialize();
    }
}
 

import org.switchyard.test.SwitchYardTestKit; //导入依赖的package包/类
@BeforeClass
public static void setup() {
    namingMixIn = new NamingMixIn();
    transactionMixIn = new TransactionMixIn();
    cdiMixIn = new CDIMixIn();
    myTxMixInParticipant = new MyTransactionMixInParticipant(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            _transactionMixInParticipantInvoked = true;
            return null;
        }
    });
    List<TestMixIn> mixins = new ArrayList<TestMixIn>(Arrays.<TestMixIn>asList(namingMixIn,transactionMixIn,cdiMixIn,myTxMixInParticipant));
    SwitchYardTestKit testkit = mock(SwitchYardTestKit.class);
    when(testkit.getMixIns()).thenReturn(mixins);
    namingMixIn.setTestKit(testkit);
    transactionMixIn.setTestKit(testkit);
    cdiMixIn.setTestKit(testkit);
    myTxMixInParticipant.setTestKit(testkit);
    namingMixIn.initialize();
    transactionMixIn.initialize();
    cdiMixIn.initialize();
    myTxMixInParticipant.initialize();
}
 

import org.switchyard.test.SwitchYardTestKit; //导入依赖的package包/类
/**
 * Send a message to HelloRequestQueue and receive from HelloResponseQueue.
 */
@Test
public void testHelloService() throws Exception {
    Session session = _hqMixIn.getJMSSession();
    MessageProducer producer = session.createProducer(HornetQMixIn.getJMSQueue(REQUEST_NAME));
    Message message = _hqMixIn.createJMSMessage(createPayload(NAME));
    producer.send(message);

    MessageConsumer consumer = session.createConsumer(HornetQMixIn.getJMSQueue(REPLY_NAME));
    message = consumer.receive(3000);
    String reply = _hqMixIn.readStringFromJMSMessage(message);
    SwitchYardTestKit.compareXMLToString(reply, createExpectedReply(NAME));
}
 

import org.switchyard.test.SwitchYardTestKit; //导入依赖的package包/类
@org.junit.Before
public void init() {
	try {
		_testKit = new SwitchYardTestKit(this);
		_testKit.start();
	} catch(Exception e) {
		e.printStackTrace();
		fail("Unable to initialize testkit: "+ e);
	}
}
 

import org.switchyard.test.SwitchYardTestKit; //导入依赖的package包/类
@org.junit.Before
public void init() {
	try {
		_testKit = new SwitchYardTestKit(this);
		_testKit.start();
	} catch(Exception e) {
		fail("Unable to initialize testkit");
	}
}
 

import org.switchyard.test.SwitchYardTestKit; //导入依赖的package包/类
/**
 * This Quickstart test exclusively uses Netty server due to buggy JDK HttpServer.
 * See https://issues.jboss.org/browse/RESTEASY-734
 */
@Test
public void orderServiceRESTEndpoint() throws Exception {

    // Create our inventory
    String response = null;
    response = http.sendString(BASE_URL + "/inventory/create", "", HTTPMixIn.HTTP_OPTIONS);
    Assert.assertEquals(SUCCESS, response);
    /* WarehouseResource warehouseProxy = ProxyFactory.create(WarehouseResource.class, BASE_URL);
    warehouseProxy.addItem(new Item(1, "Hydrogen Atom - No, we are not kidding!"));
    warehouseProxy.addItem(new Item(2, "Handcrafted Copper Plate"));
    warehouseProxy.addItem(new Item(3, "Einstein's Bust - Talks about your future :)"));
    warehouseProxy.addItem(new Item(4, "Time Machine"));*/

    // Create an order
    response = http.sendString(BASE_URL + "/order", "", HTTPMixIn.HTTP_POST);

    SwitchYardTestKit.compareXMLToString(response, ORDER);

    // Add a new item or update order
    response = http.sendString(BASE_URL + "/order/item", ORDER1, HTTPMixIn.HTTP_PUT);
    Assert.assertEquals(SUCCESS, response);

    // Add some more items or update order
    response = http.sendString(BASE_URL + "/order/item", ORDER2, HTTPMixIn.HTTP_PUT);
    Assert.assertEquals(SUCCESS, response);

    // Look at our order
    response = http.sendString(BASE_URL + "/order/1", "", HTTPMixIn.HTTP_GET);
    SwitchYardTestKit.compareXMLToString(response, ORDER3);

    // Delete the first item
    response = http.sendString(BASE_URL + "/order/1:1", "", HTTPMixIn.HTTP_DELETE);
    Assert.assertEquals(SUCCESS, response);

    // Try to delete item with wrong composite ID
    int status = http.sendStringAndGetStatus(BASE_URL + "/order/1", "", HTTPMixIn.HTTP_DELETE);
    Assert.assertEquals(400, status);

    // Look at our order
    response = http.sendString(BASE_URL + "/order/1", "", HTTPMixIn.HTTP_GET);
    SwitchYardTestKit.compareXMLToString(response, ORDER4);

    // Update item descriptions in our inventory
    response = http.sendString(BASE_URL + "/inventory/update", "", HTTPMixIn.HTTP_OPTIONS);
    Assert.assertEquals(SUCCESS, response);

    // Look at our order
    response = http.sendString(BASE_URL + "/order/1", "", HTTPMixIn.HTTP_GET);
    SwitchYardTestKit.compareXMLToString(response, ORDER5);

    // Look at non existing order
    status = http.sendStringAndGetStatus(BASE_URL + "/order/" + Integer.MAX_VALUE, "", HTTPMixIn.HTTP_GET);
    Assert.assertEquals(404, status);

    // Get item
    status = http.sendStringAndGetStatus(BASE_URL + "/warehouse/get/26", "", HTTPMixIn.HTTP_GET);
    Assert.assertEquals(404, status);

    // Destroy our inventory
    response = http.sendString(BASE_URL + "/inventory/remove", "", HTTPMixIn.HTTP_OPTIONS);
    Assert.assertEquals(SUCCESS, response);

    // Test 404 returned with complete url
    response = http.sendString(BASE_URL + "/order/404", "", HTTPMixIn.HTTP_GET);
    Assert.assertTrue(response.contains("Error at [http://localhost:8081/404/404/]"));
}
 

import org.switchyard.test.SwitchYardTestKit; //导入依赖的package包/类
@Override
public void setTestKit(SwitchYardTestKit kit) {
    this._kit = kit;
}
 

import org.switchyard.test.SwitchYardTestKit; //导入依赖的package包/类
/**
 * Get the test kit instance associated with the test mixin.
 * @return The test kit instance instance.
 */
public SwitchYardTestKit getTestKit() {
    return _kit;
}
 

import org.switchyard.test.SwitchYardTestKit; //导入依赖的package包/类
/**
 * POST the specified String request to the specified HTTP endpoint and perform an XML compare
 * between the HTTP response and the specified expected response String.
 * @param endpointURL The HTTP endpoint URL.
 * @param request The classpath resource to be posted to the endpoint.
 * @param expectedResponse The String to use to perform the XML test on the response.
 * @return The HTTP response payload.
 */
public String postStringAndTestXML(String endpointURL, String request, String expectedResponse) {
    String response = postString(endpointURL, request);
    SwitchYardTestKit.compareXMLToString(response, expectedResponse);
    return response;
}