1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
/*
* 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.tuscany.sca.binding.jms;
import java.util.ArrayList;
import java.util.List;
import org.apache.tuscany.sca.binding.jms.provider.JMSResourceFactory;
import org.apache.tuscany.sca.interfacedef.Operation;
import org.apache.tuscany.sca.interfacedef.impl.OperationImpl;
import org.junit.Test;
/**
* This unit test is used to ensure that a JMS Message delivered to a Component will select the correct operation based
* on the details in section 1.5 of the JMS Binding specification.
*
* @version $Rev$ $Date$
*/
public class OperationSelectionTestCaseFIXME {
/**
* This test attempts to invoke a Service with a Single method where scaOperationName is not specified in the JMS
* Message
* <p>
* Expected behaviour is that the single method will be invoked as scaOperationName is ignored
*
* @throws Exception Failed
*/
@Test
public void testServiceWithOnlyOneOperationScaOperationNameNotSpecified() throws Exception {
// Create the operation we should match
final Operation expectedOperation = newOperation("myOperation");
// Create the list of operations for the Service
final List<Operation> operations = new ArrayList<Operation>();
operations.add(expectedOperation);
// The name of the Operation in the JMS Message - not specified
final String scaOperationName = null;
// Do the test
doTestJMSBinding(expectedOperation, operations, scaOperationName);
}
/**
* This test attempts to invoke a Service with a Single method where scaOperationName in the JMS Message matches the
* method name on the Service
* <p>
* Expected behaviour is that the single method will be invoked as scaOperationName is ignored
*
* @throws Exception Failed
*/
@Test
public void testServiceWithOnlyOneOperationScaOperationNameMatches() throws Exception {
// Create the operation we should match
final Operation expectedOperation = newOperation("myOperation");
// Create the list of operations for the Service
final List<Operation> operations = new ArrayList<Operation>();
operations.add(expectedOperation);
// The name of the Operation in the JMS Message - matches operation name
final String scaOperationName = expectedOperation.getName();
// Do the test
doTestJMSBinding(expectedOperation, operations, scaOperationName);
}
/**
* This test attempts to invoke a Service with a Single method where scaOperationName in the JMS Message is
* different the method name on the Service
* <p>
* Expected behaviour is that the single method will be invoked as scaOperationName is ignored
*
* @throws Exception Failed
*/
@Test
public void testServiceWithOnlyOneOperationScaOperationNameDifferent() throws Exception {
// Create the operation we should match
final Operation expectedOperation = newOperation("myOperation");
// Create the list of operations for the Service
final List<Operation> operations = new ArrayList<Operation>();
operations.add(expectedOperation);
// The name of the Operation in the JMS Message - different to operation name
final String scaOperationName = "Does Not Match Opeation Name";
// Do the test
doTestJMSBinding(expectedOperation, operations, scaOperationName);
}
/**
* This test attempts to invoke a Service with a multiple operations where scaOperationName specified in the JMS
* Message matches an operation name
* <p>
* Expected behaviour is that the named method will be invoked.
*
* @throws Exception Failed
*/
@Test
public void testServiceWithMultipleOperationsScaOperationNameSpecified() throws Exception {
// Create the list of operations for the Service
final List<Operation> operations = new ArrayList<Operation>();
for (int i = 0; i < 5; i++) {
operations.add(newOperation("operation" + i));
}
// Now try and invoke each operation
for (Operation expectedOperation : operations) {
// The name of the Operation in the JMS Message
final String scaOperationName = expectedOperation.getName();
// Do the test
doTestJMSBinding(expectedOperation, operations, scaOperationName);
}
}
/**
* This test attempts to invoke a Service with a multiple operations where scaOperationName specified in the JMS
* Message is not set so we invoke the onMessage() method
* <p>
* Expected behaviour is that the onMessage() method should be used instead
*
* @throws Exception Failed
*/
@Test
public void testServiceWithMultipleOperationsScaOperationNotSpecified() throws Exception {
// Create the list of operations for the Service
final List<Operation> operations = new ArrayList<Operation>();
for (int i = 0; i < 5; i++) {
operations.add(newOperation("operation" + i));
}
// Add the onMessage operation to the Service Contract
final Operation onMessageOperation = newOperation("onMessage");
operations.add(onMessageOperation);
// The name of the Operation in the JMS Message is not set so it will attempt
// to invoke the onMessage() method
final String scaOperationName = null;
// Do the test
doTestJMSBinding(onMessageOperation, operations, scaOperationName);
}
/**
* This is the test method that will attempt to unit test invoking a Service with the specified operations using a
* JMS Message with the specified scaOperationName to ensure that it invokes the expectedOperation
*
* @param expectedOperation The Operation we are expecting to be invoked over JMS
* @param operations The list of Operations supported by the Service
* @param scaOperationName The value to set scaOperationName in the JMS Message
* @throws Exception Failed
*/
private void doTestJMSBinding(Operation expectedOperation, List<Operation> operations, String scaOperationName)
throws Exception {
// Create the test JMS Binding
final JMSBinding jmsBinding = new JMSBinding();
JMSResourceFactory jmsResourceFactory = null;
// Extra information for the method we are invoking
final String operationParams = "Hello";
final Object operationReturnValue = "Operation Success";
// Mock up the Service. Basically, it is going to call:
// List<Operation> opList = service.getInterfaceContract().getInterface().getOperations();
// final InterfaceContract ifaceContract = EasyMock.createStrictMock(InterfaceContract.class);
// final RuntimeComponentService service = EasyMock.createStrictMock(RuntimeComponentService.class);
// final Interface iface = EasyMock.createStrictMock(Interface.class);
// EasyMock.expect(iface.getOperations()).andReturn(operations);
// EasyMock.expect(ifaceContract.getInterface()).andReturn(iface);
// EasyMock.expect(service.getInterfaceContract()).andReturn(ifaceContract);
//
// // Mock up getting and invoking the RuntimeWire. It is going to call:
// // service.getRuntimeWire(jmsBinding).invoke(operation, (Object[])requestPayload);
// final RuntimeWire runtimeWire = EasyMock.createStrictMock(RuntimeWire.class);
// EasyMock.expect(service.getRuntimeWire(jmsBinding)).andReturn(runtimeWire);
// EasyMock.expect(runtimeWire.invoke(expectedOperation, new Object[] {operationParams}))
// .andReturn(operationReturnValue);
//
// // Create the JMS Binding Listener
// // final DefaultJMSBindingListener bindingListener = new DefaultJMSBindingListener(jmsBinding, jmsResourceFactory, service, null);
//
// // Simulate a message
// final TextMessage requestJMSMsg = EasyMock.createStrictMock(TextMessage.class);
// EasyMock.expect(requestJMSMsg.getStringProperty("scaOperationName")).andReturn(scaOperationName);
// EasyMock.expect(requestJMSMsg.getText()).andReturn(operationParams);
// EasyMock.expect(requestJMSMsg.getJMSReplyTo()).andReturn(null);
//
// // Lets put all the mocks into replay mode
// // EasyMock.replay(iface);
// EasyMock.replay(ifaceContract);
// EasyMock.replay(service);
// EasyMock.replay(requestJMSMsg);
// EasyMock.replay(runtimeWire);
// Do the test
// bindingListener.onMessage(requestJMSMsg);
// Verify our Mock objects
// EasyMock.verify(iface);
// EasyMock.verify(ifaceContract);
// EasyMock.verify(service);
// EasyMock.verify(requestJMSMsg);
// EasyMock.verify(runtimeWire);
}
private static Operation newOperation(String name) {
Operation operation = new OperationImpl();
operation.setName(name);
return operation;
}
}
|
