This project has retired. For details please refer to its
Attic page.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 package org.apache.juddi.v3.tck;
16
17 import java.util.ArrayList;
18 import java.util.Calendar;
19 import java.util.GregorianCalendar;
20 import java.util.List;
21 import javax.xml.datatype.DatatypeConfigurationException;
22 import javax.xml.datatype.DatatypeFactory;
23 import javax.xml.datatype.XMLGregorianCalendar;
24 import javax.xml.soap.SOAPFault;
25 import javax.xml.ws.BindingProvider;
26 import javax.xml.ws.Holder;
27 import org.apache.commons.configuration.ConfigurationException;
28 import org.apache.commons.logging.Log;
29 import org.apache.commons.logging.LogFactory;
30 import org.apache.juddi.v3.client.UDDIConstants;
31 import org.apache.juddi.v3.client.config.UDDIClient;
32 import org.apache.juddi.v3.client.transport.Transport;
33 import org.junit.AfterClass;
34 import org.junit.Assert;
35 import org.junit.Assume;
36 import org.junit.BeforeClass;
37 import org.junit.Test;
38 import org.uddi.api_v3.AddPublisherAssertions;
39 import org.uddi.api_v3.BusinessDetail;
40 import org.uddi.api_v3.BusinessEntity;
41 import org.uddi.api_v3.BusinessService;
42 import org.uddi.api_v3.CompletionStatus;
43 import org.uddi.api_v3.DeletePublisherAssertions;
44 import org.uddi.api_v3.FindBusiness;
45 import org.uddi.api_v3.FindQualifiers;
46 import org.uddi.api_v3.FindService;
47 import org.uddi.api_v3.GetAssertionStatusReport;
48 import org.uddi.api_v3.KeyedReference;
49 import org.uddi.api_v3.Name;
50 import org.uddi.api_v3.PublisherAssertion;
51 import org.uddi.api_v3.SaveBusiness;
52 import org.uddi.api_v3.SaveService;
53 import org.uddi.sub_v3.CoveragePeriod;
54 import org.uddi.sub_v3.GetSubscriptionResults;
55 import org.uddi.sub_v3.Subscription;
56 import org.uddi.sub_v3.SubscriptionFilter;
57 import org.uddi.sub_v3.SubscriptionResultsList;
58 import org.uddi.v3_service.UDDIInquiryPortType;
59 import org.uddi.v3_service.UDDIPublicationPortType;
60 import org.uddi.v3_service.UDDISecurityPortType;
61 import org.uddi.v3_service.UDDISubscriptionPortType;
62
63
64
65
66
67
68 public class UDDI_080_SubscriptionIntegrationTest {
69
70 private static Log logger = LogFactory.getLog(UDDI_080_SubscriptionIntegrationTest.class);
71 private static TckTModel tckTModelJoe = null;
72 private static TckBusiness tckBusinessJoe = null;
73 private static TckBusinessService tckBusinessServiceJoe = null;
74 private static TckBindingTemplate tckBindingTemplateJoe = null;
75 private static TckSubscription tckSubscriptionJoe = null;
76 private static TckTModel tckTModelSam = null;
77 private static TckBusiness tckBusinessSam = null;
78 private static TckBusinessService tckBusinessServiceSam = null;
79
80 private static TckSubscription tckSubscriptionSam = null;
81 private static String authInfoJoe = null;
82 private static String authInfoSam = null;
83 private static UDDIClient manager;
84 static UDDIPublicationPortType publicationJoe = null;
85 static UDDIPublicationPortType publicationSam = null;
86 static UDDISubscriptionPortType subscriptionJoe = null;
87
88 @AfterClass
89 public static void stopManager() throws ConfigurationException {
90 if (!TckPublisher.isEnabled()) return;
91 tckTModelJoe.deleteCreatedTModels(authInfoJoe);
92 tckTModelSam.deleteCreatedTModels(authInfoSam);
93 manager.stop();
94 }
95
96 @BeforeClass
97 public static void startManager() throws ConfigurationException {
98 if (!TckPublisher.isEnabled()) return;
99 manager = new UDDIClient();
100 manager.start();
101
102 logger.debug("Getting auth tokens..");
103 try {
104 Transport transport = manager.getTransport("uddiv3");
105 UDDISecurityPortType security = transport.getUDDISecurityService();
106 authInfoJoe = TckSecurity.getAuthToken(security, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
107 authInfoSam = TckSecurity.getAuthToken(security, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
108
109
110 UDDISubscriptionPortType subscription = transport.getUDDISubscriptionService();
111
112 publicationJoe = transport.getUDDIPublishService();
113 UDDIInquiryPortType inquiry = transport.getUDDIInquiryService();
114
115 if (!TckPublisher.isUDDIAuthMode()) {
116 TckSecurity.setCredentials((BindingProvider) publicationJoe, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
117 TckSecurity.setCredentials((BindingProvider) subscription, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
118 TckSecurity.setCredentials((BindingProvider) inquiry, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
119 }
120
121 tckTModelJoe = new TckTModel(publicationJoe, inquiry);
122 tckBusinessJoe = new TckBusiness(publicationJoe, inquiry);
123 tckBusinessServiceJoe = new TckBusinessService(publicationJoe, inquiry);
124 tckBindingTemplateJoe = new TckBindingTemplate(publicationJoe, inquiry);
125 subscriptionJoe = subscription;
126 tckSubscriptionJoe = new TckSubscription(subscription, security, inquiry);
127
128
129 transport = manager.getTransport("uddiv3");
130 publicationSam = transport.getUDDIPublishService();
131 inquiry = transport.getUDDIInquiryService();
132 subscription = transport.getUDDISubscriptionService();
133 if (!TckPublisher.isUDDIAuthMode()) {
134 TckSecurity.setCredentials((BindingProvider) publicationSam, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
135 TckSecurity.setCredentials((BindingProvider) subscription, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
136 TckSecurity.setCredentials((BindingProvider) inquiry, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
137 }
138 tckTModelSam = new TckTModel(publicationSam, inquiry);
139 tckBusinessSam = new TckBusiness(publicationSam, inquiry);
140 tckBusinessServiceSam = new TckBusinessService(publicationSam, inquiry);
141
142 tckSubscriptionSam = new TckSubscription(subscription, security, inquiry);
143
144
145 String authInfoUDDI = TckSecurity.getAuthToken(security, TckPublisher.getUDDIPublisherId(), TckPublisher.getUDDIPassword());
146 transport = manager.getTransport("uddiv3");
147 UDDIPublicationPortType publication = transport.getUDDIPublishService();
148 inquiry = transport.getUDDIInquiryService();
149
150 if (!TckPublisher.isUDDIAuthMode()) {
151 TckSecurity.setCredentials((BindingProvider) publication, TckPublisher.getUDDIPublisherId(), TckPublisher.getUDDIPassword());
152
153 TckSecurity.setCredentials((BindingProvider) inquiry, TckPublisher.getUDDIPublisherId(), TckPublisher.getUDDIPassword());
154 }
155
156 TckTModel tckTModelUDDI = new TckTModel(publication, inquiry);
157 tckTModelUDDI.saveUDDIPublisherTmodel(authInfoUDDI);
158 tckTModelUDDI.saveTModels(authInfoUDDI, TckTModel.TMODELS_XML);
159 } catch (Exception e) {
160 logger.error(e.getMessage(), e);
161 Assert.fail("Could not obtain authInfo token.");
162 }
163 JUDDI_300_MultiNodeIntegrationTest.testSetupReplicationConfig();
164 }
165 static final String TRANS = "The transaction has been rolled back";
166 static final String MISSING_RESOURCE = "Can't find resource for bundle";
167
168 static void HandleException(Exception ex) {
169 logger.error("Error caught of type " + ex.getClass().getCanonicalName(),ex);
170 if (ex.getMessage() != null) {
171 Assert.assertFalse(ex.getMessage().contains(TRANS));
172 Assert.assertFalse(ex.getMessage().contains(MISSING_RESOURCE));
173 }
174 if (ex instanceof SOAPFault) {
175 SOAPFault sf = (SOAPFault) ex;
176 if (!sf.getTextContent().contains("org.apache.juddi.v3.error.ValueNotAllowedException")) {
177 Assert.fail();
178 }
179 }
180 }
181
182 @Test
183 public void joePublisher() {
184 Assume.assumeTrue(TckPublisher.isEnabled());
185 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
186 try {
187 TckCommon.removeAllExistingSubscriptions(authInfoJoe, subscriptionJoe);
188 tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
189 tckBusinessJoe.saveJoePublisherBusiness(authInfoJoe);
190 tckBusinessServiceJoe.saveJoePublisherService(authInfoJoe);
191 tckBindingTemplateJoe.saveJoePublisherBinding(authInfoJoe);
192 tckSubscriptionJoe.saveJoePublisherSubscription(authInfoJoe);
193 tckSubscriptionJoe.getJoePublisherSubscriptionResults(authInfoJoe);
194 } finally {
195 tckSubscriptionJoe.deleteJoePublisherSubscription(authInfoJoe);
196 tckBindingTemplateJoe.deleteJoePublisherBinding(authInfoJoe);
197 tckBusinessServiceJoe.deleteJoePublisherService(authInfoJoe);
198 tckBusinessJoe.deleteJoePublisherBusiness(authInfoJoe);
199 tckTModelJoe.deleteJoePublisherTmodel(authInfoJoe);
200 }
201 }
202
203 @Test
204 public void samSyndicator() {
205 Assume.assumeTrue(TckPublisher.isEnabled());
206 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
207 try {
208 tckTModelSam.saveSamSyndicatorTmodel(authInfoSam);
209 tckBusinessSam.saveSamSyndicatorBusiness(authInfoSam);
210 tckBusinessServiceSam.saveSamSyndicatorService(authInfoSam);
211 tckSubscriptionSam.saveSamSyndicatorSubscription(authInfoSam);
212 tckSubscriptionSam.getSamSyndicatorSubscriptionResults(authInfoSam);
213 } finally {
214 tckSubscriptionSam.deleteSamSyndicatorSubscription(authInfoSam);
215 tckBusinessServiceSam.deleteSamSyndicatorService(authInfoSam);
216 tckBusinessSam.deleteSamSyndicatorBusiness(authInfoSam);
217 tckTModelSam.deleteSamSyndicatorTmodel(authInfoSam);
218 }
219
220 }
221
222 @Test
223 public void samSyndicatorWithChunkingOnFind() {
224 Assume.assumeTrue(TckPublisher.isEnabled());
225
226 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
227 try {
228 tckTModelSam.saveSamSyndicatorTmodel(authInfoSam);
229 tckBusinessSam.saveSamSyndicatorBusiness(authInfoSam);
230 tckBusinessServiceSam.saveSamSyndicatorService(authInfoSam);
231 tckSubscriptionSam.saveSamSyndicatorSubscriptionWithChunkingOnFind(authInfoSam);
232 tckSubscriptionSam.getSamSyndicatorSubscriptionResultsWithChunkingOnFind(authInfoSam);
233 } finally {
234 tckSubscriptionSam.deleteSamSyndicatorSubscriptionWithChunkingOnFind(authInfoSam);
235 tckBusinessServiceSam.deleteSamSyndicatorService(authInfoSam);
236 tckBusinessSam.deleteSamSyndicatorBusiness(authInfoSam);
237 tckTModelSam.deleteSamSyndicatorTmodel(authInfoSam);
238 }
239
240 }
241
242 @Test
243 public void samSyndicatorWithChunkingOnGet() {
244 Assume.assumeTrue(TckPublisher.isEnabled());
245 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
246 try {
247 tckTModelSam.saveSamSyndicatorTmodel(authInfoSam);
248 tckBusinessSam.saveSamSyndicatorBusiness(authInfoSam);
249 tckBusinessServiceSam.saveSamSyndicatorService(authInfoSam);
250 tckSubscriptionSam.saveSamSyndicatorSubscriptionWithChunkingOnGet(authInfoSam);
251 tckSubscriptionSam.getSamSyndicatorSubscriptionResultsWithChunkingOnGet(authInfoSam);
252 } finally {
253 tckSubscriptionSam.deleteSamSyndicatorSubscriptionWithChunkingOnGet(authInfoSam);
254 tckBusinessServiceSam.deleteSamSyndicatorService(authInfoSam);
255 tckBusinessSam.deleteSamSyndicatorBusiness(authInfoSam);
256 tckTModelSam.deleteSamSyndicatorTmodel(authInfoSam);
257 }
258
259 }
260
261
262
263
264 @Test
265 public void JUDDI_606_1() {
266 Assume.assumeTrue(TckPublisher.isEnabled());
267 logger.info("JUDDI_606_1");
268 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
269
270
271 Subscription sub = new Subscription();
272 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
273 data.value = new ArrayList<Subscription>();
274 sub.setBrief(true);
275 sub.setExpiresAfter(null);
276 sub.setMaxEntities(1);
277 sub.setNotificationInterval(null);
278 sub.setBindingKey(null);
279 sub.setSubscriptionFilter(new SubscriptionFilter());
280 sub.getSubscriptionFilter().setFindService(new FindService());
281 sub.getSubscriptionFilter().getFindService().setFindQualifiers(new FindQualifiers());
282 sub.getSubscriptionFilter().getFindService().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
283 sub.getSubscriptionFilter().getFindService().getName().add(new Name("%", null));
284 data.value.add(sub);
285 try {
286 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
287 Assert.assertNotNull(data.value.get(0).getExpiresAfter());
288 } catch (Exception ex) {
289 HandleException(ex);
290 Assert.fail();
291 }
292 }
293
294
295
296
297
298
299 @Test
300 public void JUDDI_606_2() throws DatatypeConfigurationException {
301 Assume.assumeTrue(TckPublisher.isEnabled());
302 logger.info("JUDDI_606_2");
303 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
304
305 DatatypeFactory df = DatatypeFactory.newInstance();
306 GregorianCalendar gcal = new GregorianCalendar();
307 gcal.setTimeInMillis(System.currentTimeMillis());
308 gcal.add(Calendar.DATE, -1);
309 XMLGregorianCalendar newXMLGregorianCalendar = df.newXMLGregorianCalendar(gcal);
310
311 Subscription sub = new Subscription();
312 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
313 data.value = new ArrayList<Subscription>();
314 sub.setBrief(true);
315 sub.setExpiresAfter(newXMLGregorianCalendar);
316 sub.setMaxEntities(1);
317 sub.setNotificationInterval(null);
318 sub.setBindingKey(null);
319 sub.setSubscriptionFilter(new SubscriptionFilter());
320 sub.getSubscriptionFilter().setFindService(new FindService());
321 sub.getSubscriptionFilter().getFindService().setFindQualifiers(new FindQualifiers());
322 sub.getSubscriptionFilter().getFindService().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
323 sub.getSubscriptionFilter().getFindService().getName().add(new Name("%", null));
324 data.value.add(sub);
325 try {
326 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
327 Assert.fail();
328 } catch (Exception ex) {
329
330 logger.info("Expected exception: " + ex.getMessage());
331 }
332 }
333
334
335
336
337 @Test
338 public void JUDDI_606_3() {
339 Assume.assumeTrue(TckPublisher.isEnabled());
340 logger.info("JUDDI_606_3");
341 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
342
343
344 Subscription sub = new Subscription();
345 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
346 data.value = new ArrayList<Subscription>();
347 sub.setBrief(true);
348 sub.setExpiresAfter(null);
349 sub.setMaxEntities(1);
350 sub.setNotificationInterval(null);
351 sub.setBindingKey(null);
352 sub.setSubscriptionFilter(new SubscriptionFilter());
353 sub.getSubscriptionFilter().setFindService(new FindService());
354 sub.getSubscriptionFilter().getFindService().setFindQualifiers(new FindQualifiers());
355 sub.getSubscriptionFilter().getFindService().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
356 sub.getSubscriptionFilter().getFindService().getName().add(new Name("%", null));
357 data.value.add(sub);
358 try {
359 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
360 Assert.assertNotNull(data.value.get(0).getSubscriptionKey());
361 Assert.assertTrue(data.value.get(0).getSubscriptionKey().length() > 0);
362 } catch (Exception ex) {
363 HandleException(ex);
364 Assert.fail();
365 }
366 }
367
368
369
370
371 @Test
372 public void JUDDI_606_4() {
373 Assume.assumeTrue(TckPublisher.isEnabled());
374 logger.info("JUDDI_606_4");
375
376 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
377
378 Subscription sub = new Subscription();
379 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
380 data.value = new ArrayList<Subscription>();
381 sub.setBrief(true);
382 sub.setExpiresAfter(null);
383 sub.setMaxEntities(1);
384 sub.setNotificationInterval(null);
385 sub.setBindingKey(null);
386 sub.setSubscriptionFilter(null);
387
388 try {
389 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
390 Assert.fail();
391 } catch (Exception ex) {
392
393 logger.info("Expected exception: " + ex.getMessage());
394 }
395 }
396
397
398
399
400 @Test
401 public void JUDDI_606_5() {
402 Assume.assumeTrue(TckPublisher.isEnabled());
403 logger.info("JUDDI_606_5");
404
405 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
406
407 Subscription sub = new Subscription();
408 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
409 data.value = new ArrayList<Subscription>();
410 sub.setBrief(true);
411 sub.setExpiresAfter(null);
412 sub.setMaxEntities(1);
413 sub.setNotificationInterval(null);
414 sub.setBindingKey(null);
415 sub.setSubscriptionFilter(new SubscriptionFilter());
416
417 data.value.add(sub);
418 try {
419 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
420 Assert.fail();
421 } catch (Exception ex) {
422
423 logger.info("Expected exception: " + ex.getMessage());
424 }
425 }
426
427
428
429
430 @Test
431 public void JUDDI_606_6() {
432 Assume.assumeTrue(TckPublisher.isEnabled());
433 logger.info("JUDDI_606_6");
434
435 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
436
437 Subscription sub = new Subscription();
438 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
439 data.value = new ArrayList<Subscription>();
440 sub.setBrief(true);
441 sub.setExpiresAfter(null);
442 sub.setMaxEntities(-1);
443 sub.setNotificationInterval(null);
444 sub.setBindingKey(null);
445 sub.setSubscriptionFilter(new SubscriptionFilter());
446 sub.getSubscriptionFilter().setFindService(new FindService());
447 sub.getSubscriptionFilter().getFindService().setFindQualifiers(new FindQualifiers());
448 sub.getSubscriptionFilter().getFindService().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
449 sub.getSubscriptionFilter().getFindService().getName().add(new Name("%", null));
450 data.value.add(sub);
451 try {
452 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
453 Assert.assertTrue(data.value.get(0).getMaxEntities() > 0);
454 } catch (Exception ex) {
455
456
457 logger.info("Expected exception: " + ex.getMessage());
458 }
459 }
460
461
462
463
464
465
466 @Test
467 public void JUDDI_606_7() throws DatatypeConfigurationException {
468 Assume.assumeTrue(TckPublisher.isEnabled());
469 logger.info("JUDDI_606_7");
470 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
471
472 DatatypeFactory df = DatatypeFactory.newInstance();
473 try {
474
475 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
476 data.value = new ArrayList<Subscription>();
477 Subscription sub = new Subscription();
478 sub.setBrief(false);
479 sub.setExpiresAfter(null);
480 sub.setMaxEntities(null);
481 sub.setNotificationInterval(null);
482 sub.setBindingKey(null);
483 sub.setSubscriptionFilter(new SubscriptionFilter());
484 sub.getSubscriptionFilter().setFindBusiness(new FindBusiness());
485 sub.getSubscriptionFilter().getFindBusiness().setFindQualifiers(new FindQualifiers());
486 sub.getSubscriptionFilter().getFindBusiness().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
487 sub.getSubscriptionFilter().getFindBusiness().getName().add(new Name("%", null));
488 sub.getSubscriptionFilter().setFindService(new FindService());
489 sub.getSubscriptionFilter().getFindService().setFindQualifiers(new FindQualifiers());
490 sub.getSubscriptionFilter().getFindService().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
491 sub.getSubscriptionFilter().getFindService().getName().add(new Name("%", null));
492
493 data.value.add(sub);
494
495 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
496 Assert.fail();
497 } catch (Exception ex) {
498 logger.info(ex.getMessage());
499
500 }
501 }
502
503
504
505
506
507 @Test
508 public void JUDDI_606_8() {
509 Assume.assumeTrue(TckPublisher.isEnabled());
510 logger.info("JUDDI_606_8");
511 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
512
513
514 try {
515
516 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
517 data.value = new ArrayList<Subscription>();
518 Subscription sub = new Subscription();
519 sub.setBrief(true);
520 sub.setExpiresAfter(null);
521 sub.setMaxEntities(null);
522 sub.setNotificationInterval(null);
523 sub.setBindingKey(null);
524 sub.setSubscriptionFilter(new SubscriptionFilter());
525 sub.getSubscriptionFilter().setFindService(new FindService());
526 sub.getSubscriptionFilter().getFindService().setFindQualifiers(new FindQualifiers());
527 sub.getSubscriptionFilter().getFindService().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
528 sub.getSubscriptionFilter().getFindService().getName().add(new Name("%", null));
529 data.value.add(sub);
530
531 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
532 Assert.assertNotNull(data.value.get(0).getExpiresAfter());
533 XMLGregorianCalendar xcal = data.value.get(0).getExpiresAfter();
534
535 Thread.sleep(5000);
536 data.value.get(0).setExpiresAfter(null);
537 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
538 Assert.assertNotNull(data.value.get(0).getExpiresAfter());
539 Assert.assertNotSame(xcal, data.value.get(0).getExpiresAfter());
540 long initial = xcal.toGregorianCalendar().getTimeInMillis();
541 long finaltime = data.value.get(0).getExpiresAfter().toGregorianCalendar().getTimeInMillis();
542 Assert.assertTrue(finaltime > initial);
543
544 } catch (Exception ex) {
545 HandleException(ex);
546 Assert.fail();
547 }
548 }
549
550
551
552
553
554
555 @Test
556 public void JUDDI_606_9() throws DatatypeConfigurationException {
557 Assume.assumeTrue(TckPublisher.isEnabled());
558 logger.info("JUDDI_606_9");
559 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
560
561
562 DatatypeFactory df = DatatypeFactory.newInstance();
563
564 try {
565
566 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
567 data.value = new ArrayList<Subscription>();
568 Subscription sub = new Subscription();
569 sub.setBrief(true);
570 sub.setExpiresAfter(null);
571 sub.setMaxEntities(null);
572 sub.setNotificationInterval(df.newDuration(5000));
573 sub.setBindingKey("uddi:uddi.joepublisher.com:mykey");
574 sub.setSubscriptionFilter(new SubscriptionFilter());
575 sub.getSubscriptionFilter().setFindService(new FindService());
576 sub.getSubscriptionFilter().getFindService().setFindQualifiers(new FindQualifiers());
577 sub.getSubscriptionFilter().getFindService().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
578 sub.getSubscriptionFilter().getFindService().getName().add(new Name("%", null));
579 data.value.add(sub);
580
581 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
582 Assert.fail();
583 } catch (Exception ex) {
584 logger.info("Expected exception: " + ex.getMessage());
585 }
586 }
587
588
589
590
591
592
593 @Test
594 public void JUDDI_606_10() throws DatatypeConfigurationException {
595 Assume.assumeTrue(TckPublisher.isEnabled());
596 logger.info("JUDDI_606_10");
597 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
598
599 try {
600
601 tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
602 tckBusinessJoe.saveJoePublisherBusiness(authInfoJoe);
603 tckBusinessServiceJoe.saveJoePublisherService(authInfoJoe);
604 tckBindingTemplateJoe.saveJoePublisherBinding(authInfoJoe);
605
606 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
607 data.value = new ArrayList<Subscription>();
608 Subscription sub = new Subscription();
609 sub.setBrief(true);
610 sub.setExpiresAfter(null);
611 sub.setMaxEntities(null);
612 sub.setNotificationInterval(null);
613 sub.setBindingKey(TckBindingTemplate.JOE_BINDING_KEY);
614 sub.setSubscriptionFilter(new SubscriptionFilter());
615 sub.getSubscriptionFilter().setFindService(new FindService());
616 sub.getSubscriptionFilter().getFindService().setFindQualifiers(new FindQualifiers());
617 sub.getSubscriptionFilter().getFindService().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
618 sub.getSubscriptionFilter().getFindService().getName().add(new Name("%", null));
619 data.value.add(sub);
620
621 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
622 Assert.fail();
623 } catch (Exception ex) {
624
625 logger.info("Expected exception: " + ex.getMessage());
626 } finally {
627 tckBindingTemplateJoe.deleteJoePublisherBinding(authInfoJoe);
628 tckBusinessServiceJoe.deleteJoePublisherService(authInfoJoe);
629 tckBusinessJoe.deleteJoePublisherBusiness(authInfoJoe);
630 tckTModelJoe.deleteJoePublisherTmodel(authInfoJoe);
631 }
632 }
633
634
635
636
637
638
639
640 @Test
641 public void JUDDI_606_11() throws DatatypeConfigurationException {
642 Assume.assumeTrue(TckPublisher.isEnabled());
643 logger.info("JUDDI_606_11");
644 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
645
646 String key = null;
647 DatatypeFactory df = DatatypeFactory.newInstance();
648 try {
649
650 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
651 data.value = new ArrayList<Subscription>();
652 Subscription sub = new Subscription();
653 sub.setBrief(false);
654 sub.setExpiresAfter(null);
655 sub.setMaxEntities(null);
656 sub.setNotificationInterval(null);
657 sub.setBindingKey(null);
658 sub.setSubscriptionFilter(new SubscriptionFilter());
659 sub.getSubscriptionFilter().setFindBusiness(new FindBusiness());
660 sub.getSubscriptionFilter().getFindBusiness().setFindQualifiers(new FindQualifiers());
661 sub.getSubscriptionFilter().getFindBusiness().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
662 sub.getSubscriptionFilter().getFindBusiness().getName().add(new Name("%", null));
663 data.value.add(sub);
664
665 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
666 SaveBusiness sb = new SaveBusiness();
667 sb.setAuthInfo(authInfoJoe);
668 BusinessEntity be = new BusinessEntity();
669 be.getName().add(new Name("Test business", null));
670 sb.getBusinessEntity().add(be);
671 BusinessDetail saveBusiness = publicationJoe.saveBusiness(sb);
672
673 key = saveBusiness.getBusinessEntity().get(0).getBusinessKey();
674
675 GetSubscriptionResults gsr = new GetSubscriptionResults();
676 gsr.setAuthInfo(authInfoJoe);
677 gsr.setSubscriptionKey(null);
678 gsr.setCoveragePeriod(new CoveragePeriod());
679 GregorianCalendar gcal = new GregorianCalendar();
680 gcal.setTimeInMillis(System.currentTimeMillis());
681 gcal.add(Calendar.HOUR, -1);
682 gsr.getCoveragePeriod().setStartPoint(df.newXMLGregorianCalendar(gcal));
683 gcal = new GregorianCalendar();
684 gcal.setTimeInMillis(System.currentTimeMillis());
685 gsr.getCoveragePeriod().setEndPoint(df.newXMLGregorianCalendar(gcal));
686 tckSubscriptionJoe.subscription.getSubscriptionResults(gsr);
687 Assert.fail();
688 } catch (Exception ex) {
689
690
691 logger.info("Expected exception: " + ex.getMessage());
692 } finally {
693 TckCommon.DeleteBusiness(key, authInfoJoe, publicationJoe);
694 }
695 }
696
697
698
699
700
701
702 @Test
703 public void JUDDI_606_12() throws DatatypeConfigurationException {
704 Assume.assumeTrue(TckPublisher.isEnabled());
705 logger.info("JUDDI_606_12");
706 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
707
708 String key = null;
709 try {
710
711 tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
712 tckBusinessJoe.saveJoePublisherBusiness(authInfoJoe);
713 tckBusinessServiceJoe.saveJoePublisherService(authInfoJoe);
714 tckBindingTemplateJoe.saveJoePublisherBinding(authInfoJoe);
715
716 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
717 data.value = new ArrayList<Subscription>();
718 Subscription sub = new Subscription();
719 sub.setBrief(false);
720 sub.setExpiresAfter(null);
721 sub.setMaxEntities(null);
722 sub.setNotificationInterval(null);
723 sub.setBindingKey(null);
724 sub.setSubscriptionFilter(new SubscriptionFilter());
725 sub.getSubscriptionFilter().setFindBusiness(new FindBusiness());
726 sub.getSubscriptionFilter().getFindBusiness().setFindQualifiers(new FindQualifiers());
727 sub.getSubscriptionFilter().getFindBusiness().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
728 sub.getSubscriptionFilter().getFindBusiness().getName().add(new Name("%", null));
729 data.value.add(sub);
730
731 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
732 SaveBusiness sb = new SaveBusiness();
733 sb.setAuthInfo(authInfoJoe);
734 BusinessEntity be = new BusinessEntity();
735 be.getName().add(new Name("Test business", null));
736 sb.getBusinessEntity().add(be);
737 BusinessDetail saveBusiness = publicationJoe.saveBusiness(sb);
738
739 key = saveBusiness.getBusinessEntity().get(0).getBusinessKey();
740 GetSubscriptionResults gsr = new GetSubscriptionResults();
741 gsr.setAuthInfo(authInfoJoe);
742 gsr.setSubscriptionKey(data.value.get(0).getSubscriptionKey());
743 gsr.setCoveragePeriod(null);
744 tckSubscriptionJoe.subscription.getSubscriptionResults(gsr);
745 Assert.fail();
746 } catch (Exception ex) {
747
748
749 logger.info("Expected exception: " + ex.getMessage());
750 } finally {
751 TckCommon.DeleteBusiness(key, authInfoJoe, publicationJoe);
752 tckBindingTemplateJoe.deleteJoePublisherBinding(authInfoJoe);
753 tckBusinessServiceJoe.deleteJoePublisherService(authInfoJoe);
754 tckBusinessJoe.deleteJoePublisherBusiness(authInfoJoe);
755 tckTModelJoe.deleteJoePublisherTmodel(authInfoJoe);
756
757
758 }
759 }
760
761
762
763
764
765
766
767 @Test
768 public void JUDDI_606_13() throws DatatypeConfigurationException {
769 Assume.assumeTrue(TckPublisher.isEnabled());
770 logger.info("JUDDI_606_13");
771 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
772
773 String key = null;
774 DatatypeFactory df = DatatypeFactory.newInstance();
775 try {
776
777 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
778 data.value = new ArrayList<Subscription>();
779 Subscription sub = new Subscription();
780 sub.setBrief(false);
781 sub.setExpiresAfter(null);
782 sub.setMaxEntities(null);
783 sub.setNotificationInterval(null);
784 sub.setBindingKey(null);
785 sub.setSubscriptionFilter(new SubscriptionFilter());
786 sub.getSubscriptionFilter().setFindBusiness(new FindBusiness());
787 sub.getSubscriptionFilter().getFindBusiness().setFindQualifiers(new FindQualifiers());
788 sub.getSubscriptionFilter().getFindBusiness().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
789 sub.getSubscriptionFilter().getFindBusiness().getName().add(new Name("%", null));
790 data.value.add(sub);
791
792 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
793 SaveBusiness sb = new SaveBusiness();
794 sb.setAuthInfo(authInfoJoe);
795 BusinessEntity be = new BusinessEntity();
796 be.getName().add(new Name("Test business", null));
797 sb.getBusinessEntity().add(be);
798 BusinessDetail saveBusiness = publicationJoe.saveBusiness(sb);
799 key = saveBusiness.getBusinessEntity().get(0).getBusinessKey();
800
801 GetSubscriptionResults gsr = new GetSubscriptionResults();
802 gsr.setAuthInfo(authInfoJoe);
803 gsr.setSubscriptionKey(data.value.get(0).getSubscriptionKey());
804 gsr.setCoveragePeriod(new CoveragePeriod());
805 GregorianCalendar gcal = new GregorianCalendar();
806 gcal.setTimeInMillis(System.currentTimeMillis());
807 gcal.add(Calendar.HOUR, -1);
808 gsr.getCoveragePeriod().setStartPoint(df.newXMLGregorianCalendar(gcal));
809 gcal = new GregorianCalendar();
810 gcal.setTimeInMillis(System.currentTimeMillis());
811 gsr.getCoveragePeriod().setEndPoint(df.newXMLGregorianCalendar(gcal));
812 SubscriptionResultsList subscriptionResults = tckSubscriptionJoe.subscription.getSubscriptionResults(gsr);
813 Assert.assertNotNull(subscriptionResults);
814 Assert.assertNotNull(subscriptionResults.getBusinessList());
815 Assert.assertNotNull(subscriptionResults.getCoveragePeriod());
816 Assert.assertNotNull(subscriptionResults.getBusinessList().getBusinessInfos());
817 Assert.assertNotNull(subscriptionResults.getBusinessList().getBusinessInfos().getBusinessInfo().get(0));
818 Assert.assertNotNull(subscriptionResults.getBusinessList().getBusinessInfos().getBusinessInfo().get(0).getBusinessKey());
819 Assert.assertNotNull(subscriptionResults.getBusinessList().getBusinessInfos().getBusinessInfo().get(0).getName().get(0));
820
821 } catch (Exception ex) {
822 HandleException(ex);
823 Assert.fail();
824 } finally {
825 TckCommon.DeleteBusiness(key, authInfoJoe, publicationJoe);
826 }
827 }
828
829
830
831
832
833
834
835 @Test
836 public void JUDDI_606_14() throws DatatypeConfigurationException {
837 Assume.assumeTrue(TckPublisher.isEnabled());
838 logger.info("JUDDI_606_14");
839 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
840
841 DatatypeFactory df = DatatypeFactory.newInstance();
842 try {
843
844
845 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
846 data.value = new ArrayList<Subscription>();
847 Subscription sub = new Subscription();
848 sub.setBrief(false);
849 sub.setExpiresAfter(null);
850 sub.setMaxEntities(null);
851 sub.setNotificationInterval(null);
852 sub.setBindingKey(null);
853 sub.setSubscriptionFilter(new SubscriptionFilter());
854 sub.getSubscriptionFilter().setFindService(new FindService());
855 sub.getSubscriptionFilter().getFindService().setFindQualifiers(new FindQualifiers());
856 sub.getSubscriptionFilter().getFindService().getFindQualifiers().getFindQualifier().add(UDDIConstants.APPROXIMATE_MATCH);
857 sub.getSubscriptionFilter().getFindService().getName().add(new Name("%", null));
858 data.value.add(sub);
859
860 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
861 tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
862 tckBusinessJoe.saveJoePublisherBusiness(authInfoJoe);
863 tckBusinessServiceJoe.saveJoePublisherService(authInfoJoe);
864
865
866
867
868
869
870
871 GetSubscriptionResults gsr = new GetSubscriptionResults();
872 gsr.setAuthInfo(authInfoJoe);
873 gsr.setSubscriptionKey(data.value.get(0).getSubscriptionKey());
874 gsr.setCoveragePeriod(new CoveragePeriod());
875 GregorianCalendar gcal = new GregorianCalendar();
876 gcal.setTimeInMillis(System.currentTimeMillis());
877 gcal.add(Calendar.HOUR, -1);
878 gsr.getCoveragePeriod().setStartPoint(df.newXMLGregorianCalendar(gcal));
879 gcal = new GregorianCalendar();
880 gcal.setTimeInMillis(System.currentTimeMillis());
881 gsr.getCoveragePeriod().setEndPoint(df.newXMLGregorianCalendar(gcal));
882 SubscriptionResultsList subscriptionResults = tckSubscriptionJoe.subscription.getSubscriptionResults(gsr);
883 Assert.assertNotNull(subscriptionResults);
884 Assert.assertNull(subscriptionResults.getBusinessList());
885 Assert.assertNotNull(subscriptionResults.getCoveragePeriod());
886 Assert.assertNotNull(subscriptionResults.getServiceList());
887 Assert.assertNotNull(subscriptionResults.getServiceList().getServiceInfos().getServiceInfo().get(0));
888 Assert.assertNotNull(subscriptionResults.getServiceList().getServiceInfos().getServiceInfo().get(0).getBusinessKey());
889 Assert.assertNotNull(subscriptionResults.getServiceList().getServiceInfos().getServiceInfo().get(0).getName().get(0));
890
891 } catch (Exception ex) {
892 HandleException(ex);
893 Assert.fail(ex.getMessage());
894 } finally {
895 tckBusinessJoe.deleteJoePublisherBusiness(authInfoJoe);
896 tckTModelJoe.deleteJoePublisherTmodel(authInfoJoe);
897 }
898 }
899
900
901
902
903
904
905
906 @Test
907 public void JUDDI_606_15() throws DatatypeConfigurationException {
908 Assume.assumeTrue(TckPublisher.isEnabled());
909 logger.info("JUDDI_606_15");
910 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
911
912 DatatypeFactory df = DatatypeFactory.newInstance();
913 try {
914
915 tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
916 tckBusinessJoe.saveJoePublisherBusiness(authInfoJoe);
917 tckTModelSam.saveSamSyndicatorTmodel(authInfoSam);
918 tckBusinessSam.saveSamSyndicatorBusiness(authInfoSam);
919
920
921 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
922 data.value = new ArrayList<Subscription>();
923 Subscription sub = new Subscription();
924 sub.setBrief(false);
925 sub.setExpiresAfter(null);
926 sub.setMaxEntities(null);
927 sub.setNotificationInterval(null);
928 sub.setBindingKey(null);
929 sub.setSubscriptionFilter(new SubscriptionFilter());
930 sub.getSubscriptionFilter().setGetAssertionStatusReport(new GetAssertionStatusReport());
931 sub.getSubscriptionFilter().getGetAssertionStatusReport().setCompletionStatus(CompletionStatus.STATUS_TO_KEY_INCOMPLETE);
932 data.value.add(sub);
933
934 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
935
936 AddPublisherAssertions r = new AddPublisherAssertions();
937 r.setAuthInfo(authInfoJoe);
938 PublisherAssertion pa = new PublisherAssertion();
939 pa.setFromKey(TckBusiness.JOE_BUSINESS_KEY);
940 pa.setToKey(TckBusiness.SAM_BUSINESS_KEY);
941 pa.setKeyedReference(new KeyedReference());
942 pa.getKeyedReference().setKeyName("Subsidiary");
943 pa.getKeyedReference().setKeyValue("parent-child");
944
945 pa.getKeyedReference().setTModelKey("uddi:uddi.org:relationships");
946
947 r.getPublisherAssertion().add(pa);
948 publicationJoe.addPublisherAssertions(r);
949
950 GetSubscriptionResults gsr = new GetSubscriptionResults();
951 gsr.setAuthInfo(authInfoJoe);
952 gsr.setSubscriptionKey(data.value.get(0).getSubscriptionKey());
953 gsr.setCoveragePeriod(new CoveragePeriod());
954 GregorianCalendar gcal = new GregorianCalendar();
955 gcal.setTimeInMillis(System.currentTimeMillis());
956 gcal.add(Calendar.HOUR, -1);
957 gsr.getCoveragePeriod().setStartPoint(df.newXMLGregorianCalendar(gcal));
958 gcal = new GregorianCalendar();
959 gcal.setTimeInMillis(System.currentTimeMillis());
960 gsr.getCoveragePeriod().setEndPoint(df.newXMLGregorianCalendar(gcal));
961 SubscriptionResultsList subscriptionResults = tckSubscriptionJoe.subscription.getSubscriptionResults(gsr);
962 Assert.assertNotNull(subscriptionResults);
963 Assert.assertNull(subscriptionResults.getBusinessList());
964 Assert.assertNotNull(subscriptionResults.getCoveragePeriod());
965 Assert.assertNull(subscriptionResults.getServiceList());
966 Assert.assertNotNull(subscriptionResults.getAssertionStatusReport());
967 Assert.assertNotNull(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem());
968 Assert.assertFalse(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().isEmpty());
969 Assert.assertEquals(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().get(0).getFromKey(), TckBusiness.JOE_BUSINESS_KEY);
970 Assert.assertEquals(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().get(0).getToKey(), TckBusiness.SAM_BUSINESS_KEY);
971 Assert.assertNotNull(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().get(0).getCompletionStatus());
972 Assert.assertEquals(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().get(0).getCompletionStatus(), CompletionStatus.STATUS_TO_KEY_INCOMPLETE);
973 Assert.assertNotNull(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().get(0).getKeyedReference());
974 } catch (Exception ex) {
975 HandleException(ex);
976 Assert.fail(ex.getMessage());
977 }
978 finally{
979
980 tckBusinessJoe.saveJoePublisherBusiness(authInfoJoe);
981 tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
982
983 tckBusinessSam.deleteSamSyndicatorBusiness(authInfoSam);
984 tckTModelSam.deleteSamSyndicatorTmodel(authInfoSam);
985
986 }
987 }
988
989
990
991
992
993
994
995 @Test
996 public void JUDDI_606_16() throws DatatypeConfigurationException {
997 Assume.assumeTrue(TckPublisher.isEnabled());
998 logger.info("JUDDI_606_16");
999 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
1000
1001 DatatypeFactory df = DatatypeFactory.newInstance();
1002 try {
1003 tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
1004 tckBusinessJoe.saveJoePublisherBusiness(authInfoJoe);
1005 tckTModelSam.saveSamSyndicatorTmodel(authInfoSam);
1006 tckBusinessSam.saveSamSyndicatorBusiness(authInfoSam);
1007
1008
1009 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
1010 data.value = new ArrayList<Subscription>();
1011 Subscription sub = new Subscription();
1012 sub.setBrief(false);
1013 sub.setExpiresAfter(null);
1014 sub.setMaxEntities(null);
1015 sub.setNotificationInterval(null);
1016 sub.setBindingKey(null);
1017 sub.setSubscriptionFilter(new SubscriptionFilter());
1018 sub.getSubscriptionFilter().setGetAssertionStatusReport(new GetAssertionStatusReport());
1019 sub.getSubscriptionFilter().getGetAssertionStatusReport().setCompletionStatus(CompletionStatus.STATUS_COMPLETE);
1020 data.value.add(sub);
1021
1022 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
1023
1024 AddPublisherAssertions r = new AddPublisherAssertions();
1025 r.setAuthInfo(authInfoJoe);
1026 PublisherAssertion pa = new PublisherAssertion();
1027 pa.setFromKey(TckBusiness.JOE_BUSINESS_KEY);
1028 pa.setToKey(TckBusiness.SAM_BUSINESS_KEY);
1029 pa.setKeyedReference(new KeyedReference());
1030 pa.getKeyedReference().setKeyName("Subsidiary");
1031 pa.getKeyedReference().setKeyValue("parent-child");
1032 pa.getKeyedReference().setTModelKey("uddi:uddi.org:relationships");
1033 r.getPublisherAssertion().add(pa);
1034 publicationJoe.addPublisherAssertions(r);
1035
1036
1037 r = new AddPublisherAssertions();
1038 r.setAuthInfo(authInfoSam);
1039 pa = new PublisherAssertion();
1040 pa.setFromKey(TckBusiness.JOE_BUSINESS_KEY);
1041 pa.setToKey(TckBusiness.SAM_BUSINESS_KEY);
1042 pa.setKeyedReference(new KeyedReference());
1043 pa.getKeyedReference().setKeyName("Subsidiary");
1044 pa.getKeyedReference().setKeyValue("parent-child");
1045 pa.getKeyedReference().setTModelKey("uddi:uddi.org:relationships");
1046 r.getPublisherAssertion().add(pa);
1047 publicationJoe.addPublisherAssertions(r);
1048
1049
1050
1051 GetSubscriptionResults gsr = new GetSubscriptionResults();
1052 gsr.setAuthInfo(authInfoJoe);
1053 gsr.setSubscriptionKey(data.value.get(0).getSubscriptionKey());
1054 gsr.setCoveragePeriod(new CoveragePeriod());
1055 GregorianCalendar gcal = new GregorianCalendar();
1056 gcal.setTimeInMillis(System.currentTimeMillis());
1057 gcal.add(Calendar.HOUR, -1);
1058 gsr.getCoveragePeriod().setStartPoint(df.newXMLGregorianCalendar(gcal));
1059 gcal = new GregorianCalendar();
1060 gcal.setTimeInMillis(System.currentTimeMillis());
1061 gsr.getCoveragePeriod().setEndPoint(df.newXMLGregorianCalendar(gcal));
1062 SubscriptionResultsList subscriptionResults = tckSubscriptionJoe.subscription.getSubscriptionResults(gsr);
1063 Assert.assertNotNull(subscriptionResults);
1064 Assert.assertNull(subscriptionResults.getBusinessList());
1065 Assert.assertNotNull(subscriptionResults.getCoveragePeriod());
1066 Assert.assertNull(subscriptionResults.getServiceList());
1067 Assert.assertNotNull(subscriptionResults.getAssertionStatusReport());
1068 Assert.assertNotNull(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem());
1069 Assert.assertFalse(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().isEmpty());
1070 Assert.assertEquals(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().get(0).getFromKey(), TckBusiness.JOE_BUSINESS_KEY);
1071 Assert.assertEquals(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().get(0).getToKey(), TckBusiness.SAM_BUSINESS_KEY);
1072 Assert.assertNotNull(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().get(0).getCompletionStatus());
1073 Assert.assertEquals(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().get(0).getCompletionStatus(), CompletionStatus.STATUS_COMPLETE);
1074 Assert.assertNotNull(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().get(0).getKeyedReference());
1075 } catch (Exception ex) {
1076 HandleException(ex);
1077 Assert.fail(ex.getMessage());
1078 }
1079 finally{
1080 tckBusinessJoe.saveJoePublisherBusiness(authInfoJoe);
1081 tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
1082
1083 tckBusinessSam.deleteSamSyndicatorBusiness(authInfoSam);
1084 tckTModelSam.deleteSamSyndicatorTmodel(authInfoSam);
1085 }
1086 }
1087
1088
1089
1090
1091
1092
1093
1094 @Test
1095 public void JUDDI_606_17() throws DatatypeConfigurationException {
1096 Assume.assumeTrue(TckPublisher.isEnabled());
1097 logger.info("JUDDI_606_17");
1098 Assume.assumeTrue(TckPublisher.isSubscriptionEnabled());
1099
1100 DatatypeFactory df = DatatypeFactory.newInstance();
1101 try {
1102 tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
1103 tckBusinessJoe.saveJoePublisherBusiness(authInfoJoe);
1104 tckTModelSam.saveSamSyndicatorTmodel(authInfoSam);
1105 tckBusinessSam.saveSamSyndicatorBusiness(authInfoSam);
1106
1107
1108 Holder<List<Subscription>> data = new Holder<List<Subscription>>();
1109 data.value = new ArrayList<Subscription>();
1110 Subscription sub = new Subscription();
1111 sub.setBrief(false);
1112 sub.setExpiresAfter(null);
1113 sub.setMaxEntities(null);
1114 sub.setNotificationInterval(null);
1115 sub.setBindingKey(null);
1116 sub.setSubscriptionFilter(new SubscriptionFilter());
1117 sub.getSubscriptionFilter().setGetAssertionStatusReport(new GetAssertionStatusReport());
1118 sub.getSubscriptionFilter().getGetAssertionStatusReport().setCompletionStatus(CompletionStatus.STATUS_BOTH_INCOMPLETE);
1119 data.value.add(sub);
1120
1121 tckSubscriptionJoe.subscription.saveSubscription(authInfoJoe, data);
1122
1123 AddPublisherAssertions r = new AddPublisherAssertions();
1124 r.setAuthInfo(authInfoJoe);
1125 PublisherAssertion pa = new PublisherAssertion();
1126 pa.setFromKey(TckBusiness.JOE_BUSINESS_KEY);
1127 pa.setToKey(TckBusiness.SAM_BUSINESS_KEY);
1128 pa.setKeyedReference(new KeyedReference());
1129 pa.getKeyedReference().setKeyName("Subsidiary");
1130 pa.getKeyedReference().setKeyValue("parent-child");
1131 pa.getKeyedReference().setTModelKey("uddi:uddi.org:relationships");
1132 r.getPublisherAssertion().add(pa);
1133 publicationJoe.addPublisherAssertions(r);
1134
1135
1136 r = new AddPublisherAssertions();
1137 r.setAuthInfo(authInfoSam);
1138 r.getPublisherAssertion().add(pa);
1139 publicationSam.addPublisherAssertions(r);
1140
1141 DeletePublisherAssertions dp = new DeletePublisherAssertions();
1142 dp.setAuthInfo(authInfoJoe);
1143 dp.getPublisherAssertion().add(pa);
1144 publicationJoe.deletePublisherAssertions(dp);
1145
1146 dp = new DeletePublisherAssertions();
1147 dp.setAuthInfo(authInfoSam);
1148 dp.getPublisherAssertion().add(pa);
1149
1150
1151
1152 GetSubscriptionResults gsr = new GetSubscriptionResults();
1153 gsr.setAuthInfo(authInfoJoe);
1154 gsr.setSubscriptionKey(data.value.get(0).getSubscriptionKey());
1155 gsr.setCoveragePeriod(new CoveragePeriod());
1156 GregorianCalendar gcal = new GregorianCalendar();
1157 gcal.setTimeInMillis(System.currentTimeMillis());
1158 gcal.add(Calendar.HOUR, -1);
1159 gsr.getCoveragePeriod().setStartPoint(df.newXMLGregorianCalendar(gcal));
1160 gcal = new GregorianCalendar();
1161 gcal.setTimeInMillis(System.currentTimeMillis());
1162 gsr.getCoveragePeriod().setEndPoint(df.newXMLGregorianCalendar(gcal));
1163 SubscriptionResultsList subscriptionResults = tckSubscriptionJoe.subscription.getSubscriptionResults(gsr);
1164 Assert.assertNotNull(subscriptionResults);
1165 Assert.assertNull(subscriptionResults.getBusinessList());
1166 Assert.assertNotNull(subscriptionResults.getCoveragePeriod());
1167 Assert.assertNull(subscriptionResults.getServiceList());
1168 Assert.assertNotNull(subscriptionResults.getAssertionStatusReport());
1169 Assert.assertNotNull(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem());
1170 Assert.assertTrue(subscriptionResults.getAssertionStatusReport().getAssertionStatusItem().isEmpty());
1171
1172
1173
1174
1175
1176
1177 } catch (Exception ex) {
1178 HandleException(ex);
1179 Assert.fail(ex.getMessage());
1180 }
1181 finally {
1182 tckBusinessJoe.saveJoePublisherBusiness(authInfoJoe);
1183 tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
1184
1185 tckBusinessSam.deleteSamSyndicatorBusiness(authInfoSam);
1186 tckTModelSam.deleteSamSyndicatorTmodel(authInfoSam);
1187 }
1188 }
1189 }