001: /**
002: * Licensed to the Apache Software Foundation (ASF) under one
003: * or more contributor license agreements. See the NOTICE file
004: * distributed with this work for additional information
005: * regarding copyright ownership. The ASF licenses this file
006: * to you under the Apache License, Version 2.0 (the
007: * "License"); you may not use this file except in compliance
008: * with the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing,
013: * software distributed under the License is distributed on an
014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015: * KIND, either express or implied. See the License for the
016: * specific language governing permissions and limitations
017: * under the License.
018: */package org.apache.cxf.systest.coloc;
019:
020: import javax.xml.namespace.QName;
021: import javax.xml.ws.BindingProvider;
022: import javax.xml.ws.Holder;
023: import javax.xml.ws.WebServiceException;
024:
025: import static junit.framework.Assert.assertEquals;
026:
027: import org.apache.cxf.message.Message;
028: import org.apache.headers.coloc.types.FaultDetailT;
029: import org.apache.headers.coloc.types.HeaderInfo;
030: import org.apache.headers.coloc.types.InHeaderResponseT;
031: import org.apache.headers.coloc.types.InHeaderT;
032: import org.apache.headers.coloc.types.InoutHeaderResponseT;
033: import org.apache.headers.coloc.types.InoutHeaderT;
034: import org.apache.headers.coloc.types.OutHeaderResponseT;
035: import org.apache.headers.coloc.types.OutHeaderT;
036: import org.apache.headers.coloc.types.PingMeResponseT;
037: import org.apache.headers.coloc.types.PingMeT;
038: import org.apache.headers.rpc_lit.HeaderTester;
039: import org.apache.headers.rpc_lit.PingMeFault;
040:
041: import org.junit.Before; //import org.junit.Ignore;
042: import org.junit.Test;
043:
044: /**
045: * This class invokes the service described in /wsdl/header_rpc_lit.wsdl.
046: * This WSDL contains operations with in-out parameters.
047: * It sets up the a client in "testRouter()" to send requests to the
048: * router which is listening on port 9001 (SOAP/HTTP).
049: * The subclass defines where CXF configuration and the
050: * target server (transport, etc).
051: *
052: */
053: public abstract class AbstractHeaderServiceRpcLitTest extends
054: AbstractColocTest {
055: static final QName SERVICE_NAME = new QName(
056: "http://apache.org/headers/rpc_lit", "SOAPHeaderService");
057: static final QName PORT_NAME = new QName(
058: "http://apache.org/headers/rpc_lit", "SoapPort");
059: static final String WSDL_LOCATION = "/wsdl/header_rpc_lit.wsdl";
060:
061: private HeaderTester port;
062:
063: @Before
064: public void setUp() throws Exception {
065: super .setUp();
066: port = getPort(getServiceQname(), getPortQName(),
067: getWsdlLocation(), HeaderTester.class);
068: }
069:
070: @Test
071: public void testTwoWayOperation() {
072: for (int idx = 0; idx < 2; idx++) {
073: verifyTwoWay(port);
074: }
075: }
076:
077: @Test
078: public void testInHeaderParts() {
079: for (int idx = 0; idx < 2; idx++) {
080: verifyInHeaderParts(port);
081: }
082: }
083:
084: @Test
085: public void testInOutHeaderParts() {
086: for (int idx = 0; idx < 2; idx++) {
087: verifyInOutHeaderParts(port);
088: }
089: }
090:
091: @Test
092: public void testOutHeaderParts() {
093: for (int idx = 0; idx < 2; idx++) {
094: verifyOutHeaderParts(port);
095: }
096: }
097:
098: @Test
099: public void testFault() {
100: for (int idx = 0; idx < 2; idx++) {
101: verifyFaults(port);
102: }
103: }
104:
105: @Test
106: public void testAll() {
107: for (int idx = 0; idx < 2; idx++) {
108: verifyTwoWay(port);
109: verifyInHeaderParts(port);
110: verifyInOutHeaderParts(port);
111: verifyOutHeaderParts(port);
112: verifyFaults(port);
113: }
114: }
115:
116: public void verifyTwoWay(HeaderTester ht) {
117: getLogger().debug("Client: calling pingMe");
118: PingMeT in = new PingMeT();
119: try {
120: in.setFaultType("ABCD");
121: PingMeResponseT ret = ht.pingMe(in);
122: assertNotNull(ret);
123: } catch (Exception ex) {
124: fail("Should not throw any exception");
125: }
126: }
127:
128: protected void verifyInHeaderParts(HeaderTester ht) {
129: getLogger().debug("Client: calling inHeader");
130: InHeaderT inHeader = new InHeaderT();
131: inHeader.setRequestType(HeaderTesterUtil.IN_REQUEST_TYPE);
132:
133: HeaderInfo headerInfo = new HeaderInfo();
134: headerInfo.setMessage(HeaderTesterUtil.IN_MESSAGE);
135: headerInfo.setOriginator(HeaderTesterUtil.IN_ORIGINATOR);
136:
137: InHeaderResponseT inHeaderResponse = ht.inHeader(inHeader,
138: headerInfo);
139: assertEquals(HeaderTesterUtil.OUT_RESPONSE_TYPE,
140: inHeaderResponse.getResponseType());
141: }
142:
143: protected void verifyInOutHeaderParts(HeaderTester ht) {
144: getLogger().debug("Client: calling inoutHeader");
145: InoutHeaderT inoutHeader = new InoutHeaderT();
146: inoutHeader
147: .setRequestType(HeaderTesterUtil.INOUT_REQUEST_TYPE_IN);
148:
149: HeaderInfo headerInfo = new HeaderInfo();
150: headerInfo.setMessage(HeaderTesterUtil.INOUT_MESSAGE_IN);
151: headerInfo.setOriginator(HeaderTesterUtil.INOUT_ORIGINATOR_IN);
152:
153: Holder<HeaderInfo> holder = new Holder<HeaderInfo>();
154: holder.value = headerInfo;
155: InoutHeaderResponseT inoutHeaderResponse = ht.inoutHeader(
156: inoutHeader, holder);
157:
158: assertEquals(HeaderTesterUtil.INOUT_REQUEST_TYPE_OUT,
159: inoutHeaderResponse.getResponseType());
160: assertNotSame(HeaderTesterUtil.INOUT_REQUEST_TYPE_OUT,
161: inoutHeader.getRequestType());
162: assertEquals(HeaderTesterUtil.INOUT_MESSAGE_OUT, holder.value
163: .getMessage());
164: assertEquals(HeaderTesterUtil.INOUT_ORIGINATOR_OUT,
165: holder.value.getOriginator());
166:
167: }
168:
169: protected void verifyOutHeaderParts(HeaderTester ht) {
170: getLogger().debug("Client: calling outHeader");
171: OutHeaderT outHeader = new OutHeaderT();
172: outHeader.setRequestType(HeaderTesterUtil.OUT_REQUEST_TYPE);
173:
174: OutHeaderResponseT theResponse = new OutHeaderResponseT();
175: theResponse.setResponseType("bogus");
176: Holder<OutHeaderResponseT> respHolder = new Holder<OutHeaderResponseT>();
177: respHolder.value = theResponse;
178:
179: Holder<HeaderInfo> holder = new Holder<HeaderInfo>();
180: HeaderInfo headerInfo = new HeaderInfo();
181: headerInfo.setMessage(HeaderTesterUtil.OUT_MESSAGE_IN);
182: headerInfo.setOriginator(HeaderTesterUtil.OUT_ORIGINATOR_IN);
183: holder.value = headerInfo;
184:
185: ht.outHeader(outHeader, respHolder, holder);
186: assertEquals(HeaderTesterUtil.OUT_MESSAGE_OUT, holder.value
187: .getMessage());
188: assertEquals(HeaderTesterUtil.OUT_ORIGINATOR_OUT, holder.value
189: .getOriginator());
190: assertEquals(HeaderTesterUtil.OUT_RESPONSE_TYPE,
191: respHolder.value.getResponseType());
192: }
193:
194: public void verifyFaults(HeaderTester ht) {
195: getLogger().debug("Client: calling pingMe user fault");
196: PingMeT in = new PingMeT();
197:
198: try {
199: in.setFaultType("USER");
200: ht.pingMe(in);
201: fail("Should throw a PingeMeFault exception");
202: } catch (PingMeFault pmf) {
203: FaultDetailT detail = pmf.getFaultInfo();
204: assertNotNull(detail);
205: assertEquals("Major Version should be 1", (short) 1, detail
206: .getMajor());
207: assertEquals("Minor Version should be 2", (short) 2, detail
208: .getMinor());
209: if (isFaultCodeCheckEnabled()) {
210: verifyFaultCode(port);
211: }
212: }
213:
214: getLogger().debug("Client: calling pingMe Cxf System Fault");
215: try {
216: in.setFaultType("SYSTEM");
217: ht.pingMe(in);
218: fail("Should throw a CXF Fault exception");
219: } catch (WebServiceException fault) {
220: assertFalse(-1 == fault.getMessage().lastIndexOf(
221: HeaderTesterUtil.EX_STRING));
222: if (isFaultCodeCheckEnabled()) {
223: verifyFaultCode(port);
224: }
225: } catch (PingMeFault pmf) {
226: fail("Should not receive PingMefault");
227: }
228:
229: getLogger().debug(
230: "Client: calling pingMe java runtime exception");
231: try {
232: in.setFaultType("RUNTIME");
233: ht.pingMe(in);
234: fail("Should throw a CXF Fault exception");
235: } catch (WebServiceException fault) {
236: assertFalse(-1 == fault.getMessage().lastIndexOf(
237: HeaderTesterUtil.EX_STRING));
238: if (isFaultCodeCheckEnabled()) {
239: verifyFaultCode(port);
240: }
241: } catch (PingMeFault pmf) {
242: fail("Should not receive PingMefault");
243: }
244: }
245:
246: protected void verifyFaultCode(HeaderTester proxy) {
247: BindingProvider bp = (BindingProvider) proxy;
248: java.util.Map<String, Object> respCtx = bp.getResponseContext();
249: assertNotNull(respCtx);
250: Integer val = (Integer) respCtx.get(Message.RESPONSE_CODE);
251: assertNotNull(val);
252: assertEquals("Message.RESPONSE_CODE should be 500", 500, val
253: .intValue());
254: }
255:
256: protected String getWsdlLocation() {
257: return WSDL_LOCATION;
258: }
259:
260: protected QName getServiceQname() {
261: return SERVICE_NAME;
262: }
263:
264: protected QName getPortQName() {
265: return PORT_NAME;
266: }
267:
268: protected boolean isFaultCodeCheckEnabled() {
269: return false;
270: }
271: }
|