| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.synapse.samples.framework; |
| |
| import junit.framework.TestCase; |
| import org.apache.axiom.om.OMElement; |
| import org.apache.axiom.om.OMXMLBuilderFactory; |
| import org.apache.axiom.om.OMXMLParserWrapper; |
| import org.apache.commons.io.FileUtils; |
| import org.apache.commons.io.FilenameUtils; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.apache.synapse.samples.framework.clients.MTOMSwASampleClient; |
| import org.apache.synapse.samples.framework.clients.StockQuoteSampleClient; |
| import org.apache.synapse.samples.framework.config.Axis2ClientConfiguration; |
| import org.apache.synapse.samples.framework.config.SampleConfigConstants; |
| |
| import javax.xml.namespace.QName; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| /** |
| * This is the class from which all sample tests are derived. Loads and stores necessary |
| * configuration information. Starts the mediation engine and backend server(s) before each test. |
| * Shuts down running servers after a test is complete. |
| */ |
| public abstract class SynapseTestCase extends TestCase { |
| |
| protected final Log log = LogFactory.getLog(this.getClass()); |
| |
| private int sampleId; |
| private String sampleName; |
| |
| private SynapseProcessController synapseController; |
| private List<ProcessController> backendServerControllers; |
| private Axis2ClientConfiguration clientConfig; |
| |
| protected SynapseTestCase(int sampleId) { |
| if (log.isDebugEnabled()) { |
| log.debug("Creating SynapseTestCase for test " + sampleId); |
| } |
| this.sampleId = sampleId; |
| System.setProperty("java.io.tmpdir", FilenameUtils.normalize( |
| SynapseTestUtils.getCurrentDir() + "modules/integration/target/temp")); |
| loadConfiguration(); |
| } |
| |
| private void loadConfiguration() { |
| // Parse the sample descriptor |
| OMElement sampleConfig = loadDescriptorInfoFile(); |
| if (sampleConfig == null) { |
| fail("Failed to load the sample configuration for sample: " + sampleId); |
| } |
| |
| // Verify sample ID |
| OMElement sampleIdElt = sampleConfig.getFirstChildWithName( |
| new QName(SampleConfigConstants.TAG_SAMPLE_ID)); |
| if (sampleIdElt == null || sampleIdElt.getText() == null || "".equals(sampleIdElt.getText())) { |
| fail("Sample ID not specified in the descriptor"); |
| } else if (this.sampleId != Integer.parseInt(sampleIdElt.getText())) { |
| fail("Sample ID in the descriptor does not match the current test case"); |
| } |
| |
| // Load sample name |
| OMElement sampleNameElt = sampleConfig.getFirstChildWithName( |
| new QName(SampleConfigConstants.TAG_SAMPLE_NAME)); |
| if (sampleNameElt == null || sampleNameElt.getText() == null || "".equals(sampleNameElt.getText())) { |
| fail("Sample name not specified in the descriptor"); |
| } else { |
| this.sampleName = sampleNameElt.getText(); |
| } |
| |
| // Load Synapse, backend server and client configurations |
| synapseController = initSynapseConfigInfo(sampleConfig); |
| backendServerControllers = initBackEndServersConfigInfo(sampleConfig); |
| if (backendServerControllers == null) { |
| fail("Failed to load backend server configurations for the sample " + sampleId); |
| } |
| clientConfig = initClientConfigInfo(sampleConfig); |
| |
| if (synapseController.isClusteringEnabled()) { |
| assertTrue("Could not properly configure clustering", configureClustering()); |
| } |
| } |
| |
| /** |
| * Executed before this test case. That means, this will be executed before each test. |
| * Loads all configuration info and starts the servers. |
| */ |
| public void setUp() { |
| // Print a short intro to the console, so the console output is more readable |
| String title = "Sample " + sampleId + ": " + sampleName; |
| String underline = ""; |
| for (int i = 0; i < title.length(); i++) { |
| underline += "="; |
| } |
| System.out.println("\n\n" + title); |
| System.out.println(underline); |
| |
| // Start backend servers |
| for (ProcessController controller : backendServerControllers) { |
| if (!controller.startProcess()) { |
| doCleanup(); |
| fail("Error starting the server: " + controller.getServerName()); |
| } |
| } |
| |
| // Start Synapse |
| if (!synapseController.startProcess()) { |
| doCleanup(); |
| fail("Error starting synapse server"); |
| } |
| } |
| |
| /** |
| * Executed after this test case. That means, This will be executed after each test |
| */ |
| public void tearDown() { |
| log.info("Sample " + sampleId + " is finished"); |
| doCleanup(); |
| } |
| |
| /** |
| * shutting down servers, cleaning temp files |
| */ |
| private void doCleanup() { |
| if (synapseController != null) { |
| log.debug("Stopping Synapse"); |
| synapseController.stopProcess(); |
| } |
| |
| List<ProcessController> removed = new ArrayList<ProcessController>(); |
| for (ProcessController bsc : backendServerControllers) { |
| if (bsc instanceof Axis2BackEndServerController) { |
| log.info("Stopping Server: " + bsc.getServerName()); |
| bsc.stopProcess(); |
| removed.add(bsc); |
| } |
| } |
| |
| for (ProcessController bsc : removed) { |
| backendServerControllers.remove(bsc); |
| } |
| |
| for (ProcessController bsc : backendServerControllers) { |
| log.info("Stopping Server: " + bsc.getServerName()); |
| bsc.stopProcess(); |
| } |
| |
| //cleaning up temp dir |
| try { |
| FileUtils.cleanDirectory(new File(System.getProperty("java.io.tmpdir"))); |
| } catch (IOException e) { |
| log.warn("Error while cleaning temp directory", e); |
| } |
| } |
| |
| /** |
| * Reads the specific descriptor file for the particular sample |
| * from resource directory |
| * |
| * @return true if the configuration was loaded successfully |
| */ |
| private OMElement loadDescriptorInfoFile() { |
| String sampleDescriptor = "/sample" + sampleId + ".xml"; |
| if (log.isDebugEnabled()) { |
| log.debug("Reading sample descriptor file from " + sampleDescriptor); |
| } |
| |
| try { |
| InputStream in = this.getClass().getResourceAsStream(sampleDescriptor); |
| if (in == null) { |
| fail("Cannot read sample descriptor file"); |
| } |
| OMXMLParserWrapper builder = OMXMLBuilderFactory.createOMBuilder(in); |
| return builder.getDocumentElement(); |
| } catch (Exception e) { |
| log.error("Error loading test descriptor", e); |
| return null; |
| } |
| } |
| |
| /** |
| * Reads and initializes Synapse specific configuration information from descriptor |
| * |
| * @param config Sample descriptor |
| * @return A SynapseProcessController instance |
| */ |
| private SynapseProcessController initSynapseConfigInfo(OMElement config) { |
| OMElement synapseConfig = config.getFirstChildWithName( |
| new QName(SampleConfigConstants.TAG_SYNAPSE_CONF)); |
| return new SynapseProcessController(sampleId, synapseConfig); |
| } |
| |
| /** |
| * Reads and initializes backend server specific configuration information from descriptor |
| * |
| * @param config Sample descriptor |
| * @return a List of ProcessController instances |
| */ |
| private List<ProcessController> initBackEndServersConfigInfo(OMElement config) { |
| log.debug("Initializing configuration information for backend servers..."); |
| List<ProcessController> controllers = new ArrayList<ProcessController>(); |
| OMElement backendServersConfig = config.getFirstChildWithName( |
| new QName(SampleConfigConstants.TAG_BE_SERVER_CONF)); |
| if (backendServersConfig == null) { |
| log.warn("No backend servers defined"); |
| return null; |
| } |
| |
| Iterator backendServers = backendServersConfig.getChildElements(); |
| while (backendServers.hasNext()) { |
| OMElement backendServer = (OMElement) backendServers.next(); |
| ProcessController controller = SynapseTestUtils.createController(backendServer); |
| if (controller != null) { |
| controllers.add(controller); |
| } else { |
| log.error("Unrecognized backend server configuration: " + backendServer.getLocalName()); |
| return null; |
| } |
| } |
| |
| return controllers; |
| } |
| |
| /** |
| * Reads and stores client specific configuration information from descriptor |
| * |
| * @param config Sample descriptor |
| * @return An Axis2ClientConfiguration instance |
| */ |
| private Axis2ClientConfiguration initClientConfigInfo(OMElement config) { |
| Axis2ClientConfiguration clientConfig = new Axis2ClientConfiguration(); |
| |
| String currentDir = SynapseTestUtils.getCurrentDir(); |
| clientConfig.setAxis2Xml(SynapseTestUtils.getParameter(config, |
| SampleConfigConstants.TAG_CLIENT_CONF_AXIS2_XML, |
| FilenameUtils.normalize(currentDir + SampleConfigConstants.DEFAULT_CLIENT_CONF_AXIS2_XML))); |
| clientConfig.setClientRepo(SynapseTestUtils.getParameter(config, |
| SampleConfigConstants.TAG_CLIENT_CONF_REPO, |
| FilenameUtils.normalize(currentDir + SampleConfigConstants.DEFAULT_CLIENT_CONF_REPO))); |
| return clientConfig; |
| } |
| |
| private boolean configureClustering() { |
| try { |
| String ip = SynapseTestUtils.getIPAddress(); |
| if (ip == null || ip.length() == 0) { |
| log.fatal("Could not detect an active IP address"); |
| return false; |
| } |
| log.info("Using the IP: " + ip); |
| |
| String synapseAxis2Xml = synapseController.getAxis2Xml(); |
| String axis2Config = FileUtils.readFileToString(new File(synapseAxis2Xml)); |
| String modifiedSynapseAxis2 = SynapseTestUtils.replace(axis2Config, "${replace.me}", ip); |
| File tempSynapseAxis2 = File.createTempFile("axis2Syn-", "xml"); |
| tempSynapseAxis2.deleteOnExit(); |
| FileUtils.writeStringToFile(tempSynapseAxis2, modifiedSynapseAxis2); |
| synapseController.setAxis2Xml(tempSynapseAxis2.getAbsolutePath()); |
| |
| for (ProcessController controller : backendServerControllers) { |
| if (controller instanceof Axis2BackEndServerController) { |
| Axis2BackEndServerController axis2Controller = (Axis2BackEndServerController) controller; |
| String beAxis2Xml = axis2Controller.getAxis2Xml(); |
| String beAxis2Config = FileUtils.readFileToString(new File(beAxis2Xml)); |
| String modifiedBEAxis2 = SynapseTestUtils.replace(beAxis2Config, "${replace.me}", ip); |
| File tempBEAxis2 = File.createTempFile("axis2BE-", "xml"); |
| tempBEAxis2.deleteOnExit(); |
| FileUtils.writeStringToFile(tempBEAxis2, modifiedBEAxis2); |
| axis2Controller.setAxis2Xml(tempBEAxis2.getAbsolutePath()); |
| } |
| } |
| return true; |
| |
| } catch (Exception e) { |
| log.error("Error configuring clustering", e); |
| return false; |
| } |
| } |
| |
| protected List<ProcessController> getBackendServerControllers() { |
| return backendServerControllers; |
| } |
| |
| public StockQuoteSampleClient getStockQuoteClient() { |
| return new StockQuoteSampleClient(clientConfig); |
| } |
| |
| public MTOMSwASampleClient getMTOMSwASampleClient() { |
| return new MTOMSwASampleClient(clientConfig); |
| } |
| |
| protected void assertResponseReceived(SampleClientResult result) { |
| assertTrue("Client did not receive the expected response", result.responseReceived()); |
| } |
| |
| protected Axis2BackEndServerController getAxis2Server() { |
| for (ProcessController server : backendServerControllers) { |
| if (server instanceof Axis2BackEndServerController) { |
| return (Axis2BackEndServerController) server; |
| } |
| } |
| return null; |
| } |
| } |