KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > outerj > daisy > repository > test > AbstractDocVariantTest


1 /*
2  * Copyright 2004 Outerthought bvba and Schaubroeck nv
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */

16 package org.outerj.daisy.repository.test;
17
18 import org.outerj.daisy.repository.testsupport.AbstractDaisyTestCase;
19 import org.outerj.daisy.repository.*;
20 import org.outerj.daisy.repository.query.QueryManager;
21 import org.outerj.daisy.repository.acl.*;
22 import org.outerj.daisy.repository.schema.RepositorySchema;
23 import org.outerj.daisy.repository.schema.FieldType;
24 import org.outerj.daisy.repository.schema.PartType;
25 import org.outerj.daisy.repository.schema.DocumentType;
26 import org.outerj.daisy.repository.variant.VariantManager;
27 import org.outerj.daisy.repository.variant.Branch;
28 import org.outerj.daisy.repository.variant.Language;
29 import org.outerj.daisy.repository.serverimpl.LocalRepositoryManager;
30 import org.outerj.daisy.repository.user.Role;
31 import org.outerj.daisy.repository.user.User;
32 import org.outerj.daisy.repository.user.UserManager;
33 import org.outerx.daisy.x10.SearchResultDocument;
34
35 import java.util.Date JavaDoc;
36 import java.util.Locale JavaDoc;
37
38 /**
39  * This testcase tests all functionality related to document variants.
40  */

