|
1 package org.objectweb.celtix.bus.ws.rm.persistence.jdbc;
2
3 import java.io.ByteArrayInputStream  ;
4 import java.io.IOException ;
5 import java.io.InputStream ;
6 import java.math.BigInteger ;
7 import java.sql.Connection ;
8 import java.sql.SQLException ;
9 import java.util.ArrayList ;
10 import java.util.Collection ;
11 import java.util.Date ;
12 import java.util.HashMap ;
13 import java.util.Map ;
14
15 import javax.xml.soap.SOAPException ;
16 import javax.xml.soap.SOAPMessage ;
17 import javax.xml.ws.handler.MessageContext;
18
19 import org.w3c.dom.Node ;
20
21 import junit.extensions.TestSetup;
22 import junit.framework.Test;
23 import junit.framework.TestCase;
24 import junit.framework.TestSuite;
25
26 import org.easymock.classextension.EasyMock;
27 import org.easymock.classextension.IMocksControl;
28 import org.objectweb.celtix.bus.bindings.soap.SOAPBindingImpl;
29 import org.objectweb.celtix.bus.ws.rm.DestinationSequence;
30 import org.objectweb.celtix.bus.ws.rm.Names;
31 import org.objectweb.celtix.bus.ws.rm.RMHandlerTest;
32 import org.objectweb.celtix.bus.ws.rm.RMUtils;
33 import org.objectweb.celtix.bus.ws.rm.SourceSequence;
34 import org.objectweb.celtix.bus.ws.rm.persistence.RMStoreException;
35 import org.objectweb.celtix.context.GenericMessageContext;
36 import org.objectweb.celtix.ws.addressing.v200408.EndpointReferenceType;
37 import org.objectweb.celtix.ws.rm.Identifier;
38 import org.objectweb.celtix.ws.rm.SequenceAcknowledgement;
39 import org.objectweb.celtix.ws.rm.SequenceAcknowledgement.AcknowledgementRange;
40 import org.objectweb.celtix.ws.rm.persistence.RMDestinationSequence;
41 import org.objectweb.celtix.ws.rm.persistence.RMMessage;
42 import org.objectweb.celtix.ws.rm.persistence.RMSourceSequence;
43
44 public class RMTxStoreTest extends TestCase {
45
46
47 private static final String CLIENT_ENDPOINT_ID =
48 "celtix.{http://celtix.objectweb.org/greeter_control}GreeterService/GreeterPort";
49 private static final String SERVER_ENDPOINT_ID =
50 "celtix.{http://celtix.objectweb.org/greeter_control}GreeterService";
51 private static final String NON_ANON_ACKS_TO =
52 "http://localhost:9999/decoupled_endpoint";
53 private static final String SOAP_MSG_KEY = "org.objectweb.celtix.bindings.soap.message";
54
55 private RMTxStore store;
56
57 public static Test suite() throws Exception {
58
59 TestSuite suite = new TestSuite(RMTxStoreTest.class);
60 class RMTxStoreTestSetup extends TestSetup {
61 public RMTxStoreTestSetup(Test test) {
62 super(test);
63 }
64
65 protected void setUp() {
66 RMTxStore.deleteDatabaseFiles("rmdb", true);
67 }
68
69
70 protected void tearDown() {
71 RMTxStore st = new RMTxStore();
72 Map <String , String > params = new HashMap <String , String >();
73 params.put(RMTxStore.CONNECTION_URL_PROPERTY, "jdbc:derby:rmdb;create=true");
74 st.init(params);
75 Connection c = st.getConnection();
76 try {
77 c.close();
78 } catch (SQLException ex) {
79 }
81 RMTxStore.deleteDatabaseFiles("rmdb", false);
82 }
83 }
84 return new RMTxStoreTestSetup(suite);
85 }
86
87 public void setUp() {
88 store = new RMTxStore();
89 Map <String , String > params = new HashMap <String , String >();
90 params.put(RMTxStore.DRIVER_CLASS_NAME_PROPERTY, "org.apache.derby.jdbc.EmbeddedDriver");
91 params.put(RMTxStore.CONNECTION_URL_PROPERTY, "jdbc:derby:rmdb;create=true");
92 store.init(params);
93
94 }
95
96
97 public void testCreateTables() throws SQLException {
98 store.createTables();
101 }
102
103 public void testCreateDeleteSrcSequences() {
104 IMocksControl control = EasyMock.createNiceControl();
105 RMSourceSequence seq = control.createMock(RMSourceSequence.class);
106 Identifier sid1 = RMUtils.getWSRMFactory().createIdentifier();
107 sid1.setValue("sequence1");
108 EasyMock.expect(seq.getIdentifier()).andReturn(sid1);
109 EasyMock.expect(seq.getExpiry()).andReturn(null);
110 EasyMock.expect(seq.getOfferingSequenceIdentifier()).andReturn(null);
111 EasyMock.expect(seq.getEndpointIdentifier()).andReturn(CLIENT_ENDPOINT_ID);
112
113 control.replay();
114 store.createSourceSequence(seq);
115 control.verify();
116
117 control.reset();
118 EasyMock.expect(seq.getIdentifier()).andReturn(sid1);
119 EasyMock.expect(seq.getExpiry()).andReturn(null);
120 EasyMock.expect(seq.getOfferingSequenceIdentifier()).andReturn(null);
121 EasyMock.expect(seq.getEndpointIdentifier()).andReturn(CLIENT_ENDPOINT_ID);
122
123 control.replay();
124 try {
125 store.createSourceSequence(seq);
126 fail("Expected RMStoreException was not thrown.");
127 } catch (RMStoreException ex) {
128 SQLException se = (SQLException )ex.getCause();
129 assertEquals("23505", se.getSQLState());
131 }
132 control.verify();
133
134 control.reset();
135 Identifier sid2 = RMUtils.getWSRMFactory().createIdentifier();
136 sid2.setValue("sequence2");
137 EasyMock.expect(seq.getIdentifier()).andReturn(sid2);
138 EasyMock.expect(seq.getExpiry()).andReturn(new Date ());
139 Identifier sid3 = RMUtils.getWSRMFactory().createIdentifier();
140 sid3.setValue("offeringSequence3");
141 EasyMock.expect(seq.getOfferingSequenceIdentifier()).andReturn(sid3);
142 EasyMock.expect(seq.getEndpointIdentifier()).andReturn(SERVER_ENDPOINT_ID);
143
144
145 control.replay();
146 store.createSourceSequence(seq);
147 control.verify();
148
149 store.removeSourceSequence(sid1);
150 store.removeSourceSequence(sid2);
151
152 store.removeSourceSequence(sid2);
154
155 }
156
157 public void testCreateDeleteDestSequences() {
158 IMocksControl control = EasyMock.createNiceControl();
159 RMDestinationSequence seq = control.createMock(RMDestinationSequence.class);
160 Identifier sid1 = RMUtils.getWSRMFactory().createIdentifier();
161 sid1.setValue("sequence1");
162 EndpointReferenceType epr = RMUtils.createReference(Names.WSA_ANONYMOUS_ADDRESS);
163 EasyMock.expect(seq.getIdentifier()).andReturn(sid1);
164 EasyMock.expect(seq.getAcksTo()).andReturn(epr);
165 EasyMock.expect(seq.getEndpointIdentifier()).andReturn(SERVER_ENDPOINT_ID);
166
167 control.replay();
168 store.createDestinationSequence(seq);
169 control.verify();
170
171 control.reset();
172 EasyMock.expect(seq.getIdentifier()).andReturn(sid1);
173 EasyMock.expect(seq.getAcksTo()).andReturn(epr);
174 EasyMock.expect(seq.getEndpointIdentifier()).andReturn(SERVER_ENDPOINT_ID);
175
176 control.replay();
177 try {
178 store.createDestinationSequence(seq);
179 fail("Expected RMStoreException was not thrown.");
180 } catch (RMStoreException ex) {
181 SQLException se = (SQLException )ex.getCause();
182 assertEquals("23505", se.getSQLState());
184 }
185 control.verify();
186
187 control.reset();
188 Identifier sid2 = RMUtils.getWSRMFactory().createIdentifier();
189 sid2.setValue("sequence2");
190 EasyMock.expect(seq.getIdentifier()).andReturn(sid2);
191 epr = RMUtils.createReference(NON_ANON_ACKS_TO);
192 EasyMock.expect(seq.getAcksTo()).andReturn(epr);
193 EasyMock.expect(seq.getEndpointIdentifier()).andReturn(CLIENT_ENDPOINT_ID);
194
195 control.replay();
196 store.createDestinationSequence(seq);
197 control.verify();
198
199 store.removeDestinationSequence(sid1);
200 store.removeDestinationSequence(sid2);
201
202 store.removeDestinationSequence(sid2);
204
205 }
206
207 public void testCreateDeleteMessages() throws IOException , SQLException {
208 IMocksControl control = EasyMock.createNiceControl();
209 RMMessage msg = control.createMock(RMMessage.class);
210 Identifier sid1 = RMUtils.getWSRMFactory().createIdentifier();
211 sid1.setValue("sequence1");
212 EasyMock.expect(msg.getMessageNr()).andReturn(BigInteger.ONE).times(2);
213 InputStream is = new ByteArrayInputStream (new byte[89]);
214 EasyMock.expect(msg.getContextAsStream()).andReturn(is).times(2);
215
216 control.replay();
217 store.beginTransaction();
218 store.storeMessage(sid1, msg, true);
219 store.storeMessage(sid1, msg, false);
220 store.commit();
221 control.verify();
222
223 control.reset();
224 EasyMock.expect(msg.getMessageNr()).andReturn(BigInteger.ONE);
225 EasyMock.expect(msg.getContextAsStream()).andReturn(is);
226
227 control.replay();
228 store.beginTransaction();
229 try {
230 store.storeMessage(sid1, msg, true);
231 } catch (SQLException ex) {
232 assertEquals("23505", ex.getSQLState());
233 }
234 store.abort();
235 control.verify();
236
237 control.reset();
238 EasyMock.expect(msg.getMessageNr()).andReturn(BigInteger.TEN).times(2);
239 EasyMock.expect(msg.getContextAsStream()).andReturn(is).times(2);
240
241 control.replay();
242 store.beginTransaction();
243 store.storeMessage(sid1, msg, true);
244 store.storeMessage(sid1, msg, false);
245 store.commit();
246 control.verify();
247
248 Collection <BigInteger > messageNrs = new ArrayList <BigInteger >();
249 messageNrs.add(BigInteger.ZERO);
250 messageNrs.add(BigInteger.TEN);
251 messageNrs.add(BigInteger.ONE);
252 messageNrs.add(BigInteger.TEN);
253
254 store.removeMessages(sid1, messageNrs, true);
255 store.removeMessages(sid1, messageNrs, false);
256
257 Identifier sid2 = RMUtils.getWSRMFactory().createIdentifier();
258 sid1.setValue("sequence2");
259 store.removeMessages(sid2, messageNrs, true);
260 }
261
262 public void testUpdateDestinationSequence() throws SQLException , IOException {
263 IMocksControl control = EasyMock.createNiceControl();
264 RMDestinationSequence seq = control.createMock(RMDestinationSequence.class);
265 Identifier sid1 = RMUtils.getWSRMFactory().createIdentifier();
266 sid1.setValue("sequence1");
267 EndpointReferenceType epr = RMUtils.createReference(Names.WSA_ANONYMOUS_ADDRESS);
268 EasyMock.expect(seq.getIdentifier()).andReturn(sid1);
269 EasyMock.expect(seq.getAcksTo()).andReturn(epr);
270 EasyMock.expect(seq.getEndpointIdentifier()).andReturn(SERVER_ENDPOINT_ID);
271
272 control.replay();
273 store.createDestinationSequence(seq);
274 control.verify();
275
276 control.reset();
277 EasyMock.expect(seq.getLastMessageNr()).andReturn(null);
278 InputStream is = new ByteArrayInputStream (new byte[32]);
279 EasyMock.expect(seq.getAcknowledgmentAsStream()).andReturn(is);
280 EasyMock.expect(seq.getIdentifier()).andReturn(sid1);
281
282 control.replay();
283 store.beginTransaction();
284 store.updateDestinationSequence(seq);
285 store.abort();
286
287 control.reset();
288 EasyMock.expect(seq.getLastMessageNr()).andReturn(BigInteger.TEN);
289 EasyMock.expect(seq.getAcknowledgmentAsStream()).andReturn(is);
290 EasyMock.expect(seq.getIdentifier()).andReturn(sid1);
291
292 control.replay();
293 store.beginTransaction();
294 store.updateDestinationSequence(seq);
295 store.abort();
296
297 store.removeDestinationSequence(sid1);
298 }
299
300 public void testUpdateSourceSequence() throws SQLException {
301 IMocksControl control = EasyMock.createNiceControl();
302 RMSourceSequence seq = control.createMock(RMSourceSequence.class);
303 Identifier sid1 = RMUtils.getWSRMFactory().createIdentifier();
304 sid1.setValue("sequence1");
305 EasyMock.expect(seq.getIdentifier()).andReturn(sid1);
306 EasyMock.expect(seq.getExpiry()).andReturn(null);
307 EasyMock.expect(seq.getOfferingSequenceIdentifier()).andReturn(null);
308 EasyMock.expect(seq.getEndpointIdentifier()).andReturn(CLIENT_ENDPOINT_ID);
309
310 control.replay();
311 store.createSourceSequence(seq);
312 control.verify();
313
314 control.reset();
315 EasyMock.expect(seq.getCurrentMessageNr()).andReturn(BigInteger.ONE);
316 EasyMock.expect(seq.isLastMessage()).andReturn(false);
317 EasyMock.expect(seq.getIdentifier()).andReturn(sid1);
318
319 control.replay();
320 store.beginTransaction();
321 store.updateSourceSequence(seq);
322 store.abort();
323
324 control.reset();
325 EasyMock.expect(seq.getCurrentMessageNr()).andReturn(BigInteger.TEN);
326 EasyMock.expect(seq.isLastMessage()).andReturn(true);
327 EasyMock.expect(seq.getIdentifier()).andReturn(sid1);
328
329 control.replay();
330 store.beginTransaction();
331 store.updateSourceSequence(seq);
332 store.abort();
333
334 store.removeSourceSequence(sid1);
335
336 }
337
338 public void testGetDestinationSequences() throws SQLException , IOException {
339
340 Identifier sid1 = null;
341 Identifier sid2 = null;
342
343 Collection <RMDestinationSequence> seqs = store.getDestinationSequences("unknown");
344 assertEquals(0, seqs.size());
345
346 try {
347 sid1 = setupDestinationSequence("sequence1");
348
349 seqs = store.getDestinationSequences(SERVER_ENDPOINT_ID);
350 assertEquals(1, seqs.size());
351 checkRecoveredDestinationSequences(seqs);
352
353 sid2 = setupDestinationSequence("sequence2");
354 seqs = store.getDestinationSequences(SERVER_ENDPOINT_ID);
355 assertEquals(2, seqs.size());
356 checkRecoveredDestinationSequences(seqs);
357 } finally {
358 if (null != sid1) {
359 store.removeDestinationSequence(sid1);
360 }
361 if (null != sid2) {
362 store.removeDestinationSequence(sid2);
363 }
364 }
365 }
366
367 public void testGetSourceSequences() throws SQLException , IOException {
368
369 Identifier sid1 = null;
370 Identifier sid2 = null;
371
372 Collection <RMSourceSequence> seqs = store.getSourceSequences("unknown");
373 assertEquals(0, seqs.size());
374
375 try {
376 sid1 = setupSourceSequence("sequence1");
377
378 seqs = store.getSourceSequences(CLIENT_ENDPOINT_ID);
379 assertEquals(1, seqs.size());
380 checkRecoveredSourceSequences(seqs);
381
382 sid2 = setupSourceSequence("sequence2");
383 seqs = store.getSourceSequences(CLIENT_ENDPOINT_ID);
384 assertEquals(2, seqs.size());
385 checkRecoveredSourceSequences(seqs);
386 } finally {
387 if (null != sid1) {
388 store.removeSourceSequence(sid1);
389 }
390 if (null != sid2) {
391 store.removeSourceSequence(sid2);
392 }
393 }
394 }
395
396 public void testGetMessages() throws SQLException , IOException , SOAPException {
397
398 Identifier sid1 = RMUtils.getWSRMFactory().createIdentifier();
399 sid1.setValue("sequence1");
400 Identifier sid2 = RMUtils.getWSRMFactory().createIdentifier();
401 sid2.setValue("sequence2");
402
403 Collection <RMMessage> out = store.getMessages(sid1, true);
404 assertEquals(0, out.size());
405 Collection <RMMessage> in = store.getMessages(sid1, false);
406 assertEquals(0, out.size());
407
408 try {
409 setupMessage(sid1, BigInteger.ONE, true);
410 setupMessage(sid1, BigInteger.ONE, false);
411
412 out = store.getMessages(sid1, true);
413 assertEquals(1, out.size());
414 checkRecoveredMessages(out);
415
416 in = store.getMessages(sid1, false);
417 assertEquals(1, in.size());
418 checkRecoveredMessages(in);
419
420 setupMessage(sid1, BigInteger.TEN, true);
421 setupMessage(sid1, BigInteger.TEN, false);
422
423 out = store.getMessages(sid1, true);
424 assertEquals(2, out.size());
425 checkRecoveredMessages(out);
426
427 in = store.getMessages(sid1, false);
428 assertEquals(2, in.size());
429 checkRecoveredMessages(in);
430 } finally {
431 Collection <BigInteger > msgNrs = new ArrayList <BigInteger >();
432 msgNrs.add(BigInteger.ONE);
433 msgNrs.add(BigInteger.TEN);
434
435 store.removeMessages(sid1, msgNrs, true);
436 store.removeMessages(sid1, msgNrs, false);
437 }
438 }
439
440 private Identifier setupDestinationSequence(String s) throws IOException , SQLException {
441 IMocksControl control = EasyMock.createNiceControl();
442 DestinationSequence seq = control.createMock(DestinationSequence.class);
443
444 Identifier sid = RMUtils.getWSRMFactory().createIdentifier();
445 sid.setValue(s);
446 EndpointReferenceType epr = RMUtils.createReference(Names.WSA_ANONYMOUS_ADDRESS);
447
448
449 SequenceAcknowledgement ack = RMUtils.getWSRMFactory().createSequenceAcknowledgement();
450 AcknowledgementRange range =
451 RMUtils.getWSRMFactory().createSequenceAcknowledgementAcknowledgementRange();
452 range.setLower(BigInteger.ONE);
453 range.setUpper(BigInteger.ONE);
454 ack.getAcknowledgementRange().add(range);
455 BigInteger lmn = null;
456
457 if ("sequence2".equals(s)) {
458 range =
459 RMUtils.getWSRMFactory().createSequenceAcknowledgementAcknowledgementRange();
460 range.setLower(new BigInteger ("3"));
461 range.setUpper(BigInteger.TEN);
462 ack.getAcknowledgementRange().add(range);
463 lmn = BigInteger.TEN;
464 }
465
466 EasyMock.expect(seq.getIdentifier()).andReturn(sid);
467 EasyMock.expect(seq.getAcksTo()).andReturn(epr);
468 EasyMock.expect(seq.getEndpointIdentifier()).andReturn(SERVER_ENDPOINT_ID);
469 EasyMock.expect(seq.getLastMessageNr()).andReturn(lmn);
470 InputStream is = RMUtils.getPersistenceUtils().getAcknowledgementAsInputStream(ack);
471 EasyMock.expect(seq.getAcknowledgmentAsStream()).andReturn(is);
472 EasyMock.expect(seq.getIdentifier()).andReturn(sid);
473
474 control.replay();
475 store.createDestinationSequence(seq);
476 store.beginTransaction();
477 store.updateDestinationSequence(seq);
478
479 store.commit();
480
481 return sid;
482 }
483
484 private Identifier setupSourceSequence(String s) throws IOException , SQLException {
485 IMocksControl control = EasyMock.createNiceControl();
486 SourceSequence seq = control.createMock(SourceSequence.class);
487
488 Identifier sid = RMUtils.getWSRMFactory().createIdentifier();
489 sid.setValue(s);
490
491 Date expiry = null;
492 Identifier osid = null;
493 BigInteger cmn = BigInteger.ONE;
494 boolean lm = false;
495
496 if ("sequence2".equals(s)) {
497 expiry = new Date (System.currentTimeMillis() + 3600 * 1000);
498 osid = RMUtils.getWSRMFactory().createIdentifier();
499 osid.setValue("offeringSequence");
500 cmn = BigInteger.TEN;
501 lm = true;
502 }
503
504 EasyMock.expect(seq.getIdentifier()).andReturn(sid);
505 EasyMock.expect(seq.getExpiry()).andReturn(expiry);
506 EasyMock.expect(seq.getOfferingSequenceIdentifier()).andReturn(osid);
507 EasyMock.expect(seq.getEndpointIdentifier()).andReturn(CLIENT_ENDPOINT_ID);
508 EasyMock.expect(seq.getCurrentMessageNr()).andReturn(cmn);
509 EasyMock.expect(seq.isLastMessage()).andReturn(lm);
510 EasyMock.expect(seq.getIdentifier()).andReturn(sid);
511
512 control.replay();
513 store.createSourceSequence(seq);
514 store.beginTransaction();
515 store.updateSourceSequence(seq);
516 store.commit();
517
518 return sid;
519 }
520
521 public void setupMessage(Identifier sid, BigInteger mn, boolean outbound)
522 throws IOException , SQLException , SOAPException {
523 IMocksControl control = EasyMock.createNiceControl();
524 RMMessage msg = control.createMock(RMMessage.class);
525 EasyMock.expect(msg.getMessageNr()).andReturn(mn);
526
527 MessageContext ctx = new GenericMessageContext();
528 ctx.put("a", "astring");
529 ctx.put("b", Boolean.TRUE);
530 ctx.put("c", new Integer (Integer.MIN_VALUE));
531 ctx.put("d", mn);
532 ctx.put("e", this);
533 InputStream mis = RMHandlerTest.class.getResourceAsStream("resources/GreetMeDocLiteralRequest.xml");
534 SOAPBindingImpl binding = new SOAPBindingImpl(false);
535 SOAPMessage smsg = binding.getMessageFactory().createMessage(null, mis);
536 ctx.put(SOAP_MSG_KEY, smsg);
537 InputStream cis = RMUtils.getPersistenceUtils().getContextAsInputStream(ctx);
538 EasyMock.expect(msg.getContextAsStream()).andReturn(cis);
539
540 control.replay();
541 store.beginTransaction();
542 store.storeMessage(sid, msg, outbound);
543 store.commit();
544 }
545
546 private void checkRecoveredDestinationSequences(Collection <RMDestinationSequence> seqs) {
547
548 for (RMDestinationSequence recovered : seqs) {
549 assertTrue("sequence1".equals(recovered.getIdentifier().getValue())
550 || "sequence2".equals(recovered.getIdentifier().getValue()));
551 assertEquals(Names.WSA_ANONYMOUS_ADDRESS, recovered.getAcksTo().getAddress().getValue());
552 assertNull(recovered.getEndpointIdentifier());
553 if ("sequence1".equals(recovered.getIdentifier().getValue())) {
554 assertNull(recovered.getLastMessageNr());
555 assertEquals(1, recovered.getAcknowledgment().getAcknowledgementRange().size());
556 AcknowledgementRange r = recovered.getAcknowledgment().getAcknowledgementRange().get(0);
557 assertEquals(BigInteger.ONE, r.getLower());
558 assertEquals(BigInteger.ONE, r.getUpper());
559 } else {
560 assertEquals(BigInteger.TEN, recovered.getLastMessageNr());
561 assertEquals(2, recovered.getAcknowledgment().getAcknowledgementRange().size());
562 AcknowledgementRange r = recovered.getAcknowledgment().getAcknowledgementRange().get(0);
563 assertEquals(BigInteger.ONE, r.getLower());
564 assertEquals(BigInteger.ONE, r.getUpper());
565 r = recovered.getAcknowledgment().getAcknowledgementRange().get(1);
566 assertEquals(new BigInteger ("3"), r.getLower());
567 assertEquals(BigInteger.TEN, r.getUpper());
568 }
569 }
570 }
571
572 private void checkRecoveredSourceSequences(Collection <RMSourceSequence> seqs) {
573
574 for (RMSourceSequence recovered : seqs) {
575 assertTrue("sequence1".equals(recovered.getIdentifier().getValue())
576 || "sequence2".equals(recovered.getIdentifier().getValue()));
577 assertNull(recovered.getEndpointIdentifier());
578 if ("sequence1".equals(recovered.getIdentifier().getValue())) {
579 assertFalse(recovered.isLastMessage());
580 assertEquals(BigInteger.ONE, recovered.getCurrentMessageNr());
581 assertNull(recovered.getExpiry());
582 assertNull(recovered.getOfferingSequenceIdentifier());
583 } else {
584 assertTrue(recovered.isLastMessage());
585 assertEquals(BigInteger.TEN, recovered.getCurrentMessageNr());
586 assertNotNull(recovered.getExpiry());
587 assertEquals("offeringSequence", recovered.getOfferingSequenceIdentifier().getValue());
588 }
589 }
590 }
591
592 public void checkRecoveredMessages(Collection <RMMessage> msgs) throws SOAPException {
593 for (RMMessage msg : msgs) {
594 BigInteger mn = msg.getMessageNr();
595 assertTrue(BigInteger.ONE.equals(mn)
596 || BigInteger.TEN.equals(mn));
597 MessageContext mc = msg.getContext();
598 assertEquals("astring", mc.get("a"));
599 assertTrue((Boolean )mc.get("b"));
600 assertEquals(Integer.MIN_VALUE, ((Integer )mc.get("c")).intValue());
601 assertEquals(mn, (BigInteger )mc.get("d"));
602 assertNull(mc.get("e"));
603 SOAPMessage smsg = (SOAPMessage )mc.get(SOAP_MSG_KEY);
604 for (int i = 0; i < smsg.getSOAPBody().getChildNodes().getLength(); i++) {
605 Node node = smsg.getSOAPBody().getChildNodes().item(i);
606 if (Node.ELEMENT_NODE == node.getNodeType()) {
607 assertEquals("greetMeRequest", node.getLocalName());
608 }
609 }
610 }
611 }
612 }
613 |
Popular Tags |
Java API By Example, From Geeks To Geeks.