This project has retired. For details please refer to its Attic page.
UDDI_150_CustodyTransferIntegrationTest xref
View Javadoc
1   /*
2    * Copyright 2001-2009 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *      http://www.apache.org/licenses/LICENSE-2.0
8    * 
9    * Unless required by applicable law or agreed to in writing, software
10   * distributed under the License is distributed on an "AS IS" BASIS,
11   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12   * See the License for the specific language governing permissions and
13   * limitations under the License.
14   */
15  package org.apache.juddi.v3.tck;
16  
17  import java.util.GregorianCalendar;
18  import java.util.UUID;
19  import javax.xml.datatype.DatatypeFactory;
20  import javax.xml.datatype.XMLGregorianCalendar;
21  
22  import javax.xml.soap.SOAPFault;
23  import javax.xml.ws.BindingProvider;
24  import javax.xml.ws.Holder;
25  
26  import org.apache.commons.configuration.ConfigurationException;
27  import org.apache.commons.logging.Log;
28  import org.apache.commons.logging.LogFactory;
29  import org.apache.juddi.v3.client.config.UDDIClient;
30  import org.apache.juddi.v3.client.transport.Transport;
31  import org.junit.AfterClass;
32  import org.junit.Assert;
33  import org.junit.Assume;
34  import org.junit.BeforeClass;
35  import org.junit.Test;
36  import org.uddi.api_v3.AccessPoint;
37  import org.uddi.api_v3.BindingTemplate;
38  import org.uddi.api_v3.BindingTemplates;
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.BusinessServices;
43  import org.uddi.api_v3.GetOperationalInfo;
44  import org.uddi.api_v3.Name;
45  import org.uddi.api_v3.OperationalInfos;
46  import org.uddi.api_v3.SaveBusiness;
47  import org.uddi.custody_v3.KeyBag;
48  import org.uddi.custody_v3.TransferEntities;
49  import org.uddi.custody_v3.TransferToken;
50  import org.uddi.v3_service.UDDICustodyTransferPortType;
51  import org.uddi.v3_service.UDDIInquiryPortType;
52  import org.uddi.v3_service.UDDIPublicationPortType;
53  import org.uddi.v3_service.UDDISecurityPortType;
54  
55  /**
56   * This test class provides test cases of items discovered or reported through
57   * the Juddi JIRA issue tracker The idea is that these tests apply to any UDDI
58   * registry and that the tests are either implied or derived requirements
59   * defined in the UDDI spec that were missed in other test cases for Juddi.
60   *
61   * @author <a href="mailto:alexoree@apache.org">Alex O'Ree</a>
62   */
63  public class UDDI_150_CustodyTransferIntegrationTest {
64  
65          private static Log logger = LogFactory.getLog(UDDI_150_CustodyTransferIntegrationTest.class);
66          static UDDISecurityPortType security = null;
67          static UDDIInquiryPortType inquiryJoe = null;
68          static UDDIPublicationPortType publishJoe = null;
69          static UDDICustodyTransferPortType custodyTransferPortTypeJoe = null;
70          static TckTModel tckTModelJoe = null;
71          static UDDIInquiryPortType inquirySam = null;
72          static UDDIPublicationPortType publishSam = null;
73          static UDDICustodyTransferPortType custodyTransferPortTypeSam = null;
74          protected static String authInfoJoe = null;
75          protected static String authInfoSam = null;
76          private static UDDIClient manager;
77          static final String TRANS = "The transaction has been rolled back";
78          static final String MISSING_RESOURCE = "Can't find resource for bundle";
79  
80          @AfterClass
81          public static void stopManager() throws ConfigurationException {
82               if (!TckPublisher.isEnabled()) return;
83                  tckTModelJoe.deleteCreatedTModels(authInfoJoe);
84                  manager.stop();
85          }
86  
87          @BeforeClass
88          public static void startManager() throws ConfigurationException {
89               if (!TckPublisher.isEnabled()) return;
90                  manager = new UDDIClient();
91                  manager.start();
92  
93                  logger.debug("Getting auth tokens..");
94                  try {
95                          Transport transport = manager.getTransport("uddiv3");
96                          security = transport.getUDDISecurityService();
97                          authInfoJoe = TckSecurity.getAuthToken(security, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
98                          authInfoSam = TckSecurity.getAuthToken(security, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
99                          //Assert.assertNotNull(authInfoJoe);
100                         //Assert.assertNotNull(authInfoSam);
101 
102 
103                         publishJoe = transport.getUDDIPublishService();
104                         inquiryJoe = transport.getUDDIInquiryService();
105                         custodyTransferPortTypeJoe = transport.getUDDICustodyTransferService();
106 
107                         if (!TckPublisher.isUDDIAuthMode()) {
108                                 TckSecurity.setCredentials((BindingProvider) publishJoe, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
109                                 TckSecurity.setCredentials((BindingProvider) inquiryJoe, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
110                                 TckSecurity.setCredentials((BindingProvider) custodyTransferPortTypeJoe, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
111                         }
112 
113                         tckTModelJoe = new TckTModel(publishJoe, inquiryJoe);
114 
115                         transport = manager.getTransport("uddiv3");
116                         publishSam = transport.getUDDIPublishService();
117                         inquirySam = transport.getUDDIInquiryService();
118                         custodyTransferPortTypeSam = transport.getUDDICustodyTransferService();
119                         if (!TckPublisher.isUDDIAuthMode()) {
120                                 TckSecurity.setCredentials((BindingProvider) publishJoe, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
121                                 TckSecurity.setCredentials((BindingProvider) inquiryJoe, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
122                                 TckSecurity.setCredentials((BindingProvider) custodyTransferPortTypeJoe, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
123                         }
124 
125                         transport = manager.getTransport("uddiv3");
126                         UDDIPublicationPortType uddiPublishService = transport.getUDDIPublishService();
127                         UDDIInquiryPortType uddiInquiryService = transport.getUDDIInquiryService();
128                         if (!TckPublisher.isUDDIAuthMode()) {
129                                 TckSecurity.setCredentials((BindingProvider) publishJoe, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
130                                 TckSecurity.setCredentials((BindingProvider) inquiryJoe, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
131                                 TckSecurity.setCredentials((BindingProvider) custodyTransferPortTypeJoe, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
132                         }
133 
134                         TckTModel tckTModelUDDI = new TckTModel(uddiPublishService, uddiInquiryService);
135                         String authInfoUDDI = TckSecurity.getAuthToken(security, TckPublisher.getUDDIPublisherId(), TckPublisher.getUDDIPassword());
136                         tckTModelUDDI.saveUDDIPublisherTmodel(authInfoUDDI);
137                         tckTModelUDDI.saveTModels(authInfoUDDI, TckTModel.TMODELS_XML);
138 
139                         tckTModelJoe.saveJoePublisherTmodel(authInfoJoe);
140                 } catch (Exception e) {
141                         logger.error(e.getMessage(), e);
142                         Assert.fail("Could not obtain authInfo token.");
143                 }
144                 JUDDI_300_MultiNodeIntegrationTest.testSetupReplicationConfig();
145         }
146 
147         static void HandleException(Exception ex) {
148                 logger.error("Error caught of type " + ex.getClass().getCanonicalName(),ex);
149                 if (ex.getMessage() != null) {
150                         Assert.assertFalse(ex.getMessage().contains(TRANS));
151                         Assert.assertFalse(ex.getMessage().contains(MISSING_RESOURCE));
152                 }
153                 if (ex instanceof SOAPFault) {
154                         SOAPFault sf = (SOAPFault) ex;
155                         if (!sf.getTextContent().contains("org.apache.juddi.v3.error.ValueNotAllowedException")) {
156                                 Assert.fail();
157                         }
158                 }
159         }
160 
161         /**
162          * tests a user to user transfer on the same node
163          *
164          * @throws Exception
165          */
166         @Test
167         public void ValidTransfer() throws Exception {
168              Assume.assumeTrue(TckPublisher.isEnabled());
169                 logger.info("ValidTransfer");
170                 DatatypeFactory df = DatatypeFactory.newInstance();
171                 GregorianCalendar gcal = new GregorianCalendar();
172                 gcal.setTimeInMillis(System.currentTimeMillis());
173                 XMLGregorianCalendar xcal = df.newXMLGregorianCalendar(gcal);
174 
175 
176                 BusinessEntity myBusEntity = new BusinessEntity();
177                 Name myBusName = new Name();
178                 myBusName.setLang("en");
179                 myBusName.setValue("ValidTransfer UDDI's Business" + " " + xcal.toString());
180                 myBusEntity.getName().add(myBusName);
181                 myBusEntity.setBusinessServices(new BusinessServices());
182                 myBusEntity.getBusinessServices().getBusinessService().add(CreateBusiness("UDDI"));
183                 SaveBusiness sb = new SaveBusiness();
184                 sb.getBusinessEntity().add(myBusEntity);
185                 sb.setAuthInfo(authInfoJoe);
186                 BusinessDetail bd = publishJoe.saveBusiness(sb);
187 
188                 String keyJoeBiz = bd.getBusinessEntity().get(0).getBusinessKey();
189                 //String keyJoeBizSvc = bd.getBusinessEntity().get(0).getBusinessServices().getBusinessService().get(0).getServiceKey();
190 
191 
192 
193                 myBusEntity = new BusinessEntity();
194                 myBusName = new Name();
195                 myBusName.setLang("en");
196                 myBusName.setValue("ValidTransfer Root's Business" + " " + xcal.toString());
197                 myBusEntity.getName().add(myBusName);
198                 myBusEntity.setBusinessServices(new BusinessServices());
199                 myBusEntity.getBusinessServices().getBusinessService().add(CreateBusiness("root"));
200                 sb = new SaveBusiness();
201                 sb.getBusinessEntity().add(myBusEntity);
202                 sb.setAuthInfo(authInfoSam);
203                 bd = publishSam.saveBusiness(sb);
204 
205                 String keySamBiz = bd.getBusinessEntity().get(0).getBusinessKey();
206                 //String keySamBizSvc = bd.getBusinessEntity().get(0).getBusinessServices().getBusinessService().get(0).getServiceKey();
207 
208                 //transfers from Joe to Sam
209                 KeyBag kb = new KeyBag();
210                 kb.getKey().add(keyJoeBiz);
211 
212                 Holder<String> nodeidOUT = new Holder<String>();
213                 Holder<XMLGregorianCalendar> expiresOUT = new Holder<XMLGregorianCalendar>();
214                 Holder<byte[]> tokenOUT = new Holder<byte[]>();
215                 custodyTransferPortTypeJoe.getTransferToken(authInfoJoe, kb, nodeidOUT, expiresOUT, tokenOUT);
216 
217                 //sam accepts
218                 TransferEntities te = new TransferEntities();
219                 te.setAuthInfo(authInfoSam);
220                 te.setKeyBag(kb);
221                 TransferToken tt = new TransferToken();
222                 tt.setExpirationTime(expiresOUT.value);
223                 tt.setNodeID(nodeidOUT.value);
224                 tt.setOpaqueToken(tokenOUT.value);
225                 te.setTransferToken(tt);
226 
227                 custodyTransferPortTypeSam.transferEntities(te);
228 
229                 //confirm the transfer
230                 GetOperationalInfo go = new GetOperationalInfo();
231                 go.setAuthInfo(authInfoSam);
232                 go.getEntityKey().add(keySamBiz);
233                 go.getEntityKey().add(keyJoeBiz);
234                 OperationalInfos operationalInfo = inquirySam.getOperationalInfo(go);
235 
236                 for (int i = 0; i < operationalInfo.getOperationalInfo().size(); i++) {
237                         if (operationalInfo.getOperationalInfo().get(i).getEntityKey().equalsIgnoreCase(keyJoeBiz)) {
238                                 Assert.assertEquals(operationalInfo.getOperationalInfo().get(i).getAuthorizedName(), (TckPublisher.getSamPublisherId()));
239 
240                         }
241                 }
242                 logger.info("Business Entity transfered successfull");
243 
244                 //note, we transfered ownership here so sam has to delete both of them
245                 TckCommon.DeleteBusiness(keyJoeBiz, authInfoSam, publishSam);
246                 TckCommon.DeleteBusiness(keySamBiz, authInfoSam, publishSam);
247 
248 
249         }
250 
251         private BusinessService CreateBusiness(String root) {
252                 BusinessService bs = new BusinessService();
253                 bs.getName().add(new Name());
254                 bs.getName().get(0).setValue(root + "'s callback endpoint");
255                 bs.setBindingTemplates(new BindingTemplates());
256                 BindingTemplate bt = new BindingTemplate();
257                 bt.setAccessPoint(new AccessPoint());
258                 bt.getAccessPoint().setValue("http://localhost:9999/" + root);
259                 bt.getAccessPoint().setUseType("endPoint");
260                 bs.getBindingTemplates().getBindingTemplate().add(bt);
261                 return bs;
262         }
263 
264         @Test
265         public void InvalidTransferTokenNullKeybag() {
266              Assume.assumeTrue(TckPublisher.isEnabled());
267                 try {
268                         //transfers from Joe to Sam
269                         KeyBag kb = null;
270 
271                         Holder<String> nodeidOUT = new Holder<String>();
272                         Holder<XMLGregorianCalendar> expiresOUT = new Holder<XMLGregorianCalendar>();
273                         Holder<byte[]> tokenOUT = new Holder<byte[]>();
274                         custodyTransferPortTypeJoe.getTransferToken(authInfoJoe, kb, nodeidOUT, expiresOUT, tokenOUT);
275                         Assert.fail();
276                 } catch (Exception ex) {
277                         logger.info("Expected exception: " + ex.getMessage());
278                 }
279 
280         }
281 
282         @Test
283         public void InvalidTransferTokenEmptyKeybag() {
284              Assume.assumeTrue(TckPublisher.isEnabled());
285                 try {
286                         //transfers from Joe to Sam
287                         KeyBag kb = new KeyBag();
288                         //kb.getKey().add(keyJoeBiz);
289 
290                         Holder<String> nodeidOUT = new Holder<String>();
291                         Holder<XMLGregorianCalendar> expiresOUT = new Holder<XMLGregorianCalendar>();
292                         Holder<byte[]> tokenOUT = new Holder<byte[]>();
293                         custodyTransferPortTypeJoe.getTransferToken(authInfoJoe, kb, nodeidOUT, expiresOUT, tokenOUT);
294 
295                         Assert.fail();
296                 } catch (Exception ex) {
297                         logger.info("Expected exception: " + ex.getMessage());
298                 }
299 
300         }
301 
302         @Test
303         public void InvalidTransferTokenEmptyNullAuthToken() {
304              Assume.assumeTrue(TckPublisher.isEnabled());
305                 String keyJoeBiz = null;
306                 try {
307                         DatatypeFactory df = DatatypeFactory.newInstance();
308                         GregorianCalendar gcal = new GregorianCalendar();
309                         gcal.setTimeInMillis(System.currentTimeMillis());
310                         XMLGregorianCalendar xcal = df.newXMLGregorianCalendar(gcal);
311 
312 
313                         BusinessEntity myBusEntity = new BusinessEntity();
314                         Name myBusName = new Name();
315                         myBusName.setLang("en");
316                         myBusName.setValue("InvalidTransferTokenEmptyNullAuthToken UDDI's Business" + " " + xcal.toString());
317                         myBusEntity.getName().add(myBusName);
318                         myBusEntity.setBusinessServices(new BusinessServices());
319                         myBusEntity.getBusinessServices().getBusinessService().add(CreateBusiness("UDDI"));
320                         SaveBusiness sb = new SaveBusiness();
321                         sb.getBusinessEntity().add(myBusEntity);
322                         sb.setAuthInfo(authInfoJoe);
323                         BusinessDetail bd = publishJoe.saveBusiness(sb);
324 
325                         keyJoeBiz = bd.getBusinessEntity().get(0).getBusinessKey();
326 
327                         //transfers from Joe to Sam
328                         KeyBag kb = new KeyBag();
329                         kb.getKey().add(keyJoeBiz);
330 
331                         Holder<String> nodeidOUT = new Holder<String>();
332                         Holder<XMLGregorianCalendar> expiresOUT = new Holder<XMLGregorianCalendar>();
333                         Holder<byte[]> tokenOUT = new Holder<byte[]>();
334                         custodyTransferPortTypeJoe.getTransferToken(null, kb, nodeidOUT, expiresOUT, tokenOUT);
335 
336                         Assert.fail();
337                 } catch (Exception ex) {
338                         logger.info("Expected exception: " + ex.getMessage());
339 
340                 } finally {
341                         TckCommon.DeleteBusiness(keyJoeBiz, authInfoJoe, publishJoe);
342 
343                 }
344 
345         }
346 
347         /**
348          * a valid transfer token issued, then modified out of band, this should
349          * fail
350          */
351         @Test
352         public void InvalidTransferTokenModified() {
353              Assume.assumeTrue(TckPublisher.isEnabled());
354                 String keySamBiz = null;
355                 String keyJoeBiz = null;
356                 try {
357                         DatatypeFactory df = DatatypeFactory.newInstance();
358                         GregorianCalendar gcal = new GregorianCalendar();
359                         gcal.setTimeInMillis(System.currentTimeMillis());
360                         XMLGregorianCalendar xcal = df.newXMLGregorianCalendar(gcal);
361 
362 
363                         BusinessEntity myBusEntity = new BusinessEntity();
364                         Name myBusName = new Name();
365                         myBusName.setLang("en");
366                         myBusName.setValue("InvalidTransferTokenModified UDDI's Business" + " " + xcal.toString());
367                         myBusEntity.getName().add(myBusName);
368                         myBusEntity.setBusinessServices(new BusinessServices());
369                         myBusEntity.getBusinessServices().getBusinessService().add(CreateBusiness("UDDI"));
370                         SaveBusiness sb = new SaveBusiness();
371                         sb.getBusinessEntity().add(myBusEntity);
372                         sb.setAuthInfo(authInfoJoe);
373                         BusinessDetail bd = publishJoe.saveBusiness(sb);
374 
375                         keyJoeBiz = bd.getBusinessEntity().get(0).getBusinessKey();
376 
377 
378 
379                         myBusEntity = new BusinessEntity();
380                         myBusName = new Name();
381                         myBusName.setLang("en");
382                         myBusName.setValue("Root's Business" + " " + xcal.toString());
383                         myBusEntity.getName().add(myBusName);
384                         myBusEntity.setBusinessServices(new BusinessServices());
385                         myBusEntity.getBusinessServices().getBusinessService().add(CreateBusiness("root"));
386                         sb = new SaveBusiness();
387                         sb.getBusinessEntity().add(myBusEntity);
388                         sb.setAuthInfo(authInfoSam);
389                         bd = publishSam.saveBusiness(sb);
390 
391                         keySamBiz = bd.getBusinessEntity().get(0).getBusinessKey();
392                         //String keySamBizSvc = bd.getBusinessEntity().get(0).getBusinessServices().getBusinessService().get(0).getServiceKey();
393 
394                         //transfers from Joe to Sam
395                         KeyBag kb = new KeyBag();
396                         kb.getKey().add(keyJoeBiz);
397 
398                         Holder<String> nodeidOUT = new Holder<String>();
399                         Holder<XMLGregorianCalendar> expiresOUT = new Holder<XMLGregorianCalendar>();
400                         Holder<byte[]> tokenOUT = new Holder<byte[]>();
401                         custodyTransferPortTypeJoe.getTransferToken(authInfoJoe, kb, nodeidOUT, expiresOUT, tokenOUT);
402 
403 
404                         //sam accepts
405                         TransferEntities te = new TransferEntities();
406                         te.setAuthInfo(authInfoSam);
407                         te.setKeyBag(kb);
408                         te.getKeyBag().getKey().add("uddi:uddi.joepublisher.com:" + UUID.randomUUID().toString());
409                         TransferToken tt = new TransferToken();
410                         tt.setExpirationTime(expiresOUT.value);
411                         tt.setNodeID(nodeidOUT.value);
412                         tt.setOpaqueToken(tokenOUT.value);
413                         te.setTransferToken(tt);
414 
415                         custodyTransferPortTypeSam.transferEntities(te);
416                         Assert.fail();
417                 } catch (Exception ex) {
418                         //  HandleException(ex);
419                         logger.info("Expected exception: " + ex.getMessage());
420                 } finally {
421                         TckCommon.DeleteBusiness(keyJoeBiz, authInfoJoe, publishJoe);
422                         TckCommon.DeleteBusiness(keySamBiz, authInfoSam, publishSam);
423                 }
424 
425         }
426 
427         @Test
428         public void InvalidTransferTokenServiceDoesntExist() throws Exception {
429              Assume.assumeTrue(TckPublisher.isEnabled());
430                 try {
431                         //transfers from Joe to Sam
432                         KeyBag kb = new KeyBag();
433                         kb.getKey().add("uddi:uddi.joepublisher.com:" + UUID.randomUUID().toString());
434 
435                         Holder<String> nodeidOUT = new Holder<String>();
436                         Holder<XMLGregorianCalendar> expiresOUT = new Holder<XMLGregorianCalendar>();
437                         Holder<byte[]> tokenOUT = new Holder<byte[]>();
438                         custodyTransferPortTypeJoe.getTransferToken(authInfoJoe, kb, nodeidOUT, expiresOUT, tokenOUT);
439                         Assert.fail();
440                 } catch (Exception ex) {
441                         //HandleException(ex);
442                         logger.info("Expected exception: " + ex.getMessage());
443                 }
444         }
445 
446         @Test
447         public void ExpiredTransferToken() {
448                 //TODO
449         }
450 }