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
16 package org.apache.juddi.v3.tck;
17
18 import java.net.InetAddress;
19 import java.rmi.RemoteException;
20 import java.util.Random;
21 import java.util.UUID;
22 import javax.jws.WebMethod;
23 import javax.jws.WebParam;
24 import javax.jws.WebResult;
25 import javax.jws.WebService;
26 import javax.jws.soap.SOAPBinding;
27 import javax.xml.ws.BindingProvider;
28 import javax.xml.ws.Endpoint;
29 import org.apache.commons.configuration.ConfigurationException;
30 import org.apache.commons.logging.Log;
31 import org.apache.commons.logging.LogFactory;
32 import org.apache.juddi.v3.client.UDDIConstants;
33 import org.apache.juddi.v3.client.config.UDDIClient;
34 import org.apache.juddi.v3.client.transport.Transport;
35 import org.junit.AfterClass;
36 import org.junit.Assert;
37 import org.junit.Assume;
38 import org.junit.BeforeClass;
39 import org.junit.Ignore;
40 import org.junit.Test;
41 import org.uddi.api_v3.AccessPoint;
42 import org.uddi.api_v3.BindingTemplate;
43 import org.uddi.api_v3.BindingTemplates;
44 import org.uddi.api_v3.BusinessDetail;
45 import org.uddi.api_v3.BusinessEntity;
46 import org.uddi.api_v3.BusinessService;
47 import org.uddi.api_v3.BusinessServices;
48 import org.uddi.api_v3.CategoryBag;
49 import org.uddi.api_v3.DeleteBusiness;
50 import org.uddi.api_v3.DeleteTModel;
51 import org.uddi.api_v3.Description;
52 import org.uddi.api_v3.DispositionReport;
53 import org.uddi.api_v3.ErrInfo;
54 import org.uddi.api_v3.IdentifierBag;
55 import org.uddi.api_v3.KeyType;
56 import org.uddi.api_v3.KeyedReference;
57 import org.uddi.api_v3.Name;
58 import org.uddi.api_v3.Result;
59 import org.uddi.api_v3.SaveBinding;
60 import org.uddi.api_v3.SaveBusiness;
61 import org.uddi.api_v3.SaveTModel;
62 import org.uddi.api_v3.TModel;
63 import org.uddi.api_v3.TModelDetail;
64 import org.uddi.v3_service.DispositionReportFaultMessage;
65 import org.uddi.v3_service.UDDIInquiryPortType;
66 import org.uddi.v3_service.UDDIPublicationPortType;
67 import org.uddi.v3_service.UDDISecurityPortType;
68 import org.uddi.v3_service.UDDIValueSetValidationPortType;
69 import org.uddi.vs_v3.ValidateValues;
70
71
72
73
74
75 @WebService(name = "UDDI_ValueSetValidation_PortType", targetNamespace = "urn:uddi-org:v3_service")
76 public class UDDI_170_ValueSetValidationIntegrationTest implements UDDIValueSetValidationPortType {
77
78 private static UDDIInquiryPortType inquiry = null;
79 private static UDDIPublicationPortType publicationJoe = null;
80 private static UDDIPublicationPortType publicationMary = null;
81 static UDDISecurityPortType security = null;
82
83 private static Log logger = LogFactory.getLog(UDDI_170_ValueSetValidationIntegrationTest.class);
84 private static String authInfoJoe = null;
85 private static String authInfoMary = null;
86 private static UDDIClient manager;
87 private static boolean VALID = true;
88 static TckTModel maryTmodel=null;
89
90 @BeforeClass
91 public static void startRegistry() throws ConfigurationException {
92 if (!TckPublisher.isEnabled()) {
93 return;
94 }
95 logger.info("__________________________________________________________");
96 logger.info("UDDI_170_ValueSetValidationIntegrationTest");
97 logger.info("__________________________________________________________");
98 logger.info("__________________________________________________________");
99 logger.info("__________________________________________________________");
100 manager = new UDDIClient();
101 manager.start();
102
103 try {
104 Transport transport = manager.getTransport("uddiv3");
105 inquiry = transport.getUDDIInquiryService();
106 publicationJoe = transport.getUDDIPublishService();
107 security = transport.getUDDISecurityService();
108 authInfoJoe = TckSecurity.getAuthToken(security, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
109 if (!TckPublisher.isUDDIAuthMode()) {
110 TckSecurity.setCredentials((BindingProvider) inquiry, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
111 TckSecurity.setCredentials((BindingProvider) publicationJoe, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
112 }
113
114 transport = manager.getTransport("uddiv3");
115 inquiry = transport.getUDDIInquiryService();
116 publicationMary = transport.getUDDIPublishService();
117 security = transport.getUDDISecurityService();
118 authInfoMary = TckSecurity.getAuthToken(security, TckPublisher.getMaryPublisherId(), TckPublisher.getMaryPassword());
119 if (!TckPublisher.isUDDIAuthMode()) {
120 TckSecurity.setCredentials((BindingProvider) inquiry, TckPublisher.getMaryPublisherId(), TckPublisher.getMaryPassword());
121 TckSecurity.setCredentials((BindingProvider) publicationMary, TckPublisher.getMaryPublisherId(), TckPublisher.getMaryPassword());
122 }
123
124 maryTmodel = new TckTModel(publicationMary, inquiry);
125 maryTmodel.saveMaryPublisherTmodel(authInfoMary);
126 } catch (Exception e) {
127 logger.error(e.getMessage(), e);
128 Assert.fail("Could not obtain authInfo token.");
129 }
130 JUDDI_300_MultiNodeIntegrationTest.testSetupReplicationConfig();
131 }
132
133 @AfterClass
134 public static void stopRegistry() throws ConfigurationException {
135 if (!TckPublisher.isEnabled()) {
136 return;
137 }
138 maryTmodel.deleteMaryPublisherTmodel(authInfoMary);
139 manager.stop();
140 }
141 final static String VSV_KEY = "uddi:juddi.apache.org:node1";
142
143 final static String TMODEL = "validated.checked.tmodel";
144
145
146
147
148
149
150
151 @Test
152 public void testVSV() throws Exception {
153 Assume.assumeTrue(TckPublisher.isEnabled());
154 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
155 logger.info("testVSV");
156 BusinessEntity SaveBusiness = null;
157 BusinessEntity SaveVSVCallbackService = null;
158 try {
159 reset();
160 VALID = true;
161 TckTModel joe = new TckTModel(publicationJoe, inquiry);
162 joe.saveJoePublisherTmodel(authInfoJoe);
163 SaveVSVCallbackService = saveVSVCallbackService(authInfoJoe, publicationJoe);
164 saveCheckedTModel(TckTModel.JOE_PUBLISHER_KEY_PREFIX + TMODEL, SaveVSVCallbackService.getBusinessServices().getBusinessService().get(0).getBindingTemplates().getBindingTemplate().get(0).getBindingKey());
165 logger.info("Saving a business using those values");
166 SaveBusiness = saveBusiness(authInfoJoe, true, TckTModel.JOE_PUBLISHER_KEY_PREFIX + TMODEL);
167
168 deleteTModel(authInfoJoe, TckTModel.JOE_PUBLISHER_KEY_PREFIX + TMODEL, publicationJoe);
169
170 } catch (Exception ex) {
171 logger.error(ex);
172 Assert.fail("unexpected failure " + ex.getMessage());
173 } finally {
174 if (SaveBusiness != null) {
175 deleteBusiness(authInfoJoe, SaveBusiness.getBusinessKey(), publicationJoe);
176 }
177 if (SaveVSVCallbackService != null) {
178 deleteBusiness(authInfoJoe, SaveVSVCallbackService.getBusinessKey(), publicationJoe);
179 }
180
181 }
182 Assert.assertTrue(messagesReceived == 1);
183 }
184
185 @Test
186 public void testVSVInvalid() throws Exception {
187 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
188 Assume.assumeTrue(TckPublisher.isEnabled());
189 logger.info("testVSVInvalid");
190 BusinessEntity SaveBusiness = null;
191 BusinessEntity SaveVSVCallbackService = null;
192 try {
193 reset();
194 VALID = false;
195 SaveVSVCallbackService = saveVSVCallbackService(authInfoJoe, publicationJoe);
196 saveCheckedTModel(TckTModel.JOE_PUBLISHER_KEY_PREFIX + TMODEL, SaveVSVCallbackService.getBusinessServices().getBusinessService().get(0).getBindingTemplates().getBindingTemplate().get(0).getBindingKey());
197 logger.info("Saving a business using those values");
198 SaveBusiness = saveBusiness(authInfoJoe, false, TckTModel.JOE_PUBLISHER_KEY_PREFIX + TMODEL);
199 Assert.assertTrue(messagesReceived == 1);
200 Assert.fail("unexpected success");
201 } catch (Exception ex) {
202 logger.info("Expected failure " + ex.getMessage());
203 } finally {
204 if (SaveBusiness != null) {
205 deleteBusiness(authInfoJoe, SaveBusiness.getBusinessKey(), publicationJoe);
206 }
207 if (SaveVSVCallbackService != null) {
208 deleteBusiness(authInfoJoe, SaveVSVCallbackService.getBusinessKey(), publicationJoe);
209 }
210 deleteTModel(authInfoJoe, TckTModel.JOE_PUBLISHER_KEY_PREFIX + TMODEL, publicationJoe);
211
212 }
213 }
214
215 private BusinessEntity saveBusiness(String authInfoJoe, boolean isValid, String key) throws Exception {
216 SaveBusiness sb = new SaveBusiness();
217 sb.setAuthInfo(authInfoJoe);
218 BusinessEntity be = new BusinessEntity();
219 be.getName().add(new Name("VSV", null));
220 be.setCategoryBag(new CategoryBag());
221 if (isValid) {
222 be.getCategoryBag().getKeyedReference().add(new KeyedReference(key, "name", "abcdefg"));
223 } else {
224 be.getCategoryBag().getKeyedReference().add(new KeyedReference(key, "name", "qwerty"));
225 }
226 sb.getBusinessEntity().add(be);
227 BusinessDetail saveBusiness = publicationJoe.saveBusiness(sb);
228 return saveBusiness.getBusinessEntity().get(0);
229 }
230
231 private void saveCheckedTModel(String key, String binding) throws Exception {
232 TModel tm = new TModel();
233 tm.setTModelKey(key);
234 tm.setCategoryBag(new CategoryBag());
235 tm.setName(new Name("My Custom validated key", "en"));
236 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
237 tm.getCategoryBag().getKeyedReference().add(
238 new KeyedReference(UDDIConstants.IS_VALIDATED_BY, UDDIConstants.IS_VALIDATED_BY_KEY_NAME, binding));
239 SaveTModel stm = new SaveTModel();
240 stm.setAuthInfo(authInfoJoe);
241 stm.getTModel().add(tm);
242 publicationJoe.saveTModel(stm);
243 }
244
245 @Override
246 @WebMethod(operationName = "validate_values", action = "validate_values")
247 @WebResult(name = "dispositionReport", targetNamespace = "urn:uddi-org:api_v3", partName = "body")
248 @SOAPBinding(parameterStyle = SOAPBinding.ParameterStyle.BARE)
249 public DispositionReport validateValues(
250 @WebParam(name = "validate_values", targetNamespace = "urn:uddi-org:vs_v3", partName = "body") ValidateValues body)
251 throws DispositionReportFaultMessage, RemoteException {
252 messagesReceived++;
253 if (VALID) {
254 DispositionReport dispositionReport = new DispositionReport();
255 dispositionReport.getResult().add(new Result());
256 return dispositionReport;
257 }
258 DispositionReport dispositionReport = new DispositionReport();
259 Result r = new Result();
260 r.setKeyType(KeyType.T_MODEL_KEY);
261 r.setErrno(20200);
262 r.setErrInfo(new ErrInfo());
263 r.getErrInfo().setErrCode("E_invalidValue");
264 r.getErrInfo().setValue("E_invalidValue");
265
266 dispositionReport.getResult().add(r);
267 throw new DispositionReportFaultMessage("error", dispositionReport);
268 }
269
270 private BusinessEntity saveVSVCallbackService(String auth, UDDIPublicationPortType port) throws Exception {
271 SaveBusiness sb = new SaveBusiness();
272 sb.setAuthInfo(auth);
273 BusinessEntity be = new BusinessEntity();
274 be.getName().add(new Name("VSV business", null));
275 be.setBusinessServices(new BusinessServices());
276 BusinessService bs = new BusinessService();
277 bs.getName().add(new Name("VSV callout", null));
278 bs.setBindingTemplates(new BindingTemplates());
279 BindingTemplate bt = new BindingTemplate();
280 bt.setAccessPoint(new AccessPoint(url, "endPoint"));
281 bs.getBindingTemplates().getBindingTemplate().add(bt);
282 be.getBusinessServices().getBusinessService().add(bs);
283 sb.getBusinessEntity().add(be);
284
285 return port.saveBusiness(sb).getBusinessEntity().get(0);
286 }
287
288 private void deleteTModel(String auth, String key, UDDIPublicationPortType port) throws Exception {
289 DeleteTModel db = new DeleteTModel();
290 db.setAuthInfo(auth);
291 db.getTModelKey().add(key);
292 port.deleteTModel(db);
293 }
294
295 private void deleteBusiness(String auth, String key, UDDIPublicationPortType port) throws Exception {
296 DeleteBusiness db = new DeleteBusiness();
297 db.setAuthInfo(auth);
298 db.getBusinessKey().add(key);
299 port.deleteBusiness(db);
300 }
301 Endpoint ep = null;
302 String url = null;
303 int messagesReceived = 0;
304
305 private void reset() throws Exception {
306 messagesReceived = 0;
307 if (ep == null || !ep.isPublished()) {
308 int httpPort = 9600 + new Random().nextInt(99);
309 String hostname = TckPublisher.getProperties().getProperty("bindaddress");
310 if (hostname == null) {
311 hostname = InetAddress.getLocalHost().getHostName();
312 }
313 url = "http://" + hostname + ":" + httpPort + "/" + UUID.randomUUID().toString();
314 logger.info("Firing up embedded endpoint at " + url);
315 do {
316 try {
317
318 ep = Endpoint.publish(url, this);
319 httpPort = 9600 + new Random().nextInt(99);
320 } catch (Exception ex) {
321 logger.warn(ex.getMessage());
322 }
323 } while (ep != null && !ep.isPublished());
324
325 }
326
327 }
328
329
330
331
332
333 public void testVSCUnknownItem() {
334
335
336
337
338
339
340
341
342
343 }
344
345
346
347
348 public void derviedFromValid() throws Exception {
349
350 Assume.assumeTrue(TckPublisher.isEnabled());
351 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
352 logger.info("DerviedFromValid");
353 TModel tm = new TModel();
354
355 tm.setCategoryBag(new CategoryBag());
356 tm.setName(new Name("My Custom validated key", "en"));
357 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
358 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_DERIVED_FROM, "", "uddi:uddi.org:categorization:nodes"));
359 SaveTModel stm = new SaveTModel();
360 stm.setAuthInfo(authInfoJoe);
361 stm.getTModel().add(tm);
362 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
363 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
364 }
365
366 @Test
367 public void derviedFromInValid() throws Exception {
368 Assume.assumeTrue(TckPublisher.isEnabled());
369 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
370 logger.info("DerviedFromInValid");
371 try {
372 TModel tm = new TModel();
373
374 tm.setCategoryBag(new CategoryBag());
375 tm.setName(new Name("My Custom validated key", "en"));
376 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
377 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_DERIVED_FROM, "", "uddi:juddi.apache.org:" + UUID.randomUUID().toString()));
378 SaveTModel stm = new SaveTModel();
379 stm.setAuthInfo(authInfoJoe);
380 stm.getTModel().add(tm);
381 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
382 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
383 Assert.fail("unexpected success");
384 } catch (Exception ex) {
385 logger.info("Expected failure " + ex.getMessage());
386 logger.debug("Expected failure " + ex.getMessage(), ex);
387 } finally {
388
389 }
390 }
391
392 @Test
393 public void entitKeyValuesValid() throws Exception {
394 Assume.assumeTrue(TckPublisher.isEnabled());
395 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
396 logger.info("EntitKeyValuesValid");
397 TModel tm = new TModel();
398
399 tm.setCategoryBag(new CategoryBag());
400 tm.setName(new Name("My Custom validated key", "en"));
401 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
402 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.ENTITY_KEY_VALUES, "", "tModelKey"));
403 SaveTModel stm = new SaveTModel();
404 stm.setAuthInfo(authInfoJoe);
405 stm.getTModel().add(tm);
406 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
407 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
408
409 }
410
411 @Test
412 public void entitKeyValuesInValid() throws Exception {
413 Assume.assumeTrue(TckPublisher.isEnabled());
414 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
415 logger.info("EntitKeyValuesInValid");
416 try {
417 TModel tm = new TModel();
418
419 tm.setCategoryBag(new CategoryBag());
420 tm.setName(new Name("My Custom validated key", "en"));
421 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
422 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.ENTITY_KEY_VALUES, "", "asdasdasd"));
423 SaveTModel stm = new SaveTModel();
424 stm.setAuthInfo(authInfoJoe);
425 stm.getTModel().add(tm);
426 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
427 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
428 Assert.fail("unexpected success");
429 } catch (Exception ex) {
430 logger.info("Expected failure " + ex.getMessage());
431 logger.debug("Expected failure " + ex.getMessage(), ex);
432 } finally {
433
434 }
435 }
436
437 @Test
438 @Ignore
439 public void uddiNodeValid() throws Exception {
440
441 Assume.assumeTrue(TckPublisher.isEnabled());
442 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
443 logger.info("UDDINodeValid");
444 BusinessEntity be = new BusinessEntity();
445 be.getName().add(new Name("test", "en"));
446 be.setCategoryBag(new CategoryBag());
447 be.getCategoryBag().getKeyedReference().add(new KeyedReference("uddi:uddi.org:categorization:nodes", "", "node"));
448 SaveBusiness sb = new SaveBusiness();
449 sb.setAuthInfo(authInfoJoe);
450 sb.getBusinessEntity().add(be);
451 BusinessDetail saveBusiness = publicationJoe.saveBusiness(sb);
452 deleteBusiness(authInfoJoe, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
453 }
454
455 @Test
456 public void uddiNodeInValid1() throws Exception {
457 Assume.assumeTrue(TckPublisher.isEnabled());
458 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
459 logger.info("UDDINodeInValid1");
460 try {
461 BusinessEntity be = new BusinessEntity();
462 be.getName().add(new Name("test", "en"));
463 be.setCategoryBag(new CategoryBag());
464 be.getCategoryBag().getKeyedReference().add(new KeyedReference("uddi:uddi.org:categorization:nodes", "", "asdasd"));
465 SaveBusiness sb = new SaveBusiness();
466 sb.setAuthInfo(authInfoJoe);
467 sb.getBusinessEntity().add(be);
468 BusinessDetail saveBusiness = publicationJoe.saveBusiness(sb);
469 deleteBusiness(authInfoJoe, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
470 Assert.fail("unexpected success");
471 } catch (Exception ex) {
472 logger.info("Expected failure " + ex.getMessage());
473 logger.debug("Expected failure " + ex.getMessage(), ex);
474 } finally {
475
476 }
477 }
478
479 @Test
480 public void uddiNodeInValid2() throws Exception {
481 Assume.assumeTrue(TckPublisher.isEnabled());
482 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
483 logger.info("UDDINodeInValid2");
484 try {
485 BusinessEntity be = new BusinessEntity();
486 be.getName().add(new Name("test", "en"));
487 be.setBusinessServices(new BusinessServices());
488 BusinessService bs = new BusinessService();
489 bs.setCategoryBag(new CategoryBag());
490 bs.getCategoryBag().getKeyedReference().add(new KeyedReference("uddi:uddi.org:categorization:nodes", "", "asdasd"));
491 be.getBusinessServices().getBusinessService().add(bs);
492 be.setCategoryBag(new CategoryBag());
493
494 SaveBusiness sb = new SaveBusiness();
495 sb.setAuthInfo(authInfoJoe);
496 sb.getBusinessEntity().add(be);
497 BusinessDetail saveBusiness = publicationJoe.saveBusiness(sb);
498 deleteBusiness(authInfoJoe, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
499 Assert.fail("unexpected success");
500 } catch (Exception ex) {
501 logger.info("Expected failure " + ex.getMessage());
502 logger.debug("Expected failure " + ex.getMessage(), ex);
503 } finally {
504
505 }
506 }
507
508 @Test
509 public void owningBusinessValid() throws Exception {
510 Assume.assumeTrue(TckPublisher.isEnabled());
511 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
512 logger.info("OwningBusinessValid");
513 TModel tm = new TModel();
514
515 tm.setCategoryBag(new CategoryBag());
516 tm.setName(new Name("My Custom validated key", "en"));
517 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
518 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.OWNING_BUSINESS, "", "uddi:juddi.apache.org:node1"));
519 SaveTModel stm = new SaveTModel();
520 stm.setAuthInfo(authInfoJoe);
521 stm.getTModel().add(tm);
522 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
523 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
524 }
525
526 @Test
527 public void owningBusinessInValid() throws Exception {
528 logger.info("OwningBusinessInValid");
529 try {
530 Assume.assumeTrue(TckPublisher.isEnabled());
531 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
532 BusinessEntity be = new BusinessEntity();
533 be.getName().add(new Name("test", "en"));
534 be.setCategoryBag(new CategoryBag());
535 be.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.OWNING_BUSINESS, "", "uddi:juddi.apache.org:" + UUID.randomUUID().toString()));
536 SaveBusiness sb = new SaveBusiness();
537 sb.setAuthInfo(authInfoJoe);
538 sb.getBusinessEntity().add(be);
539 BusinessDetail saveBusiness = publicationJoe.saveBusiness(sb);
540 deleteBusiness(authInfoJoe, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
541 Assert.fail("unexpected success");
542 } catch (Exception ex) {
543 logger.info("Expected failure " + ex.getMessage());
544 logger.debug("Expected failure " + ex.getMessage(), ex);
545 } finally {
546
547 }
548 }
549
550 @Test
551 public void owningBusinessInValid2() throws Exception {
552 Assume.assumeTrue(TckPublisher.isEnabled());
553 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
554 logger.info("OwningBusinessInValid2");
555 try {
556 TModel tm = new TModel();
557
558 tm.setCategoryBag(new CategoryBag());
559 tm.setName(new Name("My Custom validated key", "en"));
560 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
561 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.OWNING_BUSINESS, "", "uddi:juddi.apache.org:" + UUID.randomUUID().toString()));
562 SaveTModel stm = new SaveTModel();
563 stm.setAuthInfo(authInfoJoe);
564 stm.getTModel().add(tm);
565 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
566 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
567 Assert.fail("unexpected success");
568 } catch (Exception ex) {
569 logger.info("Expected failure " + ex.getMessage());
570 logger.debug("Expected failure " + ex.getMessage(), ex);
571 } finally {
572
573 }
574 }
575
576 @Test
577 public void typeTmodelValid() throws Exception {
578 Assume.assumeTrue(TckPublisher.isEnabled());
579 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
580 logger.info("TypeTmodelValid");
581 TModel tm = new TModel();
582
583 tm.setCategoryBag(new CategoryBag());
584 tm.setName(new Name("My Custom validated key", "en"));
585 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
586 tm.getCategoryBag().getKeyedReference().add(new KeyedReference("uddi:uddi.org:categorization:types", "", "namespace"));
587 SaveTModel stm = new SaveTModel();
588 stm.setAuthInfo(authInfoJoe);
589 stm.getTModel().add(tm);
590 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
591 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
592
593 }
594
595 @Test
596 public void typeTModelInValid() throws Exception {
597 Assume.assumeTrue(TckPublisher.isEnabled());
598 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
599 logger.info("TypeTModelInValid");
600 try {
601 TModel tm = new TModel();
602
603 tm.setCategoryBag(new CategoryBag());
604 tm.setName(new Name("My Custom validated key", "en"));
605 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
606 tm.getCategoryBag().getKeyedReference().add(new KeyedReference("uddi:uddi.org:categorization:types", "", "wsdlDeployment"));
607 SaveTModel stm = new SaveTModel();
608 stm.setAuthInfo(authInfoJoe);
609 stm.getTModel().add(tm);
610 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
611 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
612 Assert.fail("unexpected success");
613 } catch (Exception ex) {
614 logger.info("Expected failure " + ex.getMessage());
615 logger.debug("Expected failure " + ex.getMessage(), ex);
616 } finally {
617
618 }
619 }
620
621 @Test
622 public void typeBindingInValid() throws Exception {
623 Assume.assumeTrue(TckPublisher.isEnabled());
624 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
625 logger.info("TypeBindingInValid");
626 BusinessDetail saveBusiness = null;
627 try {
628 BusinessEntity be = new BusinessEntity();
629 be.getName().add(new Name("test", "en"));
630 be.setBusinessServices(new BusinessServices());
631 be.getBusinessServices().getBusinessService().add(new BusinessService());
632 be.getBusinessServices().getBusinessService().get(0).getName().add(new Name("test", "en"));
633 SaveBusiness sb = new SaveBusiness();
634 sb.setAuthInfo(authInfoJoe);
635 saveBusiness = publicationJoe.saveBusiness(sb);
636 SaveBinding sbb = new SaveBinding();
637
638 sbb.setAuthInfo(authInfoJoe);
639 BindingTemplate bt = new BindingTemplate();
640 bt.setServiceKey(saveBusiness.getBusinessEntity().get(0).getBusinessServices().getBusinessService().get(0).getServiceKey());
641 bt.setAccessPoint(new AccessPoint("http://test", "endPoint"));
642 bt.setCategoryBag(new CategoryBag());
643 bt.getCategoryBag().getKeyedReference().add(new KeyedReference("uddi:uddi.org:categorization:types", "", "namespace"));
644 publicationJoe.saveBinding(sbb);
645 deleteBusiness(authInfoJoe, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
646 Assert.fail("unexpected success");
647 } catch (Exception ex) {
648 logger.info("Expected failure " + ex.getMessage());
649 logger.debug("Expected failure " + ex.getMessage(), ex);
650 } finally {
651
652 }
653 }
654
655 @Test
656 public void rypeBindingValid() throws Exception {
657 Assume.assumeTrue(TckPublisher.isEnabled());
658 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
659 logger.info("TypeBindingValid");
660 BusinessEntity be = new BusinessEntity();
661 be.getName().add(new Name("test", "en"));
662 be.setBusinessServices(new BusinessServices());
663 be.getBusinessServices().getBusinessService().add(new BusinessService());
664 be.getBusinessServices().getBusinessService().get(0).getName().add(new Name("test", "en"));
665 SaveBusiness sb = new SaveBusiness();
666 sb.setAuthInfo(authInfoJoe);
667 sb.getBusinessEntity().add(be);
668 BusinessDetail saveBusiness = publicationJoe.saveBusiness(sb);
669
670 SaveBinding sbb = new SaveBinding();
671 sbb.setAuthInfo(authInfoJoe);
672 BindingTemplate bt = new BindingTemplate();
673 bt.setServiceKey(saveBusiness.getBusinessEntity().get(0).getBusinessServices().getBusinessService().get(0).getServiceKey());
674 bt.setAccessPoint(new AccessPoint("http://test", "endPoint"));
675 bt.setCategoryBag(new CategoryBag());
676 bt.getCategoryBag().getKeyedReference().add(new KeyedReference("uddi:uddi.org:categorization:types", "", "wsdlDeployment"));
677 sbb.getBindingTemplate().add(bt);
678 publicationJoe.saveBinding(sbb);
679 deleteBusiness(authInfoJoe, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
680 }
681
682 @Test
683 public void ralidatedByInValid() throws Exception {
684 Assume.assumeTrue(TckPublisher.isEnabled());
685 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
686 logger.info("ValidatedByInValid");
687 BusinessEntity SaveVSVCallbackService = null;
688 try {
689 SaveVSVCallbackService = saveVSVCallbackService(authInfoJoe, publicationJoe);
690
691 TModel tm = new TModel();
692
693 tm.setCategoryBag(new CategoryBag());
694 tm.setName(new Name("My Custom validated key", "en"));
695 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
696 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_VALIDATED_BY, UDDIConstants.IS_VALIDATED_BY_KEY_NAME, TckTModel.JOE_PUBLISHER_KEY_PREFIX + UUID.randomUUID().toString()));
697 SaveTModel stm = new SaveTModel();
698 stm.setAuthInfo(authInfoJoe);
699 stm.getTModel().add(tm);
700 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
701 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
702 Assert.fail("unexpected success");
703 } catch (Exception ex) {
704 logger.info("Expected failure " + ex.getMessage());
705 logger.debug("Expected failure " + ex.getMessage(), ex);
706 } finally {
707 deleteBusiness(authInfoJoe, SaveVSVCallbackService.getBusinessKey(), publicationJoe);
708 }
709 }
710
711 @Test
712 public void ralidatedByValid() throws Exception {
713 Assume.assumeTrue(TckPublisher.isEnabled());
714 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
715
716 logger.info("ValidatedByValid");
717 BusinessEntity SaveVSVCallbackService = saveVSVCallbackService(authInfoJoe, publicationJoe);
718
719 TModel tm = new TModel();
720
721 tm.setCategoryBag(new CategoryBag());
722 tm.setName(new Name("My Custom validated key", "en"));
723 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
724 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_VALIDATED_BY, UDDIConstants.IS_VALIDATED_BY_KEY_NAME, SaveVSVCallbackService.getBusinessServices().getBusinessService().get(0).getBindingTemplates().getBindingTemplate().get(0).getBindingKey()));
725 SaveTModel stm = new SaveTModel();
726 stm.setAuthInfo(authInfoJoe);
727 stm.getTModel().add(tm);
728 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
729 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
730 deleteBusiness(authInfoJoe, SaveVSVCallbackService.getBusinessKey(), publicationJoe);
731
732 }
733
734 @Test
735 public void replacedByValid() throws Exception {
736 Assume.assumeTrue(TckPublisher.isEnabled());
737 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
738 logger.info("ReplacedByValid");
739 TModel tm = new TModel();
740 tm.setName(new Name("My old tmodel", "en"));
741 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
742 SaveTModel stm = new SaveTModel();
743 stm.setAuthInfo(authInfoJoe);
744 stm.getTModel().add(tm);
745 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
746
747 tm = new TModel();
748 tm.setName(new Name("My new tmodel", "en"));
749 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
750 tm.setIdentifierBag(new IdentifierBag());
751 tm.getIdentifierBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_REPLACED_BY, "", saveTModel.getTModel().get(0).getTModelKey()));
752 stm = new SaveTModel();
753 stm.setAuthInfo(authInfoJoe);
754 stm.getTModel().add(tm);
755 TModelDetail saveTModel1 = publicationJoe.saveTModel(stm);
756 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
757 deleteTModel(authInfoJoe, saveTModel1.getTModel().get(0).getTModelKey(), publicationJoe);
758 }
759
760 @Test
761 public void replacedByValid2() throws Exception {
762 Assume.assumeTrue(TckPublisher.isEnabled());
763 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
764 logger.info("ReplacedByValid2");
765 TModel tm = new TModel();
766 tm.setName(new Name("My old tmodel", "en"));
767 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
768 SaveTModel stm = new SaveTModel();
769 stm.setAuthInfo(authInfoJoe);
770 stm.getTModel().add(tm);
771 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
772
773 tm = new TModel();
774 tm.setName(new Name("My new tmodel", "en"));
775 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
776 tm.setCategoryBag(new CategoryBag());
777 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_REPLACED_BY, "", saveTModel.getTModel().get(0).getTModelKey()));
778 stm = new SaveTModel();
779 stm.setAuthInfo(authInfoJoe);
780 stm.getTModel().add(tm);
781 TModelDetail saveTModel1 = publicationJoe.saveTModel(stm);
782 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
783 deleteTModel(authInfoJoe, saveTModel1.getTModel().get(0).getTModelKey(), publicationJoe);
784 }
785
786 @Test
787 public void replacedByValid3() throws Exception {
788 Assume.assumeTrue(TckPublisher.isEnabled());
789 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
790 logger.info("ReplacedByValid3");
791 BusinessEntity tm = new BusinessEntity();
792 tm.getName().add(new Name("My old business", "en"));
793 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
794 SaveBusiness stm = new SaveBusiness();
795 stm.setAuthInfo(authInfoJoe);
796 stm.getBusinessEntity().add(tm);
797 BusinessDetail saveBusiness = publicationJoe.saveBusiness(stm);
798
799 tm = new BusinessEntity();
800 tm.getName().add(new Name("My new business", "en"));
801 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
802 tm.setIdentifierBag(new IdentifierBag());
803 tm.getIdentifierBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_REPLACED_BY, "", saveBusiness.getBusinessEntity().get(0).getBusinessKey()));
804 stm = new SaveBusiness();
805 stm.setAuthInfo(authInfoJoe);
806 stm.getBusinessEntity().add(tm);
807 BusinessDetail saveBusiness1 = publicationJoe.saveBusiness(stm);
808 deleteBusiness(authInfoJoe, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
809 deleteBusiness(authInfoJoe, saveBusiness1.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
810 }
811
812 @Test
813 public void replacedByValid4() throws Exception {
814 Assume.assumeTrue(TckPublisher.isEnabled());
815 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
816 logger.info("ReplacedByValid4");
817 BusinessEntity tm = new BusinessEntity();
818 tm.getName().add(new Name("My old business", "en"));
819 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
820 SaveBusiness stm = new SaveBusiness();
821 stm.setAuthInfo(authInfoJoe);
822 stm.getBusinessEntity().add(tm);
823 BusinessDetail saveBusiness = publicationJoe.saveBusiness(stm);
824
825 tm = new BusinessEntity();
826 tm.getName().add(new Name("My new business", "en"));
827 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
828 tm.setCategoryBag(new CategoryBag());
829 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_REPLACED_BY, "", saveBusiness.getBusinessEntity().get(0).getBusinessKey()));
830 stm = new SaveBusiness();
831 stm.setAuthInfo(authInfoJoe);
832 stm.getBusinessEntity().add(tm);
833 BusinessDetail saveBusiness1 = publicationJoe.saveBusiness(stm);
834 deleteBusiness(authInfoJoe, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
835 deleteBusiness(authInfoJoe, saveBusiness1.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
836 }
837
838 @Test
839 public void replacedByValid5Projected() throws Exception {
840 Assume.assumeTrue(TckPublisher.isEnabled());
841 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
842 logger.info("ReplacedByValid5Projected");
843 BusinessEntity tm = new BusinessEntity();
844 tm.setBusinessKey(TckTModel.JOE_PUBLISHER_KEY_PREFIX + "testbiz");
845 tm.getName().add(new Name("My old business", "en"));
846 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
847 SaveBusiness stm = new SaveBusiness();
848 stm.setAuthInfo(authInfoJoe);
849 stm.getBusinessEntity().add(tm);
850
851 tm = new BusinessEntity();
852 tm.setBusinessKey(TckTModel.JOE_PUBLISHER_KEY_PREFIX + "oldbiz");
853 tm.getName().add(new Name("My new business", "en"));
854 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
855 tm.setCategoryBag(new CategoryBag());
856 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_REPLACED_BY, "", TckTModel.JOE_PUBLISHER_KEY_PREFIX + "testbiz"));
857 stm.getBusinessEntity().add(tm);
858 BusinessDetail saveBusiness = publicationJoe.saveBusiness(stm);
859 deleteBusiness(authInfoJoe, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
860 }
861
862 @Test
863 public void replacedByValid6DifferentOwners() throws Exception {
864 Assume.assumeTrue(TckPublisher.isEnabled());
865 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
866 logger.info("ReplacedByValid6DifferentOwners");
867
868 BusinessEntity tm = new BusinessEntity();
869 tm.setBusinessKey(TckTModel.MARY_KEY_PREFIX + "testbiz");
870 tm.getName().add(new Name("My old business", "en"));
871 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
872 SaveBusiness stm = new SaveBusiness();
873 stm.setAuthInfo(authInfoMary);
874 stm.getBusinessEntity().add(tm);
875 BusinessDetail saveBusiness = publicationMary.saveBusiness(stm);
876
877 tm = new BusinessEntity();
878 tm.setBusinessKey(TckTModel.JOE_PUBLISHER_KEY_PREFIX + "oldbiz");
879 tm.getName().add(new Name("My new business", "en"));
880 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
881 tm.setCategoryBag(new CategoryBag());
882 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_REPLACED_BY, "", TckTModel.MARY_KEY_PREFIX + "testbiz"));
883 stm = new SaveBusiness();
884 stm.setAuthInfo(authInfoJoe);
885 stm.getBusinessEntity().add(tm);
886 BusinessDetail saveBusiness1 = publicationJoe.saveBusiness(stm);
887
888 deleteBusiness(authInfoJoe, saveBusiness1.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
889 deleteBusiness(authInfoMary, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationMary);
890 }
891
892 @Test
893 public void replacedByValid7DifferentOwners() throws Exception {
894 Assume.assumeTrue(TckPublisher.isEnabled());
895 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
896
897 TckTModel tmodel = new TckTModel(publicationJoe, inquiry);
898 tmodel.saveJoePublisherTmodel(authInfoJoe);
899
900 logger.info("ReplacedByValid7DifferentOwners");
901 BusinessEntity tm = new BusinessEntity();
902 tm.setBusinessKey(TckTModel.MARY_KEY_PREFIX + "testbiz");
903 tm.getName().add(new Name("My old business", "en"));
904 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
905 SaveBusiness stm = new SaveBusiness();
906 stm.setAuthInfo(authInfoMary);
907 stm.getBusinessEntity().add(tm);
908 BusinessDetail saveBusiness = publicationJoe.saveBusiness(stm);
909
910 tm = new BusinessEntity();
911 tm.setBusinessKey(TckTModel.JOE_PUBLISHER_KEY_PREFIX + "oldbiz");
912 tm.getName().add(new Name("My new business", "en"));
913 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
914 tm.setIdentifierBag(new IdentifierBag());
915 tm.getIdentifierBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_REPLACED_BY, "", TckTModel.MARY_KEY_PREFIX + "testbiz"));
916 stm = new SaveBusiness();
917 stm.setAuthInfo(authInfoJoe);
918 stm.getBusinessEntity().add(tm);
919 BusinessDetail saveBusiness1 = publicationJoe.saveBusiness(stm);
920
921 deleteBusiness(authInfoJoe, saveBusiness1.getBusinessEntity().get(0).getBusinessKey(), publicationJoe);
922 deleteBusiness(authInfoMary, saveBusiness.getBusinessEntity().get(0).getBusinessKey(), publicationMary);
923 }
924
925
926
927
928
929
930 @Test
931 public void replacedByInValid() throws Exception {
932 Assume.assumeTrue(TckPublisher.isEnabled());
933 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
934 logger.info("ReplacedByInValid");
935 try {
936 TModel tm = new TModel();
937 tm.setName(new Name("My new tmodel", "en"));
938 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
939 tm.setCategoryBag(new CategoryBag());
940 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_REPLACED_BY, "", TckTModel.JOE_PUBLISHER_KEY_PREFIX + UUID.randomUUID().toString()));
941 SaveTModel stm = new SaveTModel();
942 stm.setAuthInfo(authInfoJoe);
943 stm.getTModel().add(tm);
944 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
945 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
946 Assert.fail("unexpected success");
947 } catch (Exception ex) {
948 logger.info("Expected failure " + ex.getMessage());
949 logger.debug("Expected failure " + ex.getMessage(), ex);
950 } finally {
951
952 }
953 }
954
955
956
957
958
959
960 @Test
961 public void replacedByInValid2() throws Exception {
962 Assume.assumeTrue(TckPublisher.isEnabled());
963 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
964 logger.info("ReplacedByInValid2");
965 try {
966 TModel tm = new TModel();
967 tm.setName(new Name("My new tmodel", "en"));
968 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
969 tm.setCategoryBag(new CategoryBag());
970 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.IS_REPLACED_BY, "", "uddi:juddi.apache.org:node1"));
971 SaveTModel stm = new SaveTModel();
972 stm.setAuthInfo(authInfoJoe);
973 stm.getTModel().add(tm);
974 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
975 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
976 Assert.fail("unexpected success");
977 } catch (Exception ex) {
978 logger.info("Expected failure " + ex.getMessage());
979 logger.debug("Expected failure " + ex.getMessage(), ex);
980 } finally {
981
982 }
983 }
984
985 @Test
986 public void relationshipsValid() throws Exception {
987 Assume.assumeTrue(TckPublisher.isEnabled());
988 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
989 logger.info("RelationshipsValid");
990 TModel tm = new TModel();
991 tm.setCategoryBag(new CategoryBag());
992 tm.setName(new Name("My Custom validated key", "en"));
993 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
994 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.RELATIONSHIPS, "", "peer-peer"));
995 SaveTModel stm = new SaveTModel();
996 stm.setAuthInfo(authInfoJoe);
997 stm.getTModel().add(tm);
998 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
999 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
1000
1001 }
1002
1003 @Test
1004 public void relationshipsInValid() throws Exception {
1005 Assume.assumeTrue(TckPublisher.isEnabled());
1006 Assume.assumeTrue(TckPublisher.isValueSetAPIEnabled());
1007 logger.info("RelationshipsInValid");
1008 try {
1009 TModel tm = new TModel();
1010
1011 tm.setCategoryBag(new CategoryBag());
1012 tm.setName(new Name("My Custom validated key", "en"));
1013 tm.getDescription().add(new Description("valid values include 'one', 'two', 'three'", "en"));
1014 tm.getCategoryBag().getKeyedReference().add(new KeyedReference(UDDIConstants.RELATIONSHIPS, "", "asdasdasd"));
1015 SaveTModel stm = new SaveTModel();
1016 stm.setAuthInfo(authInfoJoe);
1017 stm.getTModel().add(tm);
1018 TModelDetail saveTModel = publicationJoe.saveTModel(stm);
1019 deleteTModel(authInfoJoe, saveTModel.getTModel().get(0).getTModelKey(), publicationJoe);
1020 Assert.fail("unexpected success");
1021 } catch (Exception ex) {
1022 logger.info("Expected failure " + ex.getMessage());
1023 logger.debug("Expected failure " + ex.getMessage(), ex);
1024 } finally {
1025
1026 }
1027
1028 }
1029
1030 }