41 public abstract class AbstractDocVariantTest extends AbstractDaisyTestCase {
42     protected boolean resetDataStores() {
43         return true;
44     }
45
46     protected abstract RepositoryManager getRepositoryManager() throws Exception JavaDoc;
47
48     public void testVariants() throws Exception JavaDoc {
49         RepositoryManager repositoryManager = getRepositoryManager();
50         Repository repository = repositoryManager.getRepository(new Credentials("testuser", "testuser"));
51         repository.switchRole(Role.ADMINISTRATOR);
52
53         //
54
// Create some variants
55
//
56
VariantManager variantManager = repository.getVariantManager();
57         Branch branch1 = variantManager.createBranch("branch1");
58         branch1.save();
59         Branch branch2 = variantManager.createBranch("branch2");
60         branch2.save();
61         Language language1 = variantManager.createLanguage("lang1");
62         language1.save();
63         Language language2 = variantManager.createLanguage("lang2");
64         language2.save();
65
66         //
67
// Create some schema types
68
//
69
RepositorySchema repositorySchema = repository.getRepositorySchema();
70         FieldType fieldType1 = repositorySchema.createFieldType("fieldType1", ValueType.STRING);
71         fieldType1.setAclAllowed(true);
72         fieldType1.save();
73         FieldType fieldType2 = repositorySchema.createFieldType("fieldType2", ValueType.STRING);
74         fieldType2.save();
75         PartType partType1 = repositorySchema.createPartType("partType1", "");
76         partType1.setDaisyHtml(true);
77         partType1.save();
78         PartType partType2 = repositorySchema.createPartType("partType2", "");
79         partType2.save();
80         DocumentType documentType1 = repositorySchema.createDocumentType("doctype1");
81         documentType1.addFieldType(fieldType1, false);
82         documentType1.addFieldType(fieldType2, false);
83         documentType1.addPartType(partType1, false);
84         documentType1.addPartType(partType2, false);
85         documentType1.save();
86
87         // Test some basic branching stuff
88
{
89             Document document = repository.createDocument("document 1", "doctype1");
90             document.setField("fieldType1", "abc");
91             document.setField("fieldType2", "def");
92             document.save();
93             document.setField("fieldType2", "def2");
94             document.save();
95
96             Document variant1 = repository.createVariant(document.getId(), "main", "default", -1, "branch1", "lang1", true);
97             // new variant should be initialised with existing data
98
assertEquals("abc", variant1.getField("fieldType1").getValue());
99             assertEquals("def2", variant1.getField("fieldType2").getValue());
100             assertTrue(variant1.getCreated() != document.getCreated());
101             assertEquals(1, variant1.getVersions().getArray().length);
102             assertEquals(2, document.getVersions().getArray().length);
103
104             assertEquals(1, variant1.getVariantCreatedFromBranchId());
105             assertEquals(1, variant1.getVariantCreatedFromLanguageId());
106             assertEquals(2, variant1.getVariantCreatedFromVersionId());
107
108             variant1.setField("fieldType1", "ghi");
109             variant1.save();
110
111             document = repository.getDocument(document.getId(), true);
112             variant1 = repository.getDocument(document.getId(), "branch1", "lang1", true);
113
114             assertEquals("abc", document.getField("fieldType1").getValue());
115             assertEquals("def2", document.getField("fieldType2").getValue());
116             assertEquals("ghi", variant1.getField("fieldType1").getValue());
117             assertEquals("def2", variant1.getField("fieldType2").getValue());
118
119             if (repositoryManager instanceof LocalRepositoryManager) {
120                 Document docFromCache1 = repository.getDocument(document.getId(), false);
121                 Document docFromCache2 = repository.getDocument(document.getId(), false);
122                 assertTrue(docFromCache1 == docFromCache2);
123
124                 Document variant1FromCache1 = repository.getDocument(document.getId(), "branch1", "lang1", false);
125                 Document variant1FromCache2 = repository.getDocument(document.getId(), "branch1", "lang1", false);
126                 assertTrue(variant1FromCache1 == variant1FromCache2);
127                 assertTrue(docFromCache1 != variant1FromCache1);
128
129                 // update doc and see that cache was invalidated
130
variant1.setField("fieldType1", "zoo");
131                 variant1.save();
132
133                 Document variant1FromCache = repository.getDocument(document.getId(), "branch1", "lang1", false);
134                 assertEquals("zoo", variant1FromCache.getField("fieldType1").getValue());
135
136                 // ... but original variant should not have been cache-invalidated
137
assertTrue(docFromCache1 == repository.getDocument(document.getId(), false));
138
139                 // change a version state
140
variant1.getLastVersion().setState(VersionState.DRAFT);
141                 // and check again that cache was invalidated
142
assertTrue(variant1FromCache != repository.getDocument(document.getId(), "branch1", "lang1", false));
143                 // ... but original variant should not have been cache-invalidated
144
assertTrue(docFromCache1 == repository.getDocument(document.getId(), false));
145
146
147                 // update a shared doc property and check that all variants have been invalidated from the cache
148
Date JavaDoc variant1VariantLastModified = variant1.getVariantLastModified();
149                 variant1.setPrivate(true);
150                 variant1.save();
151                 // and meanwhile check that only changing a shared property doesn't save the variant data
152
assertEquals(variant1VariantLastModified.getTime(), variant1.getVariantLastModified().getTime());
153                 assertTrue(variant1FromCache != repository.getDocument(document.getId(), "branch1", "lang1", false));
154                 assertTrue(docFromCache1 != repository.getDocument(document.getId(), false));
155             }
156
157             // check that saving an unchanged document doesn't save anything
158
document = repository.getDocument(document.getId(), true);
159             Date JavaDoc lastModified = document.getLastModified();
160             Date JavaDoc variantLastModified = document.getVariantLastModified();
161             document.save();
162             assertEquals(lastModified.getTime(), document.getLastModified().getTime());
163             assertEquals(variantLastModified.getTime(), document.getVariantLastModified().getTime());
164             document = repository.getDocument(document.getId(), true);
165             assertEquals(lastModified.getTime(), document.getLastModified().getTime());
166             assertEquals(variantLastModified.getTime(), document.getVariantLastModified().getTime());
167
168             // check availableVariants
169
assertEquals(2, repository.getAvailableVariants(document.getId()).size());
170         }
171
172         // test that shared blobkey is not removed when one document variant is removed
173
{
174             Document variant1 = repository.createDocument("shared blobkey test", documentType1.getId(), branch1.getId(), language1.getId());
175             String JavaDoc data = "<html><body><p>kabouter plop</p></body></html>";
176             variant1.setPart(partType1.getId(), "text/xml", data.getBytes("UTF-8"));
177             variant1.save();
178
179             Document variant2 = repository.createVariant(variant1.getId(), branch1.getId(), language1.getId(), 1, branch2.getId(), language2.getId(), true);
180
181             repository.deleteVariant(variant1.getId(), branch1.getId(), language1.getId());
182
183             // version 1 of variant 2 was created based on variant1 and internally this
184
// will reuse the same blob key. Here we verify that after deleting variant1,
185
// the blob is still available to variant2
186
String JavaDoc retrievedData = new String JavaDoc(variant2.getPart(partType1.getId()).getData(), "UTF-8");
187             assertEquals(data, retrievedData);
188
189
190             // check deleted document variant is no longer in the cache
191
try {
192                 repository.getDocument(variant1.getId(), branch1.getId(), language1.getId(), false);
193                 fail("Expected a DocumentVariantNotFoundException.");
194             } catch (DocumentVariantNotFoundException e) {}
195             // ... nor in the repository
196
try {
197                 repository.getDocument(variant1.getId(), branch1.getId(), language1.getId(), true);
198                 fail("Expected a DocumentVariantNotFoundException.");
199             } catch (DocumentVariantNotFoundException e) {}
200         }
201
202         // More extensive testing of various document properties
203
{
204             Document document = repository.createDocument("extensive document", documentType1.getId());
205
206             CollectionManager collectionManager = repository.getCollectionManager();
207             DocumentCollection collection1 = collectionManager.createCollection("collection 1");
208             collection1.save();
209             DocumentCollection collection2 = collectionManager.createCollection("collection 2");
210             collection2.save();
211
212             document.addToCollection(collection1);
213             document.addToCollection(collection2);
214
215             document.setCustomField("field1", "value1");
216             document.setCustomField("field2", "value2");
217
218             document.addLink("Google", "http://www.google.be");
219             document.addLink("Apache", "http://www.apache.org");
220
221             document.setField(fieldType1.getId(), "field1 value");
222             document.setField(fieldType2.getId(), "field2 value");
223
224             String JavaDoc part1Data = "<html><body><p>Hello this is the content of part1</p></body></html>";
225             String JavaDoc part2Data = "<html><body><p>Hello this is the content of part2</p></body></html>";
226
227             document.setPart(partType1.getId(), "text/xml", part1Data.getBytes("UTF-8"));
228             document.setPart(partType2.getId(), "text/xml", part2Data.getBytes("UTF-8"));
229
230             document.save();
231
232             document.removeFromCollection(collection2);
233             document.deleteField(fieldType1.getId());
234             document.setPrivate(true);
235             document.save();
236
237             // both document and variant were modified, and saved at the same time, so they should have the
238
// same last modified stamp
239
assertEquals(document.getLastModified().getTime(), document.getVariantLastModified().getTime());
240             assertEquals(2, document.getUpdateCount());
241             assertEquals(2, document.getVariantUpdateCount());
242
243             Document variant = repository.createVariant(document.getId(), Branch.MAIN_BRANCH_ID, Language.DEFAULT_LANGUAGE_ID, 1, branch1.getId(), language2.getId(), true);
244
245             // creating a new branch shouldn't have updated the common document part
246
assertEquals(variant.getUpdateCount(), document.getUpdateCount());
247
248             assertEquals(true, variant.isPrivate());
249             assertEquals(branch1.getId(), variant.getBranchId());
250             assertEquals(language2.getId(), variant.getLanguageId());
251             assertEquals(document.getId(), variant.getId());
252
253             assertTrue(variant.inCollection(collection1));
254             assertFalse(variant.inCollection(collection2));
255
256             assertTrue(variant.hasField(fieldType1.getId()));
257             assertTrue(variant.hasField(fieldType2.getId()));
258
259             assertEquals("field1 value", variant.getField(fieldType1.getId()).getValue());
260             assertEquals("field2 value", variant.getField(fieldType2.getId()).getValue());
261
262             assertEquals(part1Data, new String JavaDoc(variant.getPart(partType1.getId()).getData(), "UTF-8"));
263             assertEquals(part2Data, new String JavaDoc(variant.getPart(partType2.getId()).getData(), "UTF-8"));
264
265             Link[] links = variant.getLinks().getArray();
266             assertEquals("Google", links[0].getTitle());
267             assertEquals("http://www.google.be", links[0].getTarget());
268             assertEquals("Apache", links[1].getTitle());
269             assertEquals("http://www.apache.org", links[1].getTarget());
270
271             assertEquals("value1", variant.getCustomField("field1"));
272             assertEquals("value2", variant.getCustomField("field2"));
273
274             String JavaDoc newPart1Data = "<html><body><p>Updated content</p></body></html>";
275             variant.setPart(partType1.getId(), "text/xml", newPart1Data.getBytes("UTF-8"));
276             variant.save();
277
278             assertEquals("Updated content", variant.getSummary());
279             assertEquals("Hello this is the content of part1", repository.getDocument(document.getId(), true).getSummary());
280             assertEquals("Updated content", repository.getDocument(document.getId(), branch1.getId(), language2.getId(), true).getSummary());
281             assertEquals("Hello this is the content of part1", repository.getDocument(document.getId(), false).getSummary());
282             assertEquals("Updated content", repository.getDocument(document.getId(), branch1.getId(), language2.getId(), false).getSummary());
283         }
284
285         // test create branch without copying data
286
{
287             Document document = repository.createDocument("my document", documentType1.getId());
288             document.setCustomField("field", "value");
289             document.save();
290
291             Document variant = repository.createVariant(document.getId(), Branch.MAIN_BRANCH_ID, Language.DEFAULT_LANGUAGE_ID, document.getLiveVersion().getId(), branch2.getId(), language1.getId(), false);
292
293             try {
294                 repository.getDocument(document.getId(), branch2.getId(), language1.getId(), true);
295                 fail("Variant created without copying data should not yet be persisted.");
296             } catch (DocumentVariantNotFoundException e) {}
297
298             variant.setCustomField("anotherfield", "anothervalue");
299             variant.save();
300             variant = repository.getDocument(document.getId(), branch2.getId(), language1.getId(), true);
301
302             // check that shared part was not saved
303
assertEquals(document.getUpdateCount(), variant.getUpdateCount());
304         }
305
306         // check that changing a shared doc property doesn't create a new version of the variant
307
{
308             Document document = repository.createDocument("document x", documentType1.getId());
309             document.addLink("Daisy", "http://cocoondev.org/daisy");
310             document.save();
311
312             Document cachedDocument = repository.getDocument(document.getId(), false);
313
314             User jan = repository.getUserManager().createUser("jan");
315             Role adminRole = repository.getUserManager().getRole(Role.ADMINISTRATOR, false);
316             jan.addToRole(adminRole);
317             jan.setDefaultRole(adminRole);
318             jan.setPassword("jan");
319             jan.save();
320
321             document.setOwner(jan.getId());
322             document.save();
323
324             assertEquals(1, document.getLastVersionId());
325             document = repository.getDocument(document.getId(), true);
326             assertEquals(1, document.getLastVersionId());
327
328             // test cache was invalidated after changing shared property
329
assertEquals(jan.getId(), repository.getDocument(document.getId(), false).getOwner());
330         }
331
332         // test the getAvailableVariants methods
333
{
334             Document document = repository.createDocument("document y", documentType1.getId());
335             assertEquals(0, document.getAvailableVariants().size());
336             document.save();
337
338             assertEquals(1, document.getAvailableVariants().size());
339
340             repository.createVariant(document.getId(), document.getBranchId(), document.getLanguageId(), document.getLastVersionId(), branch2.getId(), language1.getId(), true);
341             repository.createVariant(document.getId(), document.getBranchId(), document.getLanguageId(), document.getLastVersionId(), branch1.getId(), language2.getId(), true);
342             repository.createVariant(document.getId(), document.getBranchId(), document.getLanguageId(), document.getLastVersionId(), branch2.getId(), language2.getId(), true);
343
344             assertEquals(4, document.getAvailableVariants().size());
345             assertEquals(4, repository.getAvailableVariants(document.getId()).size());
346
347             if (repositoryManager instanceof LocalRepositoryManager) {
348                 // test this stuff is cached
349
assertTrue(document.getAvailableVariants() == document.getAvailableVariants());
350                 assertTrue(document.getAvailableVariants() == repository.getAvailableVariants(document.getId()));
351             }
352         }
353
354         // test only valid branch and language id's can be used
355
{
356             try {
357                 repository.createDocument("document x", documentType1.getId(), 5000, 6000);
358                 fail("Using non-existing lang or branch id's should have failed.");
359             } catch (Throwable JavaDoc e) {}
360
361             Document document = repository.createDocument("document z", documentType1.getId());
362             document.save();
363
364             try {
365                 repository.createVariant(document.getId(), document.getBranchId(), document.getLanguageId(), -1, 5000, 6000, true);
366                 fail("Using non-existing lang or branch id's should have failed.");
367             } catch (Throwable JavaDoc e) {}
368         }
369
370         // test creation of new variant requires write access to the start variant
371
{
372             UserManager userManager = repository.getUserManager();
373             Role userRole = userManager.getRole("user", false);
374             User tomUser = userManager.createUser("Tom");
375             tomUser.addToRole(userRole);
376             tomUser.setDefaultRole(userRole);
377             tomUser.setPassword("tom");
378             tomUser.save();
379
380             AccessManager accessManager = repository.getAccessManager();
381             Acl acl = accessManager.getStagingAcl();
382             AclObject aclObject = acl.createNewObject("$fieldType1 = 'secret'");
383             AclEntry aclEntry = aclObject.createNewEntry(AclSubjectType.ROLE, userRole.getId());
384             aclEntry.set(AclPermission.READ_LIVE, AclActionType.GRANT);
385             aclEntry.set(AclPermission.READ, AclActionType.GRANT);
386             aclEntry.set(AclPermission.WRITE, AclActionType.DENY);
387             aclEntry.set(AclPermission.PUBLISH, AclActionType.DENY);
388             aclEntry.set(AclPermission.DELETE, AclActionType.DENY);
389             aclObject.add(aclEntry);
390             acl.add(aclObject);
391             acl.save();
392             accessManager.copyStagingToLive();
393
394             Document document = repository.createDocument("testdocument", documentType1.getId());
395             document.setField("fieldType1", "secret");
396             document.save();
397
398             Repository tomRepository = repositoryManager.getRepository(new Credentials("tom", "tom"));
399             // tom has read access to the document
400
tomRepository.getDocument(document.getId(), true);
401
402             try {
403                 tomRepository.createVariant(document.getId(), Branch.MAIN_BRANCH_ID, Language.DEFAULT_LANGUAGE_ID, -1,
404                         branch1.getId(), language1.getId(), true);
405                 fail("Creating branch should have failed because of access rights.");
406             } catch (RepositoryException e) {}
407
408             try {
409                 Document variantDoc = tomRepository.createVariant(document.getId(), Branch.MAIN_BRANCH_ID, Language.DEFAULT_LANGUAGE_ID, -1,
410                         branch1.getId(), language1.getId(), false);
411                 variantDoc.setField("fieldType1", "notsecret");
412                 fail("Creating branch should have failed because of access rights.");
413             } catch (RepositoryException e) {}
414         }
415
416         // test index and query features
417
{
418             Document document1 = repository.createDocument("q doc 1", documentType1.getId());
419             document1.setPart(partType1.getId(), "text/xml", "<html><body><p>gent</p></body></html>".getBytes("UTF-8"));
420             document1.setPart(partType2.getId(), "text/xml", "<html><body><p>leuven</p></body></html>".getBytes("UTF-8"));
421             document1.save();
422
423             Document variant1 = repository.createVariant(document1.getId(), document1.getBranchId(), document1.getLanguageId(), -1, branch1.getId(), language1.getId(), false);
424             variant1.setPart(partType1.getId(), "text/xml", "<html><body><p>kortrijk</p></body></html>".getBytes("UTF-8"));
425             variant1.setPart(partType2.getId(), "text/xml", "<html><body><p>brugge</p></body></html>".getBytes("UTF-8"));
426             variant1.save();
427
428             Document variant2 = repository.createVariant(document1.getId(), variant1.getBranchId(), variant1.getLanguageId(), -1, branch2.getId(), language1.getId(), true);
429             variant2.setPart(partType1.getId(), "text/xml", "<html><body><p>antwerpen</p></body></html>".getBytes("UTF-8"));
430             variant2.setPart(partType2.getId(), "text/xml", "<html><body><p>zelzate</p></body></html>".getBytes("UTF-8"));
431             variant2.save();
432
433             System.out.println("Sleeping a bit to let fulltext indexer do its work");
434             Thread.sleep(10000);
435
436             QueryManager queryManager = repository.getQueryManager();
437             SearchResultDocument result = queryManager.performQuery("select id where FullText('gent')", Locale.US);
438             assertEquals(1, result.getSearchResult().getRows().getRowArray().length);
439             SearchResultDocument.SearchResult.Rows.Row row = result.getSearchResult().getRows().getRowArray()[0];
440             assertEquals(document1.getId(), row.getDocumentId());
441             assertEquals(document1.getBranchId(), row.getBranchId());
442             assertEquals(document1.getLanguageId(), row.getLanguageId());
443
444             result = queryManager.performQuery("select id where FullText('gent', 1, 1, 1, 2, 2)", Locale.US);
445             assertEquals(0, result.getSearchResult().getRows().getRowArray().length);
446
447             result = queryManager.performQuery("select id where FullText('brugge')", Locale.US);
448             assertEquals(1, result.getSearchResult().getRows().getRowArray().length);
449             row = result.getSearchResult().getRows().getRowArray()[0];
450             assertEquals(variant1.getId(), row.getDocumentId());
451             assertEquals(variant1.getBranchId(), row.getBranchId());
452             assertEquals(variant1.getLanguageId(), row.getLanguageId());
453
454             result = queryManager.performQuery("select id where FullText('antwerpen and zelzate')", Locale.US);
455             assertEquals(1, result.getSearchResult().getRows().getRowArray().length);
456             row = result.getSearchResult().getRows().getRowArray()[0];
457             assertEquals(variant2.getId(), row.getDocumentId());
458             assertEquals(variant2.getBranchId(), row.getBranchId());
459             assertEquals(variant2.getLanguageId(), row.getLanguageId());
460
461             result = queryManager.performQuery("select id, branchId, languageId, branch, language where id = " + document1.getId() + " and languageId = " + language1.getId() + " order by branchId", Locale.US);
462             assertEquals(2, result.getSearchResult().getRows().getRowArray().length);
463             assertEquals("branch1", result.getSearchResult().getRows().getRowArray()[0].getValueArray()[3]);
464             assertEquals("branch2", result.getSearchResult().getRows().getRowArray()[1].getValueArray()[3]);
465         }
466
467         // test DoesNotHaveVariant
468
{
469             Document document1 = repository.createDocument("ooo1", documentType1.getId());
470             document1.setField(fieldType1.getId(), "ooo");
471             document1.save();
472
473             Document document2 = repository.createDocument("ooo2", documentType1.getId());
474             document2.setField(fieldType1.getId(), "ooo");
475             document2.save();
476
477             Document document3 = repository.createDocument("ooo3", documentType1.getId());
478             document3.setField(fieldType1.getId(), "ooo");
479             document3.save();
480
481             repository.createVariant(document2.getId(), Branch.MAIN_BRANCH_ID, Language.DEFAULT_LANGUAGE_ID, -1, branch1.getId(), language1.getId(), true);
482
483             QueryManager queryManager = repository.getQueryManager();
484
485             SearchResultDocument result = queryManager.performQuery("select id where DoesNotHaveVariant('branch1', 'lang1') and $fieldType1 = 'ooo' order by id", Locale.US);
486             assertEquals(2, result.getSearchResult().getRows().getRowArray().length);
487             assertEquals(document1.getId(), result.getSearchResult().getRows().getRowArray()[0].getDocumentId());
488             assertEquals(document3.getId(), result.getSearchResult().getRows().getRowArray()[1].getDocumentId());
489
490             result = queryManager.performQuery("select id where DoesNotHaveVariant(" + branch1.getId() + ", " + language1.getId() + ") and $fieldType1 = 'ooo' order by id", Locale.US);
491             assertEquals(2, result.getSearchResult().getRows().getRowArray().length);
492         }
493
494         // test deletion of in-use variants should fail
495
{
496             Branch branchX = variantManager.createBranch("branchX");
497             branchX.save();
498
499             Document document1 = repository.createDocument("haha", documentType1.getId(), branchX.getId(), Language.DEFAULT_LANGUAGE_ID);
500             document1.setField(fieldType1.getId(), "haha");
501             document1.save();
502
503             try {
504                 variantManager.deleteBranch(branchX.getId());
505                 fail("Branch deletion should have failed because it is still in use.");
506             } catch (RepositoryException e) {}
507
508             repository.deleteDocument(document1.getId());
509             variantManager.deleteBranch(branchX.getId());
510         }
511
512         // test updating of different variants in presence of locks by different users
513
}
514 }
515
Popular Tags