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.api.impl;
16
17 import java.rmi.RemoteException;
18 import java.util.List;
19 import java.util.UUID;
20
21 import org.apache.commons.configuration.ConfigurationException;
22 import org.apache.commons.logging.Log;
23 import org.apache.commons.logging.LogFactory;
24 import org.apache.juddi.Registry;
25 import org.apache.juddi.api_v3.AccessPointType;
26 import org.apache.juddi.v3.error.InvalidKeyPassedException;
27 import org.apache.juddi.v3.error.ValueNotAllowedException;
28 import org.apache.juddi.v3.tck.TckPublisher;
29 import org.apache.juddi.v3.tck.TckSecurity;
30 import org.apache.juddi.v3.tck.TckTModel;
31 import org.junit.AfterClass;
32 import org.junit.Assert;
33 import org.junit.BeforeClass;
34 import org.junit.Test;
35 import org.uddi.api_v3.AccessPoint;
36 import org.uddi.api_v3.Address;
37 import org.uddi.api_v3.AddressLine;
38 import org.uddi.api_v3.BindingTemplate;
39 import org.uddi.api_v3.BindingTemplates;
40 import org.uddi.api_v3.BusinessDetail;
41 import org.uddi.api_v3.BusinessEntity;
42 import org.uddi.api_v3.BusinessInfos;
43 import org.uddi.api_v3.BusinessService;
44 import org.uddi.api_v3.BusinessServices;
45 import org.uddi.api_v3.CategoryBag;
46 import org.uddi.api_v3.Contact;
47 import org.uddi.api_v3.Contacts;
48 import org.uddi.api_v3.DeleteBusiness;
49 import org.uddi.api_v3.DeleteTModel;
50 import org.uddi.api_v3.Description;
51 import org.uddi.api_v3.DiscoveryURL;
52 import org.uddi.api_v3.DiscoveryURLs;
53 import org.uddi.api_v3.Email;
54 import org.uddi.api_v3.HostingRedirector;
55 import org.uddi.api_v3.KeyedReference;
56 import org.uddi.api_v3.Name;
57 import org.uddi.api_v3.PersonName;
58 import org.uddi.api_v3.Phone;
59 import org.uddi.api_v3.SaveBusiness;
60 import org.uddi.api_v3.SaveTModel;
61 import org.uddi.api_v3.ServiceInfos;
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
69
70
71
72
73
74
75
76
77
78
79
80
81 public class API_140_NegativePublicationTest {
82
83 private static Log logger = LogFactory.getLog(API_140_NegativePublicationTest.class);
84 static UDDISecurityPortType security = new UDDISecurityImpl();
85 static UDDIInquiryPortType inquiry = new UDDIInquiryImpl();
86 static UDDIPublicationPortType publication = new UDDIPublicationImpl();
87 static TckTModel tckTModel = new TckTModel(new UDDIPublicationImpl(), new UDDIInquiryImpl());
88
89 protected static String authInfoJoe = null;
90 protected static String authInfoSam = null;
91 static final String str256 = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
92 static final String str255 = "uddi:tmodelkey:categories:1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
93 static final String strkey256 = "uddi:tmodelkey:categories:11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
94 static final String strkey256_1 = "uddi:org.apache:omething.something.something.something.something.something.something.something.something.something.something.something.something.something.something.something.something.something.something.something.something.something.something.somethi.com";
95 static final String str26 = "11111111111111111111111111";
96 static final String str27 = "111111111111111111111111110";
97 static final String str10 = "0123456789";
98 static final String str11 = "01234567890";
99 static final String str80 = "01234567890123456789012345678901234567890123456789012345678901234567890123456789";
100 static final String str81 = "012345678901234567890123456789012345678901234567890123456789012345678901234567891";
101 static final String TRANS = "rolled back";
102 static final String str4096 = "12345670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234567000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123456700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012345670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234567000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123456700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012345670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234567000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000XXXXXXXX";
103 static final String str4097 = "12345670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234567000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123456700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012345670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234567000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123456700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012345670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234567000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000XXXXXXXXZ";
104 static final String str51 = "111111111111111111111111111111111111111111111111111";
105 static final String str50 = "11111111111111111111111111111111111111111111111111";
106 static final String MISSING_RESOURCE = "Can't find resource for bundle";
107
108 @AfterClass
109 public static void stopManager() throws ConfigurationException {
110 Registry.stop();
111 }
112
113 @BeforeClass
114 public static void startManager() throws ConfigurationException {
115 Registry.start();
116
117 logger.debug("Getting auth tokens..");
118 try {
119 authInfoJoe = TckSecurity.getAuthToken(security, TckPublisher.getJoePublisherId(), TckPublisher.getJoePassword());
120 authInfoSam = TckSecurity.getAuthToken(security, TckPublisher.getSamPublisherId(), TckPublisher.getSamPassword());
121 Assert.assertNotNull(authInfoJoe);
122 Assert.assertNotNull(authInfoSam);
123 String authInfoUDDI = TckSecurity.getAuthToken(security, TckPublisher.getUDDIPublisherId(), TckPublisher.getUDDIPassword());
124 tckTModel.saveUDDIPublisherTmodel(authInfoUDDI);
125 tckTModel.saveTModels(authInfoUDDI, TckTModel.TMODELS_XML);
126 tckTModel.saveJoePublisherTmodel(authInfoJoe);
127 } catch (Exception e) {
128 logger.error(e.getMessage(), e);
129 Assert.fail("Could not obtain authInfo token.");
130 }
131 }
132
133 static void HandleException(Exception ex) {
134 if (logger.isDebugEnabled()) {
135 System.err.println("Error caught of type " + ex.getClass().getCanonicalName());
136 ex.printStackTrace();
137 }
138 Assert.assertFalse(ex.getMessage().toLowerCase().contains(TRANS.toLowerCase()));
139 Assert.assertFalse(ex.getMessage().toLowerCase().contains(MISSING_RESOURCE.toLowerCase()));
140 if (! (ex instanceof ValueNotAllowedException)) {
141 Assert.fail();
142 }
143 }
144
145
146 @Test
147 public void BusinessNameSanityTest() {
148 System.out.println("BusinessNameSanityTest");
149 }
150
151 @Test(expected = ValueNotAllowedException.class)
152 public void BusinessKeyTooLongTest() throws DispositionReportFaultMessage, RemoteException {
153 System.out.println("BusinessKeyTooLongTest");
154 SaveBusiness sb = new SaveBusiness();
155 sb.setAuthInfo(authInfoJoe);
156 BusinessEntity be = new BusinessEntity();
157 Name n = new Name();
158 n.setValue("Hello Nurse");
159 be.getName().add(n);
160 be.setBusinessKey(strkey256_1);
161 sb.getBusinessEntity().add(be);
162 try {
163 BusinessDetail saveBusiness = publication.saveBusiness(sb);
164 DeleteBusiness db = new DeleteBusiness();
165 db.setAuthInfo(authInfoJoe);
166 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
167 publication.deleteBusiness(db);
168 Assert.fail("request should have been rejected");
169 } catch (ValueNotAllowedException ex) {
170 HandleException(ex);
171 throw ex;
172 }
173 }
174
175 @Test(expected = ValueNotAllowedException.class)
176 public void BusinessNameTooShortTest() throws DispositionReportFaultMessage, RemoteException {
177 System.out.println("BusinessNameTooShortTest");
178 SaveBusiness sb = new SaveBusiness();
179 sb.setAuthInfo(authInfoJoe);
180 BusinessEntity be = new BusinessEntity();
181 Name n = new Name();
182 n.setValue("");
183 be.getName().add(n);
184 sb.getBusinessEntity().add(be);
185 try {
186 BusinessDetail saveBusiness = publication.saveBusiness(sb);
187 DeleteBusiness db = new DeleteBusiness();
188 db.setAuthInfo(authInfoJoe);
189 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
190 publication.deleteBusiness(db);
191 Assert.fail("request should have been rejected");
192 } catch (ValueNotAllowedException ex) {
193 HandleException(ex);
194 throw ex;
195 }
196 }
197
198 @Test
199 public void BusinessNameMinLengthTest() throws DispositionReportFaultMessage, RemoteException {
200 System.out.println("BusinessNameMinLengthTest");
201 SaveBusiness sb = new SaveBusiness();
202 sb.setAuthInfo(authInfoJoe);
203 BusinessEntity be = new BusinessEntity();
204 Name n = new Name();
205 n.setValue("1");
206 be.getName().add(n);
207 sb.getBusinessEntity().add(be);
208 BusinessDetail saveBusiness = publication.saveBusiness(sb);
209 DeleteBusiness db = new DeleteBusiness();
210 db.setAuthInfo(authInfoJoe);
211 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
212 publication.deleteBusiness(db);
213 }
214
215 @Test(expected = ValueNotAllowedException.class)
216 public void BusinessNameTooLongTest() throws DispositionReportFaultMessage, RemoteException {
217 System.out.println("BusinessNameTooLongTest");
218 SaveBusiness sb = new SaveBusiness();
219 sb.setAuthInfo(authInfoJoe);
220 BusinessEntity be = new BusinessEntity();
221 Name n = new Name();
222
223 n.setValue(str256);
224 be.getName().add(n);
225 sb.getBusinessEntity().add(be);
226 try {
227 BusinessDetail saveBusiness = publication.saveBusiness(sb);
228 DeleteBusiness db = new DeleteBusiness();
229 db.setAuthInfo(authInfoJoe);
230 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
231 publication.deleteBusiness(db);
232 Assert.fail("request should have been rejected");
233 } catch (ValueNotAllowedException ex) {
234 HandleException(ex);
235 throw ex;
236 }
237
238 }
239
240 @Test
241 public void BusinessNameMaxLengthTest() throws DispositionReportFaultMessage, RemoteException {
242 System.out.println("BusinessNameMaxLengthTest");
243 SaveBusiness sb = new SaveBusiness();
244 sb.setAuthInfo(authInfoJoe);
245 BusinessEntity be = new BusinessEntity();
246 Name n = new Name();
247
248 n.setValue(str255);
249 be.getName().add(n);
250 sb.getBusinessEntity().add(be);
251 BusinessDetail saveBusiness = publication.saveBusiness(sb);
252 DeleteBusiness db = new DeleteBusiness();
253 db.setAuthInfo(authInfoJoe);
254 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
255 publication.deleteBusiness(db);
256 }
257
258 @Test(expected = ValueNotAllowedException.class)
259 public void BusinessNameLangTooLongTest() throws DispositionReportFaultMessage, RemoteException {
260 System.out.println("BusinessNameLangTooLongTest");
261 SaveBusiness sb = new SaveBusiness();
262 sb.setAuthInfo(authInfoJoe);
263 BusinessEntity be = new BusinessEntity();
264 Name n = new Name();
265
266 n.setValue("A Test business");
267
268 n.setLang(str27);
269 be.getName().add(n);
270 sb.getBusinessEntity().add(be);
271 try {
272 BusinessDetail saveBusiness = publication.saveBusiness(sb);
273 DeleteBusiness db = new DeleteBusiness();
274 db.setAuthInfo(authInfoJoe);
275 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
276 publication.deleteBusiness(db);
277 Assert.fail("request should have been rejected");
278 } catch (ValueNotAllowedException ex) {
279 HandleException(ex);
280 throw ex;
281 }
282
283 }
284
285 @Test
286 public void BusinessNameLangMaxLengthTest() throws DispositionReportFaultMessage, RemoteException {
287 System.out.println("BusinessNameLangMaxLengthTest");
288 SaveBusiness sb = new SaveBusiness();
289 sb.setAuthInfo(authInfoJoe);
290 BusinessEntity be = new BusinessEntity();
291 Name n = new Name();
292
293 n.setValue("A Test business");
294 n.setLang(str26);
295
296 be.getName().add(n);
297 sb.getBusinessEntity().add(be);
298 BusinessDetail saveBusiness = publication.saveBusiness(sb);
299 DeleteBusiness db = new DeleteBusiness();
300 db.setAuthInfo(authInfoJoe);
301 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
302 publication.deleteBusiness(db);
303 }
304
305 @Test(expected = ValueNotAllowedException.class)
306 public void BusinessDescriptionLangTooLongTest() throws DispositionReportFaultMessage, RemoteException {
307 System.out.println("BusinessDescriptionLangTooLongTest");
308 SaveBusiness sb = new SaveBusiness();
309 sb.setAuthInfo(authInfoJoe);
310 BusinessEntity be = new BusinessEntity();
311 Name n = new Name();
312
313 n.setValue("A Test business");
314 Description d = new Description();
315 d.setValue("a description");
316
317 d.setLang(str27);
318 be.getName().add(n);
319 be.getDescription().add(d);
320 sb.getBusinessEntity().add(be);
321 try {
322 BusinessDetail saveBusiness = publication.saveBusiness(sb);
323 DeleteBusiness db = new DeleteBusiness();
324 db.setAuthInfo(authInfoJoe);
325 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
326 publication.deleteBusiness(db);
327 Assert.fail("request should have been rejected");
328 } catch (ValueNotAllowedException ex) {
329 HandleException(ex);
330 throw ex;
331 }
332
333 }
334
335 @Test
336 public void BusinessDescriptionLangMaxLengthTest() throws DispositionReportFaultMessage, RemoteException {
337 System.out.println("BusinessDescriptionLangMaxLengthTest");
338 SaveBusiness sb = new SaveBusiness();
339 sb.setAuthInfo(authInfoJoe);
340 BusinessEntity be = new BusinessEntity();
341 Name n = new Name();
342
343 n.setValue("A Test business");
344 Description d = new Description();
345 d.setValue("a description");
346
347 d.setLang(str26);
348 be.getDescription().add(d);
349 be.getName().add(n);
350 sb.getBusinessEntity().add(be);
351 BusinessDetail saveBusiness = publication.saveBusiness(sb);
352 DeleteBusiness db = new DeleteBusiness();
353 db.setAuthInfo(authInfoJoe);
354 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
355 publication.deleteBusiness(db);
356 }
357
358 @Test
359 public void BusinessDescriptionMaxLengthTest() throws DispositionReportFaultMessage, RemoteException {
360 System.out.println("BusinessDescriptionMaxLengthTest");
361 SaveBusiness sb = new SaveBusiness();
362 sb.setAuthInfo(authInfoJoe);
363 BusinessEntity be = new BusinessEntity();
364 Name n = new Name();
365
366 n.setValue("A Test business");
367 Description d = new Description();
368 d.setValue(str255);
369 be.getDescription().add(d);
370 be.getName().add(n);
371 sb.getBusinessEntity().add(be);
372
373 BusinessDetail saveBusiness = publication.saveBusiness(sb);
374 DeleteBusiness db = new DeleteBusiness();
375 db.setAuthInfo(authInfoJoe);
376 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
377 publication.deleteBusiness(db);
378 }
379
380 @Test(expected = ValueNotAllowedException.class)
381 public void BusinessDescriptionTooLongLengthTest() throws DispositionReportFaultMessage, RemoteException {
382 System.out.println("BusinessDescriptionTooLongLengthTest");
383 SaveBusiness sb = new SaveBusiness();
384 sb.setAuthInfo(authInfoJoe);
385 BusinessEntity be = new BusinessEntity();
386 Name n = new Name();
387
388 n.setValue("A Test business");
389 Description d = new Description();
390 d.setValue(str256);
391 be.getDescription().add(d);
392 be.getName().add(n);
393 sb.getBusinessEntity().add(be);
394 try {
395 BusinessDetail saveBusiness = publication.saveBusiness(sb);
396 DeleteBusiness db = new DeleteBusiness();
397 db.setAuthInfo(authInfoJoe);
398 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
399 publication.deleteBusiness(db);
400 Assert.fail("request should have been rejected");
401 } catch (ValueNotAllowedException ex) {
402 HandleException(ex);
403 throw ex;
404 }
405
406 }
407
408 @Test(expected = ValueNotAllowedException.class)
409 public void BusinessDiscoveryURLTooLongTest() throws DispositionReportFaultMessage, RemoteException {
410 System.out.println("BusinessDiscoveryURLTooLongTest");
411 SaveBusiness sb = new SaveBusiness();
412 sb.setAuthInfo(authInfoJoe);
413 BusinessEntity be = new BusinessEntity();
414 Name n = new Name();
415
416 n.setValue("A Test business");
417 be.getName().add(n);
418 be.setDiscoveryURLs(new DiscoveryURLs());
419 DiscoveryURL d = new DiscoveryURL();
420 d.setValue(str4097);
421 be.getDiscoveryURLs().getDiscoveryURL().add(d);
422 sb.getBusinessEntity().add(be);
423 try {
424 BusinessDetail saveBusiness = publication.saveBusiness(sb);
425 DeleteBusiness db = new DeleteBusiness();
426 db.setAuthInfo(authInfoJoe);
427 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
428 publication.deleteBusiness(db);
429 Assert.fail("request should have been rejected");
430 } catch (ValueNotAllowedException ex) {
431 HandleException(ex);
432 throw ex;
433 }
434
435 }
436
437 @Test
438 public void BusinessDiscoveryURLMaxLengthTest() throws DispositionReportFaultMessage, RemoteException {
439 System.out.println("BusinessDiscoveryURLMaxLengthTest");
440 SaveBusiness sb = new SaveBusiness();
441 sb.setAuthInfo(authInfoJoe);
442 BusinessEntity be = new BusinessEntity();
443 Name n = new Name();
444
445 n.setValue("A Test business");
446 be.getName().add(n);
447 be.setDiscoveryURLs(new DiscoveryURLs());
448 DiscoveryURL d = new DiscoveryURL();
449 d.setValue(str4096);
450 be.getDiscoveryURLs().getDiscoveryURL().add(d);
451 sb.getBusinessEntity().add(be);
452
453 BusinessDetail saveBusiness = publication.saveBusiness(sb);
454 DeleteBusiness db = new DeleteBusiness();
455 db.setAuthInfo(authInfoJoe);
456 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
457 publication.deleteBusiness(db);
458 }
459
460 @Test
461 public void BusinessDiscoveryURLMaxLengthMaxUseTypeTest() throws DispositionReportFaultMessage, RemoteException {
462 System.out.println("BusinessDiscoveryURLMaxLengthMaxUseTypeTest");
463 SaveBusiness sb = new SaveBusiness();
464 sb.setAuthInfo(authInfoJoe);
465 BusinessEntity be = new BusinessEntity();
466 Name n = new Name();
467
468 n.setValue("A Test business");
469 be.getName().add(n);
470 be.setDiscoveryURLs(new DiscoveryURLs());
471 DiscoveryURL d = new DiscoveryURL();
472 d.setValue(str4096);
473 d.setUseType(str255);
474 be.getDiscoveryURLs().getDiscoveryURL().add(d);
475 sb.getBusinessEntity().add(be);
476
477 BusinessDetail saveBusiness = publication.saveBusiness(sb);
478 DeleteBusiness db = new DeleteBusiness();
479 db.setAuthInfo(authInfoJoe);
480 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
481 publication.deleteBusiness(db);
482 }
483
484 @Test(expected = ValueNotAllowedException.class)
485 public void BusinessDiscoveryURLMaxLengthToolongUseTypeTest() throws DispositionReportFaultMessage, RemoteException {
486 System.out.println("BusinessDiscoveryURLMaxLengthToolongUseTypeTest");
487 SaveBusiness sb = new SaveBusiness();
488 sb.setAuthInfo(authInfoJoe);
489 BusinessEntity be = new BusinessEntity();
490 Name n = new Name();
491
492 n.setValue("A Test business");
493 be.getName().add(n);
494 be.setDiscoveryURLs(new DiscoveryURLs());
495 DiscoveryURL d = new DiscoveryURL();
496 d.setValue(str4096);
497 d.setUseType(str256);
498 be.getDiscoveryURLs().getDiscoveryURL().add(d);
499 sb.getBusinessEntity().add(be);
500 try {
501 BusinessDetail saveBusiness = publication.saveBusiness(sb);
502 DeleteBusiness db = new DeleteBusiness();
503 db.setAuthInfo(authInfoJoe);
504 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
505 publication.deleteBusiness(db);
506 Assert.fail("request should have been rejected");
507 } catch (ValueNotAllowedException ex) {
508 HandleException(ex);
509 throw ex;
510 }
511 }
512
513 @Test
514 public void ContactMaxEmailMaxUseTypeTest() throws DispositionReportFaultMessage, RemoteException {
515 System.out.println("ContactMaxEmailMaxUseTypeTest");
516 SaveBusiness sb = new SaveBusiness();
517 sb.setAuthInfo(authInfoJoe);
518 BusinessEntity be = new BusinessEntity();
519 Name n = new Name();
520 n.setValue("A Test business");
521 be.getName().add(n);
522 be.setContacts(ContactMaxEmailMaxUseType());
523 sb.getBusinessEntity().add(be);
524
525 BusinessDetail saveBusiness = publication.saveBusiness(sb);
526 DeleteBusiness db = new DeleteBusiness();
527 db.setAuthInfo(authInfoJoe);
528 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
529 publication.deleteBusiness(db);
530 }
531
532 private Contacts ContactMaxEmailMaxUseType() {
533 Contacts cc = new Contacts();
534 Contact c = new Contact();
535 PersonName n = new PersonName();
536 n.setValue("Bob");
537 c.getPersonName().add(n);
538 Email m = new Email();
539 m.setValue(str255);
540 m.setUseType(str255);
541 c.getEmail().add(m);
542 cc.getContact().add(c);;
543 return cc;
544 }
545
546 private Contacts ContactTooLongEmailMaxUseType() {
547 Contacts cc = new Contacts();
548 Contact c = new Contact();
549 PersonName n = new PersonName();
550 n.setValue("Bob");
551 c.getPersonName().add(n);
552 Email m = new Email();
553 m.setValue(str256);
554 m.setUseType(str255);
555 c.getEmail().add(m);
556 cc.getContact().add(c);;
557 return cc;
558 }
559
560 private Contacts ContactEmailUseTypeToolong() {
561 Contacts cc = new Contacts();
562 Contact c = new Contact();
563 PersonName n = new PersonName();
564 n.setValue("Bob");
565 c.getPersonName().add(n);
566 Email m = new Email();
567 m.setValue(str255);
568 m.setUseType(str256);
569 c.getEmail().add(m);
570 cc.getContact().add(c);;
571 return cc;
572 }
573
574 private Contacts ContactMaxDescription() {
575 Contacts cc = new Contacts();
576 Contact c = new Contact();
577 PersonName n = new PersonName();
578 n.setValue("Bob");
579 c.getPersonName().add(n);
580 Email m = new Email();
581 m.setValue(str255);
582 m.setUseType(str255);
583 c.getEmail().add(m);
584 Description d = new Description();
585 d.setLang(str26);
586 d.setValue(str255);
587 c.getDescription().add(d);
588 cc.getContact().add(c);;
589 return cc;
590 }
591
592 private Contacts ContactDescriptionTooLong() {
593 Contacts cc = new Contacts();
594 Contact c = new Contact();
595 PersonName n = new PersonName();
596 n.setValue("Bob");
597 c.getPersonName().add(n);
598 Email m = new Email();
599 m.setValue(str255);
600 m.setUseType(str255);
601 c.getEmail().add(m);
602 Description d = new Description();
603 d.setLang(str256);
604 d.setValue(str26);
605 c.getDescription().add(d);
606 cc.getContact().add(c);;
607 return cc;
608 }
609
610 private Contacts ContactPhoneTooLong() {
611 Contacts cc = new Contacts();
612 Contact c = new Contact();
613 PersonName n = new PersonName();
614 n.setValue("Bob");
615 c.getPersonName().add(n);
616 Phone p = new Phone();
617 p.setValue(str51);
618 c.getPhone().add(p);
619 cc.getContact().add(c);;
620 return cc;
621 }
622
623 private Contacts ContactPhoneUseTypeTooLong() {
624 Contacts cc = new Contacts();
625 Contact c = new Contact();
626 PersonName n = new PersonName();
627 n.setValue("Bob");
628 c.getPersonName().add(n);
629 Phone p = new Phone();
630 p.setValue(str50);
631 p.setUseType(str256);
632 c.getPhone().add(p);
633 cc.getContact().add(c);;
634 return cc;
635 }
636
637 private Contacts ContactPhoneUseTypeMaxLen() {
638 Contacts cc = new Contacts();
639 Contact c = new Contact();
640 PersonName n = new PersonName();
641 n.setValue("Bob");
642 c.getPersonName().add(n);
643 Phone p = new Phone();
644 p.setValue(str50);
645 p.setUseType(str255);
646 c.getPhone().add(p);
647 cc.getContact().add(c);;
648 return cc;
649 }
650
651 private Contacts ContactPhoneMaxLength() {
652 Contacts cc = new Contacts();
653 Contact c = new Contact();
654 PersonName n = new PersonName();
655 n.setValue("Bob");
656 c.getPersonName().add(n);
657 Phone p = new Phone();
658 p.setValue(str50);
659 c.getPhone().add(p);
660 cc.getContact().add(c);;
661 return cc;
662 }
663
664 private Contacts ContactAddressAllMax(boolean oversizedLang, boolean oversizedTmodel, boolean oversizedSortCode, boolean oversizedUseType,
665 boolean oversizedAddressLineValue, boolean oversizedAddressKN, boolean oversizedAddressKV) {
666 Contacts cc = new Contacts();
667 Contact c = new Contact();
668 PersonName n = new PersonName();
669 n.setValue("Bob");
670 c.getPersonName().add(n);
671
672 cc.getContact().add(c);
673 Address a = new Address();
674 if (oversizedSortCode) {
675 a.setSortCode(str11);
676 } else {
677 a.setSortCode(str10);
678 }
679 if (oversizedLang) {
680 a.setLang(str27);
681 } else {
682 a.setLang(str26);
683 }
684 if (oversizedTmodel) {
685 a.setTModelKey(str256);
686 } else {
687 a.setTModelKey(str255);
688 }
689 if (oversizedUseType) {
690 a.setUseType(str256);
691 } else {
692 a.setUseType(str255);
693 }
694 if (oversizedSortCode) {
695 a.setSortCode(str11);
696 } else {
697 a.setSortCode(str10);
698 }
699 AddressLine al = new AddressLine();
700 if (oversizedAddressKN) {
701 al.setKeyName(str256);
702 } else {
703 al.setKeyName(str255);
704 }
705 if (oversizedAddressKV) {
706 al.setKeyValue(str256);
707 } else {
708 al.setKeyValue(str255);
709 }
710 if (oversizedAddressLineValue) {
711 al.setValue(str81);
712 } else {
713 al.setValue(str80);
714 }
715 a.getAddressLine().add(al);
716 c.getAddress().add(a);
717 return cc;
718 }
719
720 private Contacts ContactDescriptionLangTooLong() {
721 Contacts cc = new Contacts();
722 Contact c = new Contact();
723 PersonName n = new PersonName();
724 n.setValue("Bob");
725 c.getPersonName().add(n);
726 Email m = new Email();
727 m.setValue(str255);
728 m.setUseType(str255);
729 c.getEmail().add(m);
730 Description d = new Description();
731 d.setLang(str255);
732 d.setValue(str27);
733 c.getDescription().add(d);
734 cc.getContact().add(c);
735 return cc;
736 }
737
738 @Test(expected = ValueNotAllowedException.class)
739 public void ContactTooLongEmailMaxUseTypeTest() throws DispositionReportFaultMessage, RemoteException {
740 System.out.println("ContactTooLongEmailMaxUseTypeTest");
741 SaveBusiness sb = new SaveBusiness();
742 sb.setAuthInfo(authInfoJoe);
743 BusinessEntity be = new BusinessEntity();
744 Name n = new Name();
745 n.setValue("A Test business");
746 be.getName().add(n);
747 be.setContacts(ContactTooLongEmailMaxUseType());
748 sb.getBusinessEntity().add(be);
749 try {
750 BusinessDetail saveBusiness = publication.saveBusiness(sb);
751 DeleteBusiness db = new DeleteBusiness();
752 db.setAuthInfo(authInfoJoe);
753 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
754 publication.deleteBusiness(db);
755 Assert.fail("request should have been rejected");
756
757 } catch (ValueNotAllowedException ex) {
758 HandleException(ex);
759 throw ex;
760 }
761 }
762
763 @Test(expected = ValueNotAllowedException.class)
764 public void ContactMaxEmailToolongUseTypeTest() throws DispositionReportFaultMessage, RemoteException {
765 System.out.println("ContactMaxEmailToolongUseTypeTest");
766 SaveBusiness sb = new SaveBusiness();
767 sb.setAuthInfo(authInfoJoe);
768 BusinessEntity be = new BusinessEntity();
769 Name n = new Name();
770 n.setValue("A Test business");
771 be.getName().add(n);
772
773 be.setContacts(ContactEmailUseTypeToolong());
774
775
776 sb.getBusinessEntity().add(be);
777 try {
778 BusinessDetail saveBusiness = publication.saveBusiness(sb);
779 DeleteBusiness db = new DeleteBusiness();
780 db.setAuthInfo(authInfoJoe);
781 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
782 publication.deleteBusiness(db);
783 Assert.fail("request should have been rejected");
784
785 } catch (ValueNotAllowedException ex) {
786 HandleException(ex);
787 throw ex;
788 }
789 }
790
791 @Test
792 public void ContactDescriptionMaxLangMaxtest() throws DispositionReportFaultMessage, RemoteException {
793 System.out.println("ContactDescriptionMaxLangMaxtest");
794 SaveBusiness sb = new SaveBusiness();
795 sb.setAuthInfo(authInfoJoe);
796 BusinessEntity be = new BusinessEntity();
797 Name n = new Name();
798 n.setValue("A Test business");
799 be.getName().add(n);
800 be.setContacts(ContactMaxDescription());
801 sb.getBusinessEntity().add(be);
802
803 BusinessDetail saveBusiness = publication.saveBusiness(sb);
804 DeleteBusiness db = new DeleteBusiness();
805 db.setAuthInfo(authInfoJoe);
806 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
807 publication.deleteBusiness(db);
808
809 }
810
811 @Test (expected = ValueNotAllowedException.class)
812 public void ContactDescriptionTooLongtest() throws DispositionReportFaultMessage, RemoteException {
813 System.out.println("ContactDescriptionTooLongtest");
814 SaveBusiness sb = new SaveBusiness();
815 sb.setAuthInfo(authInfoJoe);
816 BusinessEntity be = new BusinessEntity();
817 Name n = new Name();
818 n.setValue("A Test business");
819 be.getName().add(n);
820 be.setContacts(ContactDescriptionTooLong());
821 sb.getBusinessEntity().add(be);
822 try {
823 BusinessDetail saveBusiness = publication.saveBusiness(sb);
824 DeleteBusiness db = new DeleteBusiness();
825 db.setAuthInfo(authInfoJoe);
826 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
827 publication.deleteBusiness(db);
828 Assert.fail("request should have been rejected");
829
830 } catch (ValueNotAllowedException ex) {
831 HandleException(ex);
832 throw ex;
833 }
834 }
835
836 @Test (expected = ValueNotAllowedException.class)
837 public void ContactDescriptionLangTooLongTest() throws DispositionReportFaultMessage, RemoteException {
838 System.out.println("ContactDescriptionLangTooLongTest");
839 SaveBusiness sb = new SaveBusiness();
840 sb.setAuthInfo(authInfoJoe);
841 BusinessEntity be = new BusinessEntity();
842 Name n = new Name();
843 n.setValue("A Test business");
844 be.getName().add(n);
845 be.setContacts(ContactDescriptionLangTooLong());
846 sb.getBusinessEntity().add(be);
847 try {
848 BusinessDetail saveBusiness = publication.saveBusiness(sb);
849 DeleteBusiness db = new DeleteBusiness();
850 db.setAuthInfo(authInfoJoe);
851 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
852 publication.deleteBusiness(db);
853 Assert.fail("request should have been rejected");
854
855 } catch (ValueNotAllowedException ex) {
856 HandleException(ex);
857 throw ex;
858 }
859 }
860
861 @Test
862 public void ContactPhoneMaxLentest() throws DispositionReportFaultMessage, RemoteException {
863 System.out.println("ContactPhoneMaxLentest");
864 SaveBusiness sb = new SaveBusiness();
865 sb.setAuthInfo(authInfoJoe);
866 BusinessEntity be = new BusinessEntity();
867 Name n = new Name();
868 n.setValue("A Test business");
869 be.getName().add(n);
870 be.setContacts(ContactPhoneMaxLength());
871 sb.getBusinessEntity().add(be);
872
873 BusinessDetail saveBusiness = publication.saveBusiness(sb);
874 DeleteBusiness db = new DeleteBusiness();
875 db.setAuthInfo(authInfoJoe);
876 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
877 publication.deleteBusiness(db);
878
879 }
880
881 @Test(expected=ValueNotAllowedException.class)
882 public void ContactPhoneTooLongtest() throws DispositionReportFaultMessage, RemoteException {
883 System.out.println("ContactPhoneTooLongtest");
884 SaveBusiness sb = new SaveBusiness();
885 sb.setAuthInfo(authInfoJoe);
886 BusinessEntity be = new BusinessEntity();
887 Name n = new Name();
888 n.setValue("A Test business");
889 be.getName().add(n);
890 be.setContacts(ContactPhoneTooLong());
891 sb.getBusinessEntity().add(be);
892 try {
893 BusinessDetail saveBusiness = publication.saveBusiness(sb);
894 DeleteBusiness db = new DeleteBusiness();
895 db.setAuthInfo(authInfoJoe);
896 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
897 publication.deleteBusiness(db);
898 Assert.fail("request should have been rejected");
899 } catch (ValueNotAllowedException ex) {
900 HandleException(ex);
901 throw ex;
902 }
903 }
904
905 @Test
906 public void ContactPhoneMaxLongtest() throws DispositionReportFaultMessage, RemoteException {
907 System.out.println("ContactPhoneMaxLongtest");
908 SaveBusiness sb = new SaveBusiness();
909 sb.setAuthInfo(authInfoJoe);
910 BusinessEntity be = new BusinessEntity();
911 Name n = new Name();
912 n.setValue("A Test business");
913 be.getName().add(n);
914 be.setContacts(ContactPhoneMaxLength());
915 sb.getBusinessEntity().add(be);
916 BusinessDetail saveBusiness = publication.saveBusiness(sb);
917 DeleteBusiness db = new DeleteBusiness();
918 db.setAuthInfo(authInfoJoe);
919 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
920 publication.deleteBusiness(db);
921 }
922
923 @Test
924 public void ContactPhoneMaxLongMaxUseTypetest() throws DispositionReportFaultMessage, RemoteException {
925 System.out.println("ContactPhoneMaxLongMaxUseTypetest");
926 SaveBusiness sb = new SaveBusiness();
927 sb.setAuthInfo(authInfoJoe);
928 BusinessEntity be = new BusinessEntity();
929 Name n = new Name();
930 n.setValue("A Test business");
931 be.getName().add(n);
932 be.setContacts(ContactPhoneUseTypeMaxLen());
933 sb.getBusinessEntity().add(be);
934
935 BusinessDetail saveBusiness = publication.saveBusiness(sb);
936 DeleteBusiness db = new DeleteBusiness();
937 db.setAuthInfo(authInfoJoe);
938 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
939 publication.deleteBusiness(db);
940 }
941
942 @Test(expected = ValueNotAllowedException.class)
943 public void ContactPhoneUseTypeTooLongtest() throws DispositionReportFaultMessage, RemoteException {
944 System.out.println("ContactPhoneUseTypeTooLongtest");
945 SaveBusiness sb = new SaveBusiness();
946 sb.setAuthInfo(authInfoJoe);
947 BusinessEntity be = new BusinessEntity();
948 Name n = new Name();
949 n.setValue("A Test business");
950 be.getName().add(n);
951 be.setContacts(ContactPhoneUseTypeTooLong());
952 sb.getBusinessEntity().add(be);
953 try {
954 BusinessDetail saveBusiness = publication.saveBusiness(sb);
955 DeleteBusiness db = new DeleteBusiness();
956 db.setAuthInfo(authInfoJoe);
957 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
958 publication.deleteBusiness(db);
959 Assert.fail("request should have been rejected");
960 } catch (ValueNotAllowedException ex) {
961 HandleException(ex);
962 throw ex;
963 }
964 }
965
966 @Test
967 public void ContactMaxAddressFFFFFFFtest() throws DispositionReportFaultMessage, RemoteException {
968 System.out.println("ContactMaxAddressFFFFFFFtest");
969 SaveBusiness sb = new SaveBusiness();
970 sb.setAuthInfo(authInfoJoe);
971 BusinessEntity be = new BusinessEntity();
972 Name n = new Name();
973 n.setValue("A Test business");
974 be.getName().add(n);
975 be.setContacts(ContactAddressAllMax(false, false, false, false, false, false, false));
976 sb.getBusinessEntity().add(be);
977
978 BusinessDetail saveBusiness = publication.saveBusiness(sb);
979 DeleteBusiness db = new DeleteBusiness();
980 db.setAuthInfo(authInfoJoe);
981 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
982 publication.deleteBusiness(db);
983
984 }
985
986 @Test(expected=ValueNotAllowedException.class)
987 public void ContactMaxAddressTFFFFFFtest() throws DispositionReportFaultMessage, RemoteException {
988 System.out.println("ContactMaxAddressTFFFFFFtest");
989 SaveBusiness sb = new SaveBusiness();
990 sb.setAuthInfo(authInfoJoe);
991 BusinessEntity be = new BusinessEntity();
992 Name n = new Name();
993 n.setValue("A Test business");
994 be.getName().add(n);
995 be.setContacts(ContactAddressAllMax(true, false, false, false, false, false, false));
996 sb.getBusinessEntity().add(be);
997 try {
998 BusinessDetail saveBusiness = publication.saveBusiness(sb);
999 DeleteBusiness db = new DeleteBusiness();
1000 db.setAuthInfo(authInfoJoe);
1001 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1002 publication.deleteBusiness(db);
1003 Assert.fail("request should have been rejected");
1004
1005 } catch (ValueNotAllowedException ex) {
1006 HandleException(ex);
1007 throw ex;
1008 }
1009 }
1010
1011 @Test(expected=ValueNotAllowedException.class)
1012 public void ContactMaxAddressFTFFFFFtest() throws DispositionReportFaultMessage, RemoteException {
1013 System.out.println("ContactMaxAddressFTFFFFFtest");
1014 SaveBusiness sb = new SaveBusiness();
1015 sb.setAuthInfo(authInfoJoe);
1016 BusinessEntity be = new BusinessEntity();
1017 Name n = new Name();
1018 n.setValue("A Test business");
1019 be.getName().add(n);
1020 be.setContacts(ContactAddressAllMax(false, true, false, false, false, false, false));
1021 sb.getBusinessEntity().add(be);
1022 try {
1023 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1024 DeleteBusiness db = new DeleteBusiness();
1025 db.setAuthInfo(authInfoJoe);
1026 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1027 publication.deleteBusiness(db);
1028 Assert.fail("request should have been rejected");
1029
1030 } catch (ValueNotAllowedException ex) {
1031 HandleException(ex);
1032 throw ex;
1033 }
1034 }
1035
1036 @Test(expected=ValueNotAllowedException.class)
1037 public void ContactMaxAddressFFTFFFFtest() throws DispositionReportFaultMessage, RemoteException {
1038 System.out.println("ContactMaxAddressFFTFFFFtest");
1039 SaveBusiness sb = new SaveBusiness();
1040 sb.setAuthInfo(authInfoJoe);
1041 BusinessEntity be = new BusinessEntity();
1042 Name n = new Name();
1043 n.setValue("A Test business");
1044 be.getName().add(n);
1045 be.setContacts(ContactAddressAllMax(false, false, true, false, false, false, false));
1046 sb.getBusinessEntity().add(be);
1047 try {
1048 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1049 DeleteBusiness db = new DeleteBusiness();
1050 db.setAuthInfo(authInfoJoe);
1051 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1052 publication.deleteBusiness(db);
1053 Assert.fail("request should have been rejected");
1054
1055 } catch (ValueNotAllowedException ex) {
1056 HandleException(ex);
1057 throw ex;
1058 }
1059 }
1060
1061 @Test(expected=ValueNotAllowedException.class)
1062 public void ContactMaxAddressFFFTFFFtest() throws DispositionReportFaultMessage, RemoteException {
1063 System.out.println("ContactMaxAddressFFFTFFFtest");
1064 SaveBusiness sb = new SaveBusiness();
1065 sb.setAuthInfo(authInfoJoe);
1066 BusinessEntity be = new BusinessEntity();
1067 Name n = new Name();
1068 n.setValue("A Test business");
1069 be.getName().add(n);
1070 be.setContacts(ContactAddressAllMax(false, false, false, true, false, false, false));
1071 sb.getBusinessEntity().add(be);
1072 try {
1073 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1074 DeleteBusiness db = new DeleteBusiness();
1075 db.setAuthInfo(authInfoJoe);
1076 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1077 publication.deleteBusiness(db);
1078 Assert.fail("request should have been rejected");
1079 } catch (ValueNotAllowedException ex) {
1080 HandleException(ex);
1081 throw ex;
1082 }
1083 }
1084
1085 @Test(expected=ValueNotAllowedException.class)
1086 public void ContactMaxAddressFFFFTFFtest() throws DispositionReportFaultMessage, RemoteException {
1087 System.out.println("ContactMaxAddressFFFFTFFtest");
1088 SaveBusiness sb = new SaveBusiness();
1089 sb.setAuthInfo(authInfoJoe);
1090 BusinessEntity be = new BusinessEntity();
1091 Name n = new Name();
1092 n.setValue("A Test business");
1093 be.getName().add(n);
1094 be.setContacts(ContactAddressAllMax(false, false, false, false, true, false, false));
1095 sb.getBusinessEntity().add(be);
1096 try {
1097 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1098 DeleteBusiness db = new DeleteBusiness();
1099 db.setAuthInfo(authInfoJoe);
1100 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1101 publication.deleteBusiness(db);
1102 Assert.fail("request should have been rejected");
1103
1104 } catch (ValueNotAllowedException ex) {
1105 HandleException(ex);
1106 throw ex;
1107 }
1108 }
1109
1110 @Test(expected=ValueNotAllowedException.class)
1111 public void ContactMaxAddressFFFFFTFtest() throws DispositionReportFaultMessage, RemoteException {
1112 System.out.println("ContactMaxAddressFFFFFTFtest");
1113 SaveBusiness sb = new SaveBusiness();
1114 sb.setAuthInfo(authInfoJoe);
1115 BusinessEntity be = new BusinessEntity();
1116 Name n = new Name();
1117 n.setValue("A Test business");
1118 be.getName().add(n);
1119 be.setContacts(ContactAddressAllMax(false, false, false, false, false, true, false));
1120 sb.getBusinessEntity().add(be);
1121 try {
1122 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1123 DeleteBusiness db = new DeleteBusiness();
1124 db.setAuthInfo(authInfoJoe);
1125 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1126 publication.deleteBusiness(db);
1127 Assert.fail("request should have been rejected");
1128
1129 } catch (ValueNotAllowedException ex) {
1130 HandleException(ex);
1131 throw ex;
1132 }
1133 }
1134
1135 @Test(expected=ValueNotAllowedException.class)
1136 public void ContactMaxAddressFFFFFFTtest() throws DispositionReportFaultMessage, RemoteException {
1137 System.out.println("ContactMaxAddressFFFFFFTtest");
1138 SaveBusiness sb = new SaveBusiness();
1139 sb.setAuthInfo(authInfoJoe);
1140 BusinessEntity be = new BusinessEntity();
1141 Name n = new Name();
1142 n.setValue("A Test business");
1143 be.getName().add(n);
1144 be.setContacts(ContactAddressAllMax(false, false, false, false, false, false, true));
1145 sb.getBusinessEntity().add(be);
1146 try {
1147 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1148 DeleteBusiness db = new DeleteBusiness();
1149 db.setAuthInfo(authInfoJoe);
1150 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1151 publication.deleteBusiness(db);
1152 Assert.fail("request should have been rejected");
1153
1154 } catch (ValueNotAllowedException ex) {
1155 HandleException(ex);
1156 throw ex;
1157 }
1158 }
1159
1160 @Test
1161 public void KeyReferenceMax() throws DispositionReportFaultMessage, RemoteException {
1162 System.out.println("KeyReferenceMax");
1163 SaveBusiness sb = new SaveBusiness();
1164 sb.setAuthInfo(authInfoJoe);
1165 BusinessEntity be = new BusinessEntity();
1166 Name n = new Name();
1167 n.setValue("A Test business");
1168 be.getName().add(n);
1169 be.setCategoryBag(new CategoryBag());
1170 KeyedReference kr = new KeyedReference();
1171 kr.setKeyName(str255);
1172 kr.setKeyValue(str255);
1173 kr.setTModelKey(str255);
1174 be.getCategoryBag().getKeyedReference().add(kr);
1175 sb.getBusinessEntity().add(be);
1176
1177 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1178 DeleteBusiness db = new DeleteBusiness();
1179 db.setAuthInfo(authInfoJoe);
1180 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1181 publication.deleteBusiness(db);
1182 }
1183
1184 @Test(expected=ValueNotAllowedException.class)
1185 public void KeyReferenceKeyTooLong() throws DispositionReportFaultMessage, RemoteException {
1186 System.out.println("KeyReferenceKeyTooLong");
1187 SaveBusiness sb = new SaveBusiness();
1188 sb.setAuthInfo(authInfoJoe);
1189 BusinessEntity be = new BusinessEntity();
1190 Name n = new Name();
1191 n.setValue("A Test business");
1192 be.getName().add(n);
1193 be.setCategoryBag(new CategoryBag());
1194 KeyedReference kr = new KeyedReference();
1195 kr.setKeyName(str255);
1196 kr.setKeyValue(str255);
1197 kr.setTModelKey(str256);
1198 be.getCategoryBag().getKeyedReference().add(kr);
1199 sb.getBusinessEntity().add(be);
1200 try {
1201 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1202 DeleteBusiness db = new DeleteBusiness();
1203 db.setAuthInfo(authInfoJoe);
1204 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1205 publication.deleteBusiness(db);
1206 Assert.fail("request should have been rejected");
1207
1208 } catch (ValueNotAllowedException ex) {
1209 HandleException(ex);
1210 throw ex;
1211 }
1212 }
1213
1214 @Test(expected=ValueNotAllowedException.class)
1215 public void KeyReferenceNameTooLong() throws DispositionReportFaultMessage, RemoteException {
1216 System.out.println("KeyReferenceNameTooLong");
1217 SaveBusiness sb = new SaveBusiness();
1218 sb.setAuthInfo(authInfoJoe);
1219 BusinessEntity be = new BusinessEntity();
1220 Name n = new Name();
1221 n.setValue("A Test business");
1222 be.getName().add(n);
1223 be.setCategoryBag(new CategoryBag());
1224 KeyedReference kr = new KeyedReference();
1225 kr.setKeyName(str256);
1226 kr.setKeyValue(str255);
1227 kr.setTModelKey(str255);
1228 be.getCategoryBag().getKeyedReference().add(kr);
1229 sb.getBusinessEntity().add(be);
1230 try {
1231 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1232 DeleteBusiness db = new DeleteBusiness();
1233 db.setAuthInfo(authInfoJoe);
1234 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1235 publication.deleteBusiness(db);
1236 Assert.fail("request should have been rejected");
1237
1238 } catch (ValueNotAllowedException ex) {
1239 HandleException(ex);
1240 throw ex;
1241 }
1242 }
1243
1244 @Test(expected=ValueNotAllowedException.class)
1245 public void KeyReferenceValueTooLong() throws DispositionReportFaultMessage, RemoteException {
1246 System.out.println("KeyReferenceValueTooLong");
1247 SaveBusiness sb = new SaveBusiness();
1248 sb.setAuthInfo(authInfoJoe);
1249 BusinessEntity be = new BusinessEntity();
1250 Name n = new Name();
1251 n.setValue("A Test business");
1252 be.getName().add(n);
1253 be.setCategoryBag(new CategoryBag());
1254 KeyedReference kr = new KeyedReference();
1255 kr.setKeyName(str255);
1256 kr.setKeyValue(str256);
1257 kr.setTModelKey(str255);
1258 be.getCategoryBag().getKeyedReference().add(kr);
1259 sb.getBusinessEntity().add(be);
1260 try {
1261 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1262 DeleteBusiness db = new DeleteBusiness();
1263 db.setAuthInfo(authInfoJoe);
1264 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1265 publication.deleteBusiness(db);
1266 Assert.fail("request should have been rejected");
1267
1268 } catch (ValueNotAllowedException ex) {
1269 HandleException(ex);
1270 throw ex;
1271 }
1272 }
1273
1274 @Test(expected=ValueNotAllowedException.class)
1275 public void ServiceNameTooLongTest() throws DispositionReportFaultMessage, RemoteException {
1276 System.out.println("ServiceNameTooLongTest");
1277 SaveBusiness sb = new SaveBusiness();
1278 sb.setAuthInfo(authInfoJoe);
1279 BusinessEntity be = new BusinessEntity();
1280 Name n = new Name();
1281 n.setValue("A Test business");
1282 be.getName().add(n);
1283 be.setBusinessServices(new BusinessServices());
1284 BusinessService bs = new BusinessService();
1285 n = new Name();
1286 n.setValue(str256);
1287 bs.getName().add(n);
1288 be.getBusinessServices().getBusinessService().add(bs);
1289
1290 sb.getBusinessEntity().add(be);
1291 try {
1292 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1293 DeleteBusiness db = new DeleteBusiness();
1294 db.setAuthInfo(authInfoJoe);
1295 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1296 publication.deleteBusiness(db);
1297 Assert.fail("request should have been rejected");
1298
1299 } catch (ValueNotAllowedException ex) {
1300 HandleException(ex);
1301 throw ex;
1302 }
1303 }
1304
1305 @Test
1306 public void ServiceNameMaxLenTest() throws DispositionReportFaultMessage, RemoteException {
1307 System.out.println("ServiceNameMaxLenTest");
1308 SaveBusiness sb = new SaveBusiness();
1309 sb.setAuthInfo(authInfoJoe);
1310 BusinessEntity be = new BusinessEntity();
1311 Name n = new Name();
1312 n.setValue("A Test business");
1313 be.getName().add(n);
1314 be.setBusinessServices(new BusinessServices());
1315 BusinessService bs = new BusinessService();
1316 n = new Name();
1317 n.setValue(str255);
1318 bs.getName().add(n);
1319 be.getBusinessServices().getBusinessService().add(bs);
1320
1321 sb.getBusinessEntity().add(be);
1322
1323 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1324 DeleteBusiness db = new DeleteBusiness();
1325 db.setAuthInfo(authInfoJoe);
1326 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1327 publication.deleteBusiness(db);
1328 }
1329
1330 @Test
1331 public void ServiceNameMaxLangLenTest() throws DispositionReportFaultMessage, RemoteException {
1332 System.out.println("ServiceNameMaxLangLenTest");
1333 SaveBusiness sb = new SaveBusiness();
1334 sb.setAuthInfo(authInfoJoe);
1335 BusinessEntity be = new BusinessEntity();
1336 Name n = new Name();
1337 n.setValue("A Test business");
1338 be.getName().add(n);
1339 be.setBusinessServices(new BusinessServices());
1340 BusinessService bs = new BusinessService();
1341 n = new Name();
1342 n.setValue(str255);
1343 n.setLang(str26);
1344 bs.getName().add(n);
1345 be.getBusinessServices().getBusinessService().add(bs);
1346
1347 sb.getBusinessEntity().add(be);
1348
1349 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1350 DeleteBusiness db = new DeleteBusiness();
1351 db.setAuthInfo(authInfoJoe);
1352 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1353 publication.deleteBusiness(db);
1354 }
1355
1356 @Test(expected=ValueNotAllowedException.class)
1357 public void ServiceNameTooLongLangTest() throws DispositionReportFaultMessage, RemoteException {
1358 System.out.println("ServiceNameTooLongLangTest");
1359 SaveBusiness sb = new SaveBusiness();
1360 sb.setAuthInfo(authInfoJoe);
1361 BusinessEntity be = new BusinessEntity();
1362 Name n = new Name();
1363 n.setValue("A Test business");
1364 be.getName().add(n);
1365 be.setBusinessServices(new BusinessServices());
1366 BusinessService bs = new BusinessService();
1367 n = new Name();
1368 n.setValue(str255);
1369 n.setLang(str27);
1370 bs.getName().add(n);
1371 be.getBusinessServices().getBusinessService().add(bs);
1372
1373 sb.getBusinessEntity().add(be);
1374 try {
1375 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1376 DeleteBusiness db = new DeleteBusiness();
1377 db.setAuthInfo(authInfoJoe);
1378 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1379 publication.deleteBusiness(db);
1380 Assert.fail("request should have been rejected");
1381
1382 } catch (ValueNotAllowedException ex) {
1383 HandleException(ex);
1384 throw ex;
1385 }
1386 }
1387
1388 @Test(expected=ValueNotAllowedException.class)
1389 public void ServiceDescTooLongTest() throws DispositionReportFaultMessage, RemoteException {
1390 System.out.println("ServiceDescTooLongTest");
1391 SaveBusiness sb = new SaveBusiness();
1392 sb.setAuthInfo(authInfoJoe);
1393 BusinessEntity be = new BusinessEntity();
1394 Name n = new Name();
1395 n.setValue("A Test business");
1396 be.getName().add(n);
1397 be.setBusinessServices(new BusinessServices());
1398 BusinessService bs = new BusinessService();
1399 Description d = new Description();
1400 d.setValue(str256);
1401 bs.getDescription().add(d);
1402 n = new Name();
1403 n.setValue(str255);
1404 bs.getName().add(n);
1405 be.getBusinessServices().getBusinessService().add(bs);
1406
1407 sb.getBusinessEntity().add(be);
1408 try {
1409 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1410 DeleteBusiness db = new DeleteBusiness();
1411 db.setAuthInfo(authInfoJoe);
1412 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1413 publication.deleteBusiness(db);
1414 Assert.fail("request should have been rejected");
1415
1416 } catch (ValueNotAllowedException ex) {
1417 HandleException(ex);
1418 throw ex;
1419 }
1420 }
1421
1422 @Test(expected=ValueNotAllowedException.class)
1423 public void ServiceDescLangTooLongTest() throws DispositionReportFaultMessage, RemoteException {
1424 System.out.println("ServiceDescLangTooLongTest");
1425 SaveBusiness sb = new SaveBusiness();
1426 sb.setAuthInfo(authInfoJoe);
1427 BusinessEntity be = new BusinessEntity();
1428 Name n = new Name();
1429 n.setValue("A Test business");
1430 be.getName().add(n);
1431 be.setBusinessServices(new BusinessServices());
1432 BusinessService bs = new BusinessService();
1433 Description d = new Description();
1434 d.setValue(str255);
1435 d.setLang(str27);
1436 bs.getDescription().add(d);
1437 n = new Name();
1438 n.setValue(str255);
1439 bs.getName().add(n);
1440 be.getBusinessServices().getBusinessService().add(bs);
1441
1442 sb.getBusinessEntity().add(be);
1443 try {
1444 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1445 DeleteBusiness db = new DeleteBusiness();
1446 db.setAuthInfo(authInfoJoe);
1447 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1448 publication.deleteBusiness(db);
1449 Assert.fail("request should have been rejected");
1450
1451 } catch (ValueNotAllowedException ex) {
1452 HandleException(ex);
1453 throw ex;
1454 }
1455 }
1456
1457 @Test
1458 public void ServiceDescMaxLangTest() throws DispositionReportFaultMessage, RemoteException {
1459 System.out.println("ServiceDescMaxLangTest");
1460 SaveBusiness sb = new SaveBusiness();
1461 sb.setAuthInfo(authInfoJoe);
1462 BusinessEntity be = new BusinessEntity();
1463 Name n = new Name();
1464 n.setValue("A Test business");
1465 be.getName().add(n);
1466 be.setBusinessServices(new BusinessServices());
1467 BusinessService bs = new BusinessService();
1468 Description d = new Description();
1469 d.setValue(str255);
1470 d.setLang(str26);
1471 bs.getDescription().add(d);
1472 n = new Name();
1473 n.setValue(str255);
1474 bs.getName().add(n);
1475 be.getBusinessServices().getBusinessService().add(bs);
1476
1477 sb.getBusinessEntity().add(be);
1478
1479 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1480 DeleteBusiness db = new DeleteBusiness();
1481 db.setAuthInfo(authInfoJoe);
1482 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1483 publication.deleteBusiness(db);
1484
1485 }
1486
1487 @Test
1488 public void ServiceMaxCatBagTest() throws DispositionReportFaultMessage, RemoteException {
1489 System.out.println("ServiceDescMaxLangTest");
1490 SaveBusiness sb = new SaveBusiness();
1491 sb.setAuthInfo(authInfoJoe);
1492 BusinessEntity be = new BusinessEntity();
1493 Name n = new Name();
1494 n.setValue("A Test business");
1495 be.getName().add(n);
1496 be.setBusinessServices(new BusinessServices());
1497 BusinessService bs = new BusinessService();
1498 Description d = new Description();
1499 d.setValue(str255);
1500 d.setLang(str26);
1501 bs.getDescription().add(d);
1502 n = new Name();
1503 n.setValue(str255);
1504 bs.getName().add(n);
1505 bs.setCategoryBag(new CategoryBag());
1506 KeyedReference kr = new KeyedReference();
1507 kr.setKeyName(str255);
1508 kr.setKeyValue(str255);
1509 kr.setTModelKey(str255);
1510 bs.getCategoryBag().getKeyedReference().add(kr);
1511 be.getBusinessServices().getBusinessService().add(bs);
1512
1513 sb.getBusinessEntity().add(be);
1514
1515 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1516 DeleteBusiness db = new DeleteBusiness();
1517 db.setAuthInfo(authInfoJoe);
1518 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1519 publication.deleteBusiness(db);
1520 }
1521
1522 @Test(expected=ValueNotAllowedException.class)
1523 public void ServiceMaxCatBagTooBigTest() throws DispositionReportFaultMessage, RemoteException {
1524 System.out.println("ServiceMaxCatBagTooBigTest");
1525 SaveBusiness sb = new SaveBusiness();
1526 sb.setAuthInfo(authInfoJoe);
1527 BusinessEntity be = new BusinessEntity();
1528 Name n = new Name();
1529 n.setValue("A Test business");
1530 be.getName().add(n);
1531 be.setBusinessServices(new BusinessServices());
1532 BusinessService bs = new BusinessService();
1533 Description d = new Description();
1534 d.setValue(str255);
1535 d.setLang(str26);
1536 bs.getDescription().add(d);
1537 n = new Name();
1538 n.setValue(str255);
1539 bs.getName().add(n);
1540 bs.setCategoryBag(new CategoryBag());
1541 KeyedReference kr = new KeyedReference();
1542 kr.setKeyName(str256);
1543 kr.setKeyValue(str256);
1544 kr.setTModelKey(str256);
1545 bs.getCategoryBag().getKeyedReference().add(kr);
1546 be.getBusinessServices().getBusinessService().add(bs);
1547
1548 sb.getBusinessEntity().add(be);
1549 try {
1550 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1551 DeleteBusiness db = new DeleteBusiness();
1552 db.setAuthInfo(authInfoJoe);
1553 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1554 publication.deleteBusiness(db);
1555 Assert.fail("request should have been rejected");
1556
1557 } catch (ValueNotAllowedException ex) {
1558 HandleException(ex);
1559 throw ex;
1560 }
1561 }
1562
1563 @Test(expected=ValueNotAllowedException.class)
1564 public void BindingTemplateNoAccessPointTest() throws DispositionReportFaultMessage, RemoteException {
1565 System.out.println("BindingTemplateNoAccessPointTest");
1566 SaveBusiness sb = new SaveBusiness();
1567 sb.setAuthInfo(authInfoJoe);
1568 BusinessEntity be = new BusinessEntity();
1569 Name n = new Name();
1570 n.setValue("A Test business");
1571 be.getName().add(n);
1572 be.setBusinessServices(new BusinessServices());
1573 BusinessService bs = new BusinessService();
1574
1575 n = new Name();
1576 n.setValue(str255);
1577 bs.getName().add(n);
1578 BindingTemplate bt = new BindingTemplate();
1579 bs.setBindingTemplates(new BindingTemplates());
1580 bs.getBindingTemplates().getBindingTemplate().add(bt);
1581
1582 be.getBusinessServices().getBusinessService().add(bs);
1583
1584 sb.getBusinessEntity().add(be);
1585 try {
1586 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1587 DeleteBusiness db = new DeleteBusiness();
1588 db.setAuthInfo(authInfoJoe);
1589 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1590 publication.deleteBusiness(db);
1591 Assert.fail("request should have been rejected");
1592
1593 } catch (ValueNotAllowedException ex) {
1594 HandleException(ex);
1595 throw ex;
1596 }
1597 }
1598
1599 @Test
1600 public void BindingTemplateAccessPointMaxUseTypeTest() throws DispositionReportFaultMessage, RemoteException {
1601 System.out.println("BindingTemplateAccessPointMaxUseTypeTest");
1602 SaveBusiness sb = new SaveBusiness();
1603 sb.setAuthInfo(authInfoJoe);
1604 BusinessEntity be = new BusinessEntity();
1605 Name n = new Name();
1606 n.setValue("A Test business");
1607 be.getName().add(n);
1608 be.setBusinessServices(new BusinessServices());
1609 BusinessService bs = new BusinessService();
1610
1611 n = new Name();
1612 n.setValue(str255);
1613 bs.getName().add(n);
1614 BindingTemplate bt = new BindingTemplate();
1615 bs.setBindingTemplates(new BindingTemplates());
1616 AccessPoint ap = new AccessPoint();
1617 ap.setUseType(str255);
1618 ap.setValue("http://localhost");
1619 bt.setAccessPoint(ap);
1620 bs.getBindingTemplates().getBindingTemplate().add(bt);
1621
1622 be.getBusinessServices().getBusinessService().add(bs);
1623
1624 sb.getBusinessEntity().add(be);
1625
1626 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1627 DeleteBusiness db = new DeleteBusiness();
1628 db.setAuthInfo(authInfoJoe);
1629 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1630 publication.deleteBusiness(db);
1631 }
1632
1633 @Test(expected=ValueNotAllowedException.class)
1634 public void BindingTemplateAccessPointUseTypeTooLongTest() throws DispositionReportFaultMessage, RemoteException {
1635 System.out.println("BindingTemplateAccessPointUseTypeTooLongTest");
1636 SaveBusiness sb = new SaveBusiness();
1637 sb.setAuthInfo(authInfoJoe);
1638 BusinessEntity be = new BusinessEntity();
1639 Name n = new Name();
1640 n.setValue("A Test business");
1641 be.getName().add(n);
1642 be.setBusinessServices(new BusinessServices());
1643 BusinessService bs = new BusinessService();
1644
1645 n = new Name();
1646 n.setValue(str255);
1647 bs.getName().add(n);
1648 BindingTemplate bt = new BindingTemplate();
1649 bs.setBindingTemplates(new BindingTemplates());
1650 AccessPoint ap = new AccessPoint();
1651 ap.setUseType(str256);
1652 ap.setValue("http://localhost");
1653 bt.setAccessPoint(ap);
1654 bs.getBindingTemplates().getBindingTemplate().add(bt);
1655
1656 be.getBusinessServices().getBusinessService().add(bs);
1657
1658 sb.getBusinessEntity().add(be);
1659 try {
1660 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1661 DeleteBusiness db = new DeleteBusiness();
1662 db.setAuthInfo(authInfoJoe);
1663 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1664 publication.deleteBusiness(db);
1665 Assert.fail("request should have been rejected");
1666
1667 } catch (ValueNotAllowedException ex) {
1668 HandleException(ex);
1669 throw ex;
1670 }
1671 }
1672
1673 @Test(expected=ValueNotAllowedException.class)
1674 public void BindingTemplateAccessPointValueTooLongTest() throws DispositionReportFaultMessage, RemoteException {
1675 System.out.println("BindingTemplateAccessPointValueTooLongTest");
1676 SaveBusiness sb = new SaveBusiness();
1677 sb.setAuthInfo(authInfoJoe);
1678 BusinessEntity be = new BusinessEntity();
1679 Name n = new Name();
1680 n.setValue("A Test business");
1681 be.getName().add(n);
1682 be.setBusinessServices(new BusinessServices());
1683 BusinessService bs = new BusinessService();
1684
1685 n = new Name();
1686 n.setValue(str255);
1687 bs.getName().add(n);
1688 BindingTemplate bt = new BindingTemplate();
1689 bs.setBindingTemplates(new BindingTemplates());
1690 AccessPoint ap = new AccessPoint();
1691 ap.setUseType(str255);
1692 ap.setValue(str4097);
1693 bt.setAccessPoint(ap);
1694 bs.getBindingTemplates().getBindingTemplate().add(bt);
1695
1696 be.getBusinessServices().getBusinessService().add(bs);
1697
1698 sb.getBusinessEntity().add(be);
1699 try {
1700 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1701 DeleteBusiness db = new DeleteBusiness();
1702 db.setAuthInfo(authInfoJoe);
1703 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1704 publication.deleteBusiness(db);
1705 Assert.fail("request should have been rejected");
1706
1707 } catch (ValueNotAllowedException ex) {
1708 HandleException(ex);
1709 throw ex;
1710 }
1711 }
1712
1713 @Test
1714 public void BindingTemplateAccessPointMaxValueTest() throws DispositionReportFaultMessage, RemoteException {
1715 System.out.println("BindingTemplateAccessPointMaxValueTest");
1716 SaveBusiness sb = new SaveBusiness();
1717 sb.setAuthInfo(authInfoJoe);
1718 BusinessEntity be = new BusinessEntity();
1719 Name n = new Name();
1720 n.setValue("A Test business");
1721 be.getName().add(n);
1722 be.setBusinessServices(new BusinessServices());
1723 BusinessService bs = new BusinessService();
1724
1725 n = new Name();
1726 n.setValue(str255);
1727 bs.getName().add(n);
1728 BindingTemplate bt = new BindingTemplate();
1729 bs.setBindingTemplates(new BindingTemplates());
1730 AccessPoint ap = new AccessPoint();
1731 ap.setUseType(str255);
1732 ap.setValue(str4096);
1733 bt.setAccessPoint(ap);
1734 bs.getBindingTemplates().getBindingTemplate().add(bt);
1735
1736 be.getBusinessServices().getBusinessService().add(bs);
1737
1738 sb.getBusinessEntity().add(be);
1739
1740 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1741 DeleteBusiness db = new DeleteBusiness();
1742 db.setAuthInfo(authInfoJoe);
1743 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1744 publication.deleteBusiness(db);
1745 }
1746
1747 @Test(expected=ValueNotAllowedException.class)
1748 public void BindingTemplateNoAccessPointNoRedirectorTest() throws DispositionReportFaultMessage, RemoteException {
1749 System.out.println("BindingTemplateNoAccessPointNoRedirectorTest");
1750 SaveBusiness sb = new SaveBusiness();
1751 sb.setAuthInfo(authInfoJoe);
1752 BusinessEntity be = new BusinessEntity();
1753 Name n = new Name();
1754 n.setValue("A Test business");
1755 be.getName().add(n);
1756 be.setBusinessServices(new BusinessServices());
1757 BusinessService bs = new BusinessService();
1758
1759
1760 n = new Name();
1761 n.setValue(str255);
1762 bs.getName().add(n);
1763 BindingTemplate bt = new BindingTemplate();
1764 bs.setBindingTemplates(new BindingTemplates());
1765
1766 bs.getBindingTemplates().getBindingTemplate().add(bt);
1767
1768 be.getBusinessServices().getBusinessService().add(bs);
1769
1770 sb.getBusinessEntity().add(be);
1771 try {
1772 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1773 DeleteBusiness db = new DeleteBusiness();
1774 db.setAuthInfo(authInfoJoe);
1775 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1776 publication.deleteBusiness(db);
1777 Assert.fail("request should have been rejected");
1778
1779 } catch (ValueNotAllowedException ex) {
1780 HandleException(ex);
1781 throw ex;
1782 }
1783 }
1784
1785 @Test(expected=ValueNotAllowedException.class)
1786 public void BindingTemplateAccessPointAndRedirectorTest() throws DispositionReportFaultMessage, RemoteException {
1787 System.out.println("BindingTemplateAccessPointAndRedirectorTest");
1788 SaveBusiness sb = new SaveBusiness();
1789 sb.setAuthInfo(authInfoJoe);
1790 BusinessEntity be = new BusinessEntity();
1791 Name n = new Name();
1792 n.setValue("A Test business");
1793 be.getName().add(n);
1794 be.setBusinessServices(new BusinessServices());
1795 BusinessService bs = new BusinessService();
1796
1797 n = new Name();
1798 n.setValue(str255);
1799 bs.getName().add(n);
1800 BindingTemplate bt = new BindingTemplate();
1801 bs.setBindingTemplates(new BindingTemplates());
1802 bt.setAccessPoint(new AccessPoint());
1803 bt.getAccessPoint().setUseType(str26);
1804
1805 bt.setHostingRedirector(new HostingRedirector());
1806
1807 bt.getHostingRedirector().setBindingKey(str26);
1808 bs.getBindingTemplates().getBindingTemplate().add(bt);
1809
1810 be.getBusinessServices().getBusinessService().add(bs);
1811
1812 sb.getBusinessEntity().add(be);
1813 try {
1814 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1815 DeleteBusiness db = new DeleteBusiness();
1816 db.setAuthInfo(authInfoJoe);
1817 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1818 publication.deleteBusiness(db);
1819 Assert.fail("request should have been rejected");
1820
1821 } catch (ValueNotAllowedException ex) {
1822 HandleException(ex);
1823 throw ex;
1824 }
1825 }
1826
1827 @Test
1828 public void BindingTemplateHostRedirectorReferencalIntegritytest() throws DispositionReportFaultMessage, RemoteException {
1829 System.out.println("BindingTemplateHostRedirectorReferencalIntegritytest");
1830
1831 String url = "http://juddi.apache.org";
1832 SaveBusiness sb = new SaveBusiness();
1833 sb.setAuthInfo(authInfoJoe);
1834 BusinessEntity be = new BusinessEntity();
1835 Name n = new Name();
1836 n.setValue("A Test business");
1837 be.getName().add(n);
1838 be.setBusinessServices(new BusinessServices());
1839 BusinessService bs = new BusinessService();
1840
1841 n = new Name();
1842 n.setValue("A first business service");
1843 bs.getName().add(n);
1844 BindingTemplate bt = new BindingTemplate();
1845 bs.setBindingTemplates(new BindingTemplates());
1846 bt.setAccessPoint(new AccessPoint());
1847 bt.getAccessPoint().setValue(url);
1848
1849
1850
1851 bs.getBindingTemplates().getBindingTemplate().add(bt);
1852
1853 be.getBusinessServices().getBusinessService().add(bs);
1854
1855 sb.getBusinessEntity().add(be);
1856
1857 System.out.println("Saving the business with the first service");
1858 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1859
1860 PrintBusinessDetails(saveBusiness.getBusinessEntity());
1861
1862
1863 bs = new BusinessService();
1864 n = new Name();
1865 n.setValue("A a redirected business service");
1866 bt = new BindingTemplate();
1867 bt.setHostingRedirector(new HostingRedirector());
1868 bt.getHostingRedirector().setBindingKey(saveBusiness.getBusinessEntity().get(0).getBusinessServices().getBusinessService().get(0).getBindingTemplates().getBindingTemplate().get(0).getBindingKey());
1869 bs.getName().add(n);
1870 bs.setBindingTemplates(new BindingTemplates());
1871 bs.getBindingTemplates().getBindingTemplate().add(bt);
1872 saveBusiness.getBusinessEntity().get(0).getBusinessServices().getBusinessService().add(bs);
1873
1874 sb = new SaveBusiness();
1875 sb.setAuthInfo(authInfoJoe);
1876 sb.getBusinessEntity().add(saveBusiness.getBusinessEntity().get(0));
1877
1878
1879 System.out.println("Saving the business with the first and second service as a host redirect");
1880 saveBusiness = publication.saveBusiness(sb);
1881 PrintBusinessDetails(saveBusiness.getBusinessEntity());
1882
1883 DeleteBusiness db = new DeleteBusiness();
1884 db.setAuthInfo(authInfoJoe);
1885 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1886 publication.deleteBusiness(db);
1887 }
1888
1889 @Test
1890 public void BindingTemplateAccessPointAsBindingTemplateReferencalIntegritytest() throws DispositionReportFaultMessage, RemoteException {
1891 System.out.println("BindingTemplateAccessPointAsBindingTemplateReferencalIntegritytest");
1892
1893 String url = "http://juddi.apache.org";
1894 SaveBusiness sb = new SaveBusiness();
1895 sb.setAuthInfo(authInfoJoe);
1896 BusinessEntity be = new BusinessEntity();
1897 Name n = new Name();
1898 n.setValue("A Test business");
1899 be.getName().add(n);
1900 be.setBusinessServices(new BusinessServices());
1901 BusinessService bs = new BusinessService();
1902
1903 n = new Name();
1904 n.setValue("A first business service");
1905 bs.getName().add(n);
1906 BindingTemplate bt = new BindingTemplate();
1907 bs.setBindingTemplates(new BindingTemplates());
1908 bt.setAccessPoint(new AccessPoint());
1909 bt.getAccessPoint().setValue(url);
1910
1911
1912
1913 bs.getBindingTemplates().getBindingTemplate().add(bt);
1914
1915 be.getBusinessServices().getBusinessService().add(bs);
1916
1917 sb.getBusinessEntity().add(be);
1918 System.out.println("Saving the business with the first service");
1919 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1920
1921 PrintBusinessDetails(saveBusiness.getBusinessEntity());
1922
1923
1924 bs = new BusinessService();
1925 n = new Name();
1926 n.setValue("A a redirected business service");
1927 bt = new BindingTemplate();
1928 bt.setAccessPoint(new AccessPoint());
1929 bt.getAccessPoint().setUseType(AccessPointType.BINDING_TEMPLATE.toString());
1930 bt.getAccessPoint().setValue(saveBusiness.getBusinessEntity().get(0).getBusinessServices().getBusinessService().get(0).getBindingTemplates().getBindingTemplate().get(0).getBindingKey());
1931 bs.getName().add(n);
1932 bs.setBindingTemplates(new BindingTemplates());
1933 bs.getBindingTemplates().getBindingTemplate().add(bt);
1934 saveBusiness.getBusinessEntity().get(0).getBusinessServices().getBusinessService().add(bs);
1935
1936 sb = new SaveBusiness();
1937 sb.setAuthInfo(authInfoJoe);
1938 sb.getBusinessEntity().add(saveBusiness.getBusinessEntity().get(0));
1939
1940
1941 System.out.println("Saving the business with the first and second service as a host redirect");
1942 saveBusiness = publication.saveBusiness(sb);
1943 PrintBusinessDetails(saveBusiness.getBusinessEntity());
1944
1945 DeleteBusiness db = new DeleteBusiness();
1946 db.setAuthInfo(authInfoJoe);
1947 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1948 publication.deleteBusiness(db);
1949 }
1950
1951 @Test(expected=ValueNotAllowedException.class)
1952 public void BindingTemplateAccessPointAsBindingTemplateINVALIDReferencalIntegritytest() throws DispositionReportFaultMessage, RemoteException {
1953 System.out.println("BindingTemplateAccessPointAsBindingTemplateINVALIDReferencalIntegritytest");
1954
1955 SaveBusiness sb;
1956 try {
1957
1958 sb = new SaveBusiness();
1959 sb.setAuthInfo(authInfoJoe);
1960
1961 BusinessEntity be = new BusinessEntity();
1962 Name bsn = new Name();
1963 bsn.setValue("A bogus business");
1964 be.getName().add(bsn);
1965
1966 BusinessService bs = new BusinessService();
1967 Name n = new Name();
1968 n.setValue("A a redirected business service");
1969 BindingTemplate bt = new BindingTemplate();
1970 bt.setAccessPoint(new AccessPoint());
1971 bt.getAccessPoint().setUseType(AccessPointType.BINDING_TEMPLATE.toString());
1972 bt.getAccessPoint().setValue("uddi:" + UUID.randomUUID().toString());
1973 bs.getName().add(n);
1974 bs.setBindingTemplates(new BindingTemplates());
1975 bs.getBindingTemplates().getBindingTemplate().add(bt);
1976 be.setBusinessServices(new BusinessServices());
1977 be.getBusinessServices().getBusinessService().add(bs);
1978 sb.getBusinessEntity().add(be);
1979 BusinessDetail saveBusiness = publication.saveBusiness(sb);
1980
1981 DeleteBusiness db = new DeleteBusiness();
1982 db.setAuthInfo(authInfoJoe);
1983 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
1984 publication.deleteBusiness(db);
1985 Assert.fail("request should have been rejected");
1986
1987 } catch (ValueNotAllowedException ex) {
1988 HandleException(ex);
1989 throw ex;
1990 }
1991 }
1992
1993 @Test(expected=ValueNotAllowedException.class)
1994 public void BindingTemplateHostRedirectorTooLongTest() throws DispositionReportFaultMessage, RemoteException {
1995 System.out.println("BindingTemplateHostRedirectorTooLongTest");
1996 SaveBusiness sb = new SaveBusiness();
1997 sb.setAuthInfo(authInfoJoe);
1998 BusinessEntity be = new BusinessEntity();
1999 Name n = new Name();
2000 n.setValue("A Test business");
2001 be.getName().add(n);
2002 be.setBusinessServices(new BusinessServices());
2003 BusinessService bs = new BusinessService();
2004
2005 n = new Name();
2006 n.setValue(str255);
2007 bs.getName().add(n);
2008 BindingTemplate bt = new BindingTemplate();
2009 bs.setBindingTemplates(new BindingTemplates());
2010
2011 bt.setHostingRedirector(new HostingRedirector());
2012 bt.getHostingRedirector().setBindingKey(str256);
2013 bs.getBindingTemplates().getBindingTemplate().add(bt);
2014
2015 be.getBusinessServices().getBusinessService().add(bs);
2016
2017 sb.getBusinessEntity().add(be);
2018 try {
2019 BusinessDetail saveBusiness = publication.saveBusiness(sb);
2020 DeleteBusiness db = new DeleteBusiness();
2021 db.setAuthInfo(authInfoJoe);
2022 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
2023 publication.deleteBusiness(db);
2024 Assert.fail("request should have been rejected");
2025
2026 } catch (ValueNotAllowedException ex) {
2027 HandleException(ex);
2028 throw ex;
2029 }
2030 }
2031
2032 @Test
2033 public void BindingTemplateAccessPointMaxLengthTest() throws DispositionReportFaultMessage, RemoteException {
2034 System.out.println("BindingTemplateAccessPointMaxLengthTest");
2035 SaveBusiness sb = new SaveBusiness();
2036 sb.setAuthInfo(authInfoJoe);
2037 BusinessEntity be = new BusinessEntity();
2038 Name n = new Name();
2039 n.setValue("A Test business");
2040 be.getName().add(n);
2041 be.setBusinessServices(new BusinessServices());
2042 BusinessService bs = new BusinessService();
2043
2044 n = new Name();
2045 n.setValue(str255);
2046 bs.getName().add(n);
2047 BindingTemplate bt = new BindingTemplate();
2048 bs.setBindingTemplates(new BindingTemplates());
2049 bt.setAccessPoint(new AccessPoint());
2050 bt.getAccessPoint().setValue(str4096);
2051
2052 bs.getBindingTemplates().getBindingTemplate().add(bt);
2053
2054 be.getBusinessServices().getBusinessService().add(bs);
2055
2056 sb.getBusinessEntity().add(be);
2057
2058 BusinessDetail saveBusiness = publication.saveBusiness(sb);
2059 DeleteBusiness db = new DeleteBusiness();
2060 db.setAuthInfo(authInfoJoe);
2061 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
2062 publication.deleteBusiness(db);
2063 }
2064
2065 @Test(expected=ValueNotAllowedException.class)
2066 public void BindingTemplateAccessPointTooLongTest() throws DispositionReportFaultMessage, RemoteException {
2067 System.out.println("BindingTemplateAccessPointTooLongTest");
2068 SaveBusiness sb = new SaveBusiness();
2069 sb.setAuthInfo(authInfoJoe);
2070 BusinessEntity be = new BusinessEntity();
2071 Name n = new Name();
2072 n.setValue("A Test business");
2073 be.getName().add(n);
2074 be.setBusinessServices(new BusinessServices());
2075 BusinessService bs = new BusinessService();
2076
2077 n = new Name();
2078 n.setValue(str255);
2079 bs.getName().add(n);
2080 BindingTemplate bt = new BindingTemplate();
2081
2082 bs.setBindingTemplates(new BindingTemplates());
2083 bt.setAccessPoint(new AccessPoint());
2084 bt.getAccessPoint().setValue(str4097);
2085
2086 bs.getBindingTemplates().getBindingTemplate().add(bt);
2087
2088 be.getBusinessServices().getBusinessService().add(bs);
2089
2090 sb.getBusinessEntity().add(be);
2091 try {
2092 BusinessDetail saveBusiness = publication.saveBusiness(sb);
2093 DeleteBusiness db = new DeleteBusiness();
2094 db.setAuthInfo(authInfoJoe);
2095 db.getBusinessKey().add(saveBusiness.getBusinessEntity().get(0).getBusinessKey());
2096 publication.deleteBusiness(db);
2097 Assert.fail("request should have been rejected");
2098
2099 } catch (ValueNotAllowedException ex) {
2100 HandleException(ex);
2101 throw ex;
2102 }
2103 }
2104
2105 static final String validTmodelKeyGenMax = "uddi:www.mycoolxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxcompany.com:keygenerator";
2106 static final String validTmodelKeyGenTooLong = "uddi:www.mycoolzxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxcompany.com:keygenerator";
2107
2108
2109 @Test
2110 public void CreateKeyGenMaxLengthTest() throws DispositionReportFaultMessage, RemoteException {
2111 System.out.println("CreateKeyGenMaxLengthTest");
2112
2113 SaveTModel st = new SaveTModel();
2114 st.setAuthInfo(authInfoJoe);
2115 TModel tm = new TModel();
2116 tm.setName(new Name());
2117 tm.getName().setValue("My Cool Company Keymodel generator");
2118 tm.getName().setLang("en");
2119 tm.setCategoryBag(new CategoryBag());
2120 KeyedReference kr = new KeyedReference();
2121 kr.setTModelKey("uddi:uddi.org:categorization:types");
2122 kr.setKeyName("uddi-org:keyGenerator");
2123 kr.setKeyValue("keyGenerator");
2124 tm.getCategoryBag().getKeyedReference().add(kr);
2125 tm.setTModelKey(validTmodelKeyGenMax);
2126 st.getTModel().add(tm);
2127
2128 @SuppressWarnings("unused")
2129 TModelDetail saveTModel = publication.saveTModel(st);
2130 DeleteTModel dm = new DeleteTModel();
2131 dm.setAuthInfo(authInfoJoe);
2132 dm.getTModelKey().add(validTmodelKeyGenMax);
2133 publication.deleteTModel(dm);
2134
2135 }
2136
2137
2138 @Test(expected=ValueNotAllowedException.class)
2139 public void CreateKeyGenTooLongTest() throws DispositionReportFaultMessage, RemoteException {
2140 System.out.println("CreateKeyGenTooLongTest");
2141
2142 SaveTModel st = new SaveTModel();
2143 st.setAuthInfo(authInfoJoe);
2144 TModel tm = new TModel();
2145 tm.setName(new Name());
2146 tm.getName().setValue("My Cool Company Keymodel generator");
2147 tm.getName().setLang("en");
2148 tm.setCategoryBag(new CategoryBag());
2149 KeyedReference kr = new KeyedReference();
2150 kr.setTModelKey("uddi:uddi.org:categorization:types");
2151 kr.setKeyName("uddi-org:keyGenerator");
2152 kr.setKeyValue("keyGenerator");
2153 tm.getCategoryBag().getKeyedReference().add(kr);
2154 tm.setTModelKey(validTmodelKeyGenTooLong);
2155 st.getTModel().add(tm);
2156 try {
2157 @SuppressWarnings("unused")
2158 TModelDetail saveTModel = publication.saveTModel(st);
2159 Assert.fail("request should have been rejected");
2160 } catch (ValueNotAllowedException ex) {
2161 HandleException(ex);
2162 throw ex;
2163 }
2164
2165 }
2166
2167
2168 @Test(expected=ValueNotAllowedException.class)
2169 public void CreateKeyGenKeyDescriptionTooLongTest() throws DispositionReportFaultMessage, RemoteException {
2170 System.out.println("CreateKeyGenKeyDescriptionTooLongTest");
2171
2172 SaveTModel st = new SaveTModel();
2173 st.setAuthInfo(authInfoJoe);
2174 TModel tm = new TModel();
2175 tm.setName(new Name());
2176 tm.getName().setValue("Key gen name");
2177 tm.getName().setLang("en");
2178 Description d = new Description();
2179 d.setValue(str256);
2180 tm.getDescription().add(d);
2181 tm.setCategoryBag(new CategoryBag());
2182 KeyedReference kr = new KeyedReference();
2183 kr.setTModelKey("uddi:uddi.org:categorization:types");
2184 kr.setKeyName("uddi-org:keyGenerator");
2185 kr.setKeyValue("keyGenerator");
2186 tm.getCategoryBag().getKeyedReference().add(kr);
2187 tm.setTModelKey("uddi:uddi.joepublisher.com:mycustomkey");
2188 st.getTModel().add(tm);
2189 try {
2190 @SuppressWarnings("unused")
2191 TModelDetail saveTModel = publication.saveTModel(st);
2192 Assert.fail("request should have been rejected");
2193 } catch (ValueNotAllowedException ex) {
2194 HandleException(ex);
2195 throw ex;
2196 }
2197 }
2198
2199 @Test(expected=ValueNotAllowedException.class)
2200 public void CreateKeyGenKeyDescriptionLangTooLongTest() throws DispositionReportFaultMessage, RemoteException {
2201 System.out.println("CreateKeyGenKeyDescriptionTooLongTest");
2202
2203 SaveTModel st = new SaveTModel();
2204 st.setAuthInfo(authInfoJoe);
2205 TModel tm = new TModel();
2206 tm.setName(new Name());
2207 tm.getName().setValue("Key gen name");
2208 tm.getName().setLang("en");
2209 Description d = new Description();
2210 d.setValue("A description");
2211 d.setLang(str256);
2212 tm.getDescription().add(d);
2213 tm.setCategoryBag(new CategoryBag());
2214 KeyedReference kr = new KeyedReference();
2215 kr.setTModelKey("uddi:uddi.org:categorization:types");
2216 kr.setKeyName("uddi-org:keyGenerator");
2217 kr.setKeyValue("keyGenerator");
2218 tm.getCategoryBag().getKeyedReference().add(kr);
2219 String key = UUID.randomUUID().toString();
2220 tm.setTModelKey(key);
2221 st.getTModel().add(tm);
2222 try {
2223 @SuppressWarnings("unused")
2224 TModelDetail saveTModel = publication.saveTModel(st);
2225 Assert.fail("request should have been rejected");
2226 } catch (ValueNotAllowedException ex) {
2227 HandleException(ex);
2228 throw ex;
2229 } finally {
2230
2231 }
2232 }
2233
2234 @Test(expected=ValueNotAllowedException.class)
2235 public void CreateKeyGenNameLangTooLongTest() throws DispositionReportFaultMessage, RemoteException {
2236 System.out.println("CreateKeyGenNameLangTooLongTest");
2237
2238 SaveTModel st = new SaveTModel();
2239 st.setAuthInfo(authInfoJoe);
2240 TModel tm = new TModel();
2241 tm.setName(new Name());
2242 tm.getName().setValue("hello world");
2243 tm.getName().setLang(str27);
2244 tm.setCategoryBag(new CategoryBag());
2245 KeyedReference kr = new KeyedReference();
2246 kr.setTModelKey("uddi:uddi.org:categorization:types");
2247 kr.setKeyName("uddi-org:keyGenerator");
2248 kr.setKeyValue("keyGenerator");
2249 tm.getCategoryBag().getKeyedReference().add(kr);
2250 tm.setTModelKey(validTmodelKeyGenTooLong);
2251 st.getTModel().add(tm);
2252 try {
2253 @SuppressWarnings("unused")
2254 TModelDetail saveTModel = publication.saveTModel(st);
2255 Assert.fail("request should have been rejected");
2256 } catch (ValueNotAllowedException ex) {
2257 HandleException(ex);
2258 throw ex;
2259 }
2260 }
2261
2262
2263
2264
2265 @Test(expected=InvalidKeyPassedException.class)
2266 public void CreateTmodelnoKeyGen() throws DispositionReportFaultMessage, RemoteException {
2267 System.out.println("CreateTmodelnoKeyGen");
2268
2269 SaveTModel st = new SaveTModel();
2270 st.setAuthInfo(authInfoJoe);
2271 TModel tm = new TModel();
2272 tm.setName(new Name());
2273 tm.getName().setValue("My Cool Company's tmodel");
2274 tm.getName().setLang("en");
2275
2276 tm.setTModelKey("uddi:uddi.joepublisher.com:nokeygenerator:customkey");
2277 st.getTModel().add(tm);
2278 try {
2279 @SuppressWarnings("unused")
2280 TModelDetail saveTModel = publication.saveTModel(st);
2281 Assert.fail("request should have been rejected");
2282 } catch (ValueNotAllowedException ex) {
2283 HandleException(ex);
2284 throw ex;
2285 }
2286
2287 }
2288
2289 @Test
2290 public void BindingTemplateTmodelInstanceInfoTest() {
2291 System.out.println("BindingTemplateTmodelInstanceInfoTest");
2292
2293
2294
2295
2296 }
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308 public static String CatBagToString(CategoryBag categoryBag) {
2309 StringBuilder sb = new StringBuilder();
2310 if (categoryBag == null) {
2311 return "no data";
2312 }
2313 for (int i = 0; i < categoryBag.getKeyedReference().size(); i++) {
2314 sb.append(KeyedReferenceToString(categoryBag.getKeyedReference().get(i)));
2315 }
2316 for (int i = 0; i < categoryBag.getKeyedReferenceGroup().size(); i++) {
2317 sb.append("Key Ref Grp: TModelKey=");
2318 for (int k = 0; k < categoryBag.getKeyedReferenceGroup().get(i).getKeyedReference().size(); k++) {
2319 sb.append(KeyedReferenceToString(categoryBag.getKeyedReferenceGroup().get(i).getKeyedReference().get(k)));
2320 }
2321 }
2322 return sb.toString();
2323 }
2324
2325 public static String KeyedReferenceToString(KeyedReference item) {
2326 StringBuilder sb = new StringBuilder();
2327 sb.append("Key Ref: Name=").
2328 append(item.getKeyName()).
2329 append(" Value=").
2330 append(item.getKeyValue()).
2331 append(" tModel=").
2332 append(item.getTModelKey()).
2333 append(System.getProperty("line.separator"));
2334 return sb.toString();
2335 }
2336
2337 public static void PrintContacts(Contacts contacts) {
2338 if (contacts == null) {
2339 return;
2340 }
2341 for (int i = 0; i < contacts.getContact().size(); i++) {
2342 System.out.println("Contact " + i + " type:" + contacts.getContact().get(i).getUseType());
2343 for (int k = 0; k < contacts.getContact().get(i).getPersonName().size(); k++) {
2344 System.out.println("Name: " + contacts.getContact().get(i).getPersonName().get(k).getValue());
2345 }
2346 for (int k = 0; k < contacts.getContact().get(i).getEmail().size(); k++) {
2347 System.out.println("Email: " + contacts.getContact().get(i).getEmail().get(k).getValue());
2348 }
2349 for (int k = 0; k < contacts.getContact().get(i).getAddress().size(); k++) {
2350 System.out.println("Address sort code " + contacts.getContact().get(i).getAddress().get(k).getSortCode());
2351 System.out.println("Address use type " + contacts.getContact().get(i).getAddress().get(k).getUseType());
2352 System.out.println("Address tmodel key " + contacts.getContact().get(i).getAddress().get(k).getTModelKey());
2353 for (int x = 0; x < contacts.getContact().get(i).getAddress().get(k).getAddressLine().size(); x++) {
2354 System.out.println("Address line value " + contacts.getContact().get(i).getAddress().get(k).getAddressLine().get(x).getValue());
2355 System.out.println("Address line key name " + contacts.getContact().get(i).getAddress().get(k).getAddressLine().get(x).getKeyName());
2356 System.out.println("Address line key value " + contacts.getContact().get(i).getAddress().get(k).getAddressLine().get(x).getKeyValue());
2357 }
2358 }
2359 for (int k = 0; k < contacts.getContact().get(i).getDescription().size(); k++) {
2360 System.out.println("Desc: " + contacts.getContact().get(i).getDescription().get(k).getValue());
2361 }
2362 for (int k = 0; k < contacts.getContact().get(i).getPhone().size(); k++) {
2363 System.out.println("Phone: " + contacts.getContact().get(i).getPhone().get(k).getValue());
2364 }
2365 }
2366
2367 }
2368
2369
2370
2371
2372
2373
2374
2375 public static void PrintBindingTemplates(BindingTemplates bindingTemplates) {
2376 if (bindingTemplates == null) {
2377 return;
2378 }
2379 for (int i = 0; i < bindingTemplates.getBindingTemplate().size(); i++) {
2380 System.out.println("Binding Key: " + bindingTemplates.getBindingTemplate().get(i).getBindingKey());
2381
2382 if (bindingTemplates.getBindingTemplate().get(i).getAccessPoint() != null) {
2383 System.out.println("Access Point: " + bindingTemplates.getBindingTemplate().get(i).getAccessPoint().getValue() + " type " + bindingTemplates.getBindingTemplate().get(i).getAccessPoint().getUseType());
2384 }
2385
2386 if (bindingTemplates.getBindingTemplate().get(i).getHostingRedirector() != null) {
2387 System.out.println("Hosting Redirection: " + bindingTemplates.getBindingTemplate().get(i).getHostingRedirector().getBindingKey());
2388 }
2389 }
2390 }
2391
2392 public static void PrintBusinessInfo(BusinessInfos businessInfos) {
2393 if (businessInfos == null) {
2394 System.out.println("No data returned");
2395 } else {
2396 for (int i = 0; i < businessInfos.getBusinessInfo().size(); i++) {
2397 System.out.println("===============================================");
2398 System.out.println("Business Key: " + businessInfos.getBusinessInfo().get(i).getBusinessKey());
2399 System.out.println("Name: " + ListToString(businessInfos.getBusinessInfo().get(i).getName()));
2400
2401 System.out.println("Name: " + ListToDescString(businessInfos.getBusinessInfo().get(i).getDescription()));
2402 System.out.println("Services:");
2403 PrintServiceInfo(businessInfos.getBusinessInfo().get(i).getServiceInfos());
2404 }
2405 }
2406 }
2407
2408 public static String ListToString(List<Name> name) {
2409 StringBuilder sb = new StringBuilder();
2410 for (int i = 0; i < name.size(); i++) {
2411 sb.append(name.get(i).getValue()).append(" ");
2412 }
2413 return sb.toString();
2414 }
2415
2416 public static String ListToDescString(List<Description> name) {
2417 StringBuilder sb = new StringBuilder();
2418 for (int i = 0; i < name.size(); i++) {
2419 sb.append(name.get(i).getValue()).append(" ");
2420 }
2421 return sb.toString();
2422 }
2423
2424 public static void PrintServiceInfo(ServiceInfos serviceInfos) {
2425 for (int i = 0; i < serviceInfos.getServiceInfo().size(); i++) {
2426 System.out.println("-------------------------------------------");
2427 System.out.println("Service Key: " + serviceInfos.getServiceInfo().get(i).getServiceKey());
2428 System.out.println("Owning Business Key: " + serviceInfos.getServiceInfo().get(i).getBusinessKey());
2429 System.out.println("Name: " + ListToString(serviceInfos.getServiceInfo().get(i).getName()));
2430 }
2431 }
2432
2433 public static void PrintBusinessDetails(List<BusinessEntity> businessDetail) {
2434
2435
2436 for (int i = 0; i < businessDetail.size(); i++) {
2437 System.out.println("Business Detail - key: " + businessDetail.get(i).getBusinessKey());
2438 System.out.println("Name: " + ListToString(businessDetail.get(i).getName()));
2439 System.out.println("CategoryBag: " + CatBagToString(businessDetail.get(i).getCategoryBag()));
2440 PrintContacts(businessDetail.get(i).getContacts());
2441 }
2442 }
2443
2444 }