001: /*
002: * Copyright 2004 Outerthought bvba and Schaubroeck nv
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016: package org.outerj.daisy.repository.test;
017:
018: import org.outerj.daisy.repository.testsupport.AbstractDaisyTestCase;
019: import org.outerj.daisy.repository.*;
020: import org.outerj.daisy.repository.query.QueryManager;
021: import org.outerj.daisy.repository.acl.*;
022: import org.outerj.daisy.repository.schema.RepositorySchema;
023: import org.outerj.daisy.repository.schema.FieldType;
024: import org.outerj.daisy.repository.schema.PartType;
025: import org.outerj.daisy.repository.schema.DocumentType;
026: import org.outerj.daisy.repository.variant.VariantManager;
027: import org.outerj.daisy.repository.variant.Branch;
028: import org.outerj.daisy.repository.variant.Language;
029: import org.outerj.daisy.repository.user.Role;
030: import org.outerj.daisy.repository.user.User;
031: import org.outerj.daisy.repository.user.UserManager;
032: import org.outerx.daisy.x10.SearchResultDocument;
033:
034: import java.util.Date;
035: import java.util.Locale;
036:
037: /**
038: * This testcase tests all functionality related to document variants.
039: */
040: public abstract class AbstractDocVariantTest extends
041: AbstractDaisyTestCase {
042: protected boolean resetDataStores() {
043: return true;
044: }
045:
046: protected abstract RepositoryManager getRepositoryManager()
047: throws Exception;
048:
049: public void testVariants() throws Exception {
050: RepositoryManager repositoryManager = getRepositoryManager();
051: Repository repository = repositoryManager
052: .getRepository(new Credentials("testuser", "testuser"));
053: repository.switchRole(Role.ADMINISTRATOR);
054:
055: //
056: // Create some variants
057: //
058: VariantManager variantManager = repository.getVariantManager();
059: Branch branch1 = variantManager.createBranch("branch1");
060: branch1.save();
061: Branch branch2 = variantManager.createBranch("branch2");
062: branch2.save();
063: Branch branch3 = variantManager.createBranch("branch3");
064: branch3.save();
065: Language language1 = variantManager.createLanguage("lang1");
066: language1.save();
067: Language language2 = variantManager.createLanguage("lang2");
068: language2.save();
069: Language language3 = variantManager.createLanguage("lang3");
070: language3.save();
071:
072: //
073: // Create some schema types
074: //
075: RepositorySchema repositorySchema = repository
076: .getRepositorySchema();
077: FieldType fieldType1 = repositorySchema.createFieldType(
078: "fieldType1", ValueType.STRING);
079: fieldType1.setAclAllowed(true);
080: fieldType1.save();
081: FieldType fieldType2 = repositorySchema.createFieldType(
082: "fieldType2", ValueType.STRING);
083: fieldType2.save();
084: PartType partType1 = repositorySchema.createPartType(
085: "partType1", "");
086: partType1.setDaisyHtml(true);
087: partType1.save();
088: PartType partType2 = repositorySchema.createPartType(
089: "partType2", "");
090: partType2.save();
091: DocumentType documentType1 = repositorySchema
092: .createDocumentType("doctype1");
093: documentType1.addFieldType(fieldType1, false);
094: documentType1.addFieldType(fieldType2, false);
095: documentType1.addPartType(partType1, false);
096: documentType1.addPartType(partType2, false);
097: documentType1.save();
098:
099: // Test some basic branching stuff
100: {
101: Document document = repository.createDocument("document 1",
102: "doctype1");
103: document.setField("fieldType1", "abc");
104: document.setField("fieldType2", "def");
105: document.save();
106: document.setField("fieldType2", "def2");
107: document.save();
108:
109: Document variant1 = repository.createVariant(document
110: .getId(), "main", "default", -1, "branch1",
111: "lang1", true);
112: // new variant should be initialised with existing data
113: assertEquals("abc", variant1.getField("fieldType1")
114: .getValue());
115: assertEquals("def2", variant1.getField("fieldType2")
116: .getValue());
117: assertTrue(variant1.getCreated() != document.getCreated());
118: assertEquals(1, variant1.getVersions().getArray().length);
119: assertEquals(2, document.getVersions().getArray().length);
120:
121: assertEquals(1, variant1.getVariantCreatedFromBranchId());
122: assertEquals(1, variant1.getVariantCreatedFromLanguageId());
123: assertEquals(2, variant1.getVariantCreatedFromVersionId());
124:
125: variant1.setField("fieldType1", "ghi");
126: variant1.save();
127:
128: document = repository.getDocument(document.getId(), true);
129: variant1 = repository.getDocument(document.getId(),
130: "branch1", "lang1", true);
131:
132: assertEquals("abc", document.getField("fieldType1")
133: .getValue());
134: assertEquals("def2", document.getField("fieldType2")
135: .getValue());
136: assertEquals("ghi", variant1.getField("fieldType1")
137: .getValue());
138: assertEquals("def2", variant1.getField("fieldType2")
139: .getValue());
140:
141: if (repositoryManager.getClass().getName().endsWith(
142: "LocalRepositoryManager")) {
143: Document docFromCache1 = repository.getDocument(
144: document.getId(), false);
145: Document docFromCache2 = repository.getDocument(
146: document.getId(), false);
147: assertTrue(docFromCache1 == docFromCache2);
148:
149: Document variant1FromCache1 = repository.getDocument(
150: document.getId(), "branch1", "lang1", false);
151: Document variant1FromCache2 = repository.getDocument(
152: document.getId(), "branch1", "lang1", false);
153: assertTrue(variant1FromCache1 == variant1FromCache2);
154: assertTrue(docFromCache1 != variant1FromCache1);
155:
156: // update doc and see that cache was invalidated
157: variant1.setField("fieldType1", "zoo");
158: variant1.save();
159:
160: Document variant1FromCache = repository.getDocument(
161: document.getId(), "branch1", "lang1", false);
162: assertEquals("zoo", variant1FromCache.getField(
163: "fieldType1").getValue());
164:
165: // ... but original variant should not have been cache-invalidated
166: assertTrue(docFromCache1 == repository.getDocument(
167: document.getId(), false));
168:
169: // change a version state
170: Version lastVersion = variant1.getLastVersion();
171: lastVersion.setState(VersionState.DRAFT);
172: lastVersion.save();
173: // and check again that cache was invalidated
174: assertTrue(variant1FromCache != repository.getDocument(
175: document.getId(), "branch1", "lang1", false));
176: // ... but original variant should not have been cache-invalidated
177: assertTrue(docFromCache1 == repository.getDocument(
178: document.getId(), false));
179:
180: // update a shared doc property and check that all variants have been invalidated from the cache
181: Date variant1VariantLastModified = variant1
182: .getVariantLastModified();
183: variant1.setPrivate(true);
184: variant1.save();
185: // and meanwhile check that only changing a shared property doesn't save the variant data
186: assertEquals(variant1VariantLastModified.getTime(),
187: variant1.getVariantLastModified().getTime());
188: assertTrue(variant1FromCache != repository.getDocument(
189: document.getId(), "branch1", "lang1", false));
190: assertTrue(docFromCache1 != repository.getDocument(
191: document.getId(), false));
192: }
193:
194: // check that saving an unchanged document doesn't save anything
195: document = repository.getDocument(document.getId(), true);
196: Date lastModified = document.getLastModified();
197: Date variantLastModified = document
198: .getVariantLastModified();
199: document.save();
200: assertEquals(lastModified.getTime(), document
201: .getLastModified().getTime());
202: assertEquals(variantLastModified.getTime(), document
203: .getVariantLastModified().getTime());
204: document = repository.getDocument(document.getId(), true);
205: assertEquals(lastModified.getTime(), document
206: .getLastModified().getTime());
207: assertEquals(variantLastModified.getTime(), document
208: .getVariantLastModified().getTime());
209:
210: // check availableVariants
211: assertEquals(2, repository.getAvailableVariants(
212: document.getId()).size());
213: }
214:
215: // test that shared blobkey is not removed when one document variant is removed
216: {
217: Document variant1 = repository.createDocument(
218: "shared blobkey test", documentType1.getId(),
219: branch1.getId(), language1.getId());
220: String data = "<html><body><p>kabouter plop</p></body></html>";
221: variant1.setPart(partType1.getId(), "text/xml", data
222: .getBytes("UTF-8"));
223: variant1.save();
224:
225: Document variant2 = repository.createVariant(variant1
226: .getId(), branch1.getId(), language1.getId(), 1,
227: branch2.getId(), language2.getId(), true);
228:
229: repository.deleteVariant(variant1.getId(), branch1.getId(),
230: language1.getId());
231:
232: // version 1 of variant 2 was created based on variant1 and internally this
233: // will reuse the same blob key. Here we verify that after deleting variant1,
234: // the blob is still available to variant2
235: String retrievedData = new String(variant2.getPart(
236: partType1.getId()).getData(), "UTF-8");
237: assertEquals(data, retrievedData);
238:
239: // check deleted document variant is no longer in the cache
240: try {
241: repository.getDocument(variant1.getId(), branch1
242: .getId(), language1.getId(), false);
243: fail("Expected a DocumentVariantNotFoundException.");
244: } catch (DocumentVariantNotFoundException e) {
245: }
246: // ... nor in the repository
247: try {
248: repository.getDocument(variant1.getId(), branch1
249: .getId(), language1.getId(), true);
250: fail("Expected a DocumentVariantNotFoundException.");
251: } catch (DocumentVariantNotFoundException e) {
252: }
253: }
254:
255: // More extensive testing of various document properties
256: {
257: Document document = repository.createDocument(
258: "extensive document", documentType1.getId());
259:
260: CollectionManager collectionManager = repository
261: .getCollectionManager();
262: DocumentCollection collection1 = collectionManager
263: .createCollection("collection 1");
264: collection1.save();
265: DocumentCollection collection2 = collectionManager
266: .createCollection("collection 2");
267: collection2.save();
268:
269: document.addToCollection(collection1);
270: document.addToCollection(collection2);
271:
272: document.setCustomField("field1", "value1");
273: document.setCustomField("field2", "value2");
274:
275: document.addLink("Google", "http://www.google.be");
276: document.addLink("Apache", "http://www.apache.org");
277:
278: document.setField(fieldType1.getId(), "field1 value");
279: document.setField(fieldType2.getId(), "field2 value");
280:
281: String part1Data = "<html><body><p>Hello this is the content of part1</p></body></html>";
282: String part2Data = "<html><body><p>Hello this is the content of part2</p></body></html>";
283:
284: document.setPart(partType1.getId(), "text/xml", part1Data
285: .getBytes("UTF-8"));
286: document.setPart(partType2.getId(), "text/xml", part2Data
287: .getBytes("UTF-8"));
288:
289: document.save();
290:
291: document.removeFromCollection(collection2);
292: document.deleteField(fieldType1.getId());
293: document.setPrivate(true);
294: document.save();
295:
296: // both document and variant were modified, and saved at the same time, so they should have the
297: // same last modified stamp
298: assertEquals(document.getLastModified().getTime(), document
299: .getVariantLastModified().getTime());
300: assertEquals(2, document.getUpdateCount());
301: assertEquals(2, document.getVariantUpdateCount());
302:
303: Document variant = repository.createVariant(document
304: .getId(), Branch.MAIN_BRANCH_ID,
305: Language.DEFAULT_LANGUAGE_ID, 1, branch1.getId(),
306: language2.getId(), true);
307:
308: // creating a new branch shouldn't have updated the common document part
309: assertEquals(variant.getUpdateCount(), document
310: .getUpdateCount());
311:
312: assertEquals(true, variant.isPrivate());
313: assertEquals(branch1.getId(), variant.getBranchId());
314: assertEquals(language2.getId(), variant.getLanguageId());
315: assertEquals(document.getId(), variant.getId());
316:
317: assertTrue(variant.inCollection(collection1));
318: assertFalse(variant.inCollection(collection2));
319:
320: assertTrue(variant.hasField(fieldType1.getId()));
321: assertTrue(variant.hasField(fieldType2.getId()));
322:
323: assertEquals("field1 value", variant.getField(
324: fieldType1.getId()).getValue());
325: assertEquals("field2 value", variant.getField(
326: fieldType2.getId()).getValue());
327:
328: assertEquals(part1Data, new String(variant.getPart(
329: partType1.getId()).getData(), "UTF-8"));
330: assertEquals(part2Data, new String(variant.getPart(
331: partType2.getId()).getData(), "UTF-8"));
332:
333: Link[] links = variant.getLinks().getArray();
334: assertEquals("Google", links[0].getTitle());
335: assertEquals("http://www.google.be", links[0].getTarget());
336: assertEquals("Apache", links[1].getTitle());
337: assertEquals("http://www.apache.org", links[1].getTarget());
338:
339: assertEquals("value1", variant.getCustomField("field1"));
340: assertEquals("value2", variant.getCustomField("field2"));
341:
342: String newPart1Data = "<html><body><p>Updated content</p></body></html>";
343: variant.setPart(partType1.getId(), "text/xml", newPart1Data
344: .getBytes("UTF-8"));
345: variant.save();
346:
347: assertEquals("Updated content", variant.getSummary());
348: assertEquals("Hello this is the content of part1",
349: repository.getDocument(document.getId(), true)
350: .getSummary());
351: assertEquals("Updated content", repository.getDocument(
352: document.getId(), branch1.getId(),
353: language2.getId(), true).getSummary());
354: assertEquals("Hello this is the content of part1",
355: repository.getDocument(document.getId(), false)
356: .getSummary());
357: assertEquals("Updated content", repository.getDocument(
358: document.getId(), branch1.getId(),
359: language2.getId(), false).getSummary());
360: }
361:
362: // test create branch without copying data
363: {
364: Document document = repository.createDocument(
365: "my document", documentType1.getId());
366: document.setCustomField("field", "value");
367: document.save();
368:
369: Document variant = repository.createVariant(document
370: .getId(), Branch.MAIN_BRANCH_ID,
371: Language.DEFAULT_LANGUAGE_ID, document
372: .getLiveVersion().getId(), branch2.getId(),
373: language1.getId(), false);
374:
375: try {
376: repository.getDocument(document.getId(), branch2
377: .getId(), language1.getId(), true);
378: fail("Variant created without copying data should not yet be persisted.");
379: } catch (DocumentVariantNotFoundException e) {
380: }
381:
382: variant.setCustomField("anotherfield", "anothervalue");
383: variant.save();
384: variant = repository.getDocument(document.getId(), branch2
385: .getId(), language1.getId(), true);
386:
387: // check that shared part was not saved
388: assertEquals(document.getUpdateCount(), variant
389: .getUpdateCount());
390: }
391:
392: // check that changing a shared doc property doesn't create a new version of the variant
393: {
394: Document document = repository.createDocument("document x",
395: documentType1.getId());
396: document.addLink("Daisy", "http://cocoondev.org/daisy");
397: document.save();
398:
399: Document cachedDocument = repository.getDocument(document
400: .getId(), false);
401:
402: User jan = repository.getUserManager().createUser("jan");
403: Role adminRole = repository.getUserManager().getRole(
404: Role.ADMINISTRATOR, false);
405: jan.addToRole(adminRole);
406: jan.setDefaultRole(adminRole);
407: jan.setPassword("jan");
408: jan.save();
409:
410: document.setOwner(jan.getId());
411: document.save();
412:
413: assertEquals(1, document.getLastVersionId());
414: document = repository.getDocument(document.getId(), true);
415: assertEquals(1, document.getLastVersionId());
416:
417: // test cache was invalidated after changing shared property
418: assertEquals(jan.getId(), repository.getDocument(
419: document.getId(), false).getOwner());
420: }
421:
422: // test the getAvailableVariants methods
423: {
424: Document document = repository.createDocument("document y",
425: documentType1.getId());
426: assertEquals(0, document.getAvailableVariants().size());
427: document.save();
428:
429: assertEquals(1, document.getAvailableVariants().size());
430:
431: repository.createVariant(document.getId(), document
432: .getBranchId(), document.getLanguageId(), document
433: .getLastVersionId(), branch2.getId(), language1
434: .getId(), true);
435: repository.createVariant(document.getId(), document
436: .getBranchId(), document.getLanguageId(), document
437: .getLastVersionId(), branch1.getId(), language2
438: .getId(), true);
439: repository.createVariant(document.getId(), document
440: .getBranchId(), document.getLanguageId(), document
441: .getLastVersionId(), branch2.getId(), language2
442: .getId(), true);
443:
444: assertEquals(4, document.getAvailableVariants().size());
445: assertEquals(4, repository.getAvailableVariants(
446: document.getId()).size());
447:
448: if (repositoryManager.getClass().getName().endsWith(
449: "LocalRepositoryManager")) {
450: // test this stuff is cached
451: assertTrue(document.getAvailableVariants() == document
452: .getAvailableVariants());
453: assertTrue(document.getAvailableVariants() == repository
454: .getAvailableVariants(document.getId()));
455: }
456: }
457:
458: // test only valid branch and language id's can be used
459: {
460: try {
461: repository.createDocument("document x", documentType1
462: .getId(), 5000, 6000);
463: fail("Using non-existing lang or branch id's should have failed.");
464: } catch (Throwable e) {
465: }
466:
467: Document document = repository.createDocument("document z",
468: documentType1.getId());
469: document.save();
470:
471: try {
472: repository.createVariant(document.getId(), document
473: .getBranchId(), document.getLanguageId(), -1,
474: 5000, 6000, true);
475: fail("Using non-existing lang or branch id's should have failed.");
476: } catch (Throwable e) {
477: }
478: }
479:
480: // test creation of new variant requires (only) read access to the start variant
481: {
482: UserManager userManager = repository.getUserManager();
483: Role userRole = userManager.getRole("User", false);
484: User tomUser = userManager.createUser("Tom");
485: tomUser.addToRole(userRole);
486: tomUser.setDefaultRole(userRole);
487: tomUser.setPassword("tom");
488: tomUser.save();
489:
490: AccessManager accessManager = repository.getAccessManager();
491: Acl acl = accessManager.getStagingAcl();
492:
493: AclObject aclObject = acl.createNewObject("true");
494: AclEntry aclEntry = aclObject.createNewEntry(
495: AclSubjectType.ROLE, userRole.getId());
496: aclEntry.set(AclPermission.READ, AclActionType.GRANT);
497: aclEntry.set(AclPermission.WRITE, AclActionType.GRANT);
498: aclObject.add(aclEntry);
499: acl.add(aclObject);
500:
501: aclObject = acl
502: .createNewObject("branch = 'main' and language = 'default'");
503: aclEntry = aclObject.createNewEntry(AclSubjectType.ROLE,
504: userRole.getId());
505: aclEntry.set(AclPermission.READ, AclActionType.GRANT);
506: aclEntry.set(AclPermission.WRITE, AclActionType.DENY);
507: aclObject.add(aclEntry);
508: acl.add(aclObject);
509:
510: acl.save();
511: accessManager.copyStagingToLive();
512:
513: Document document = repository.createDocument(
514: "testdocument", documentType1.getId());
515: document.save();
516:
517: Repository tomRepository = repositoryManager
518: .getRepository(new Credentials("Tom", "tom"));
519: // check user has read access
520: tomRepository.getDocument(document.getId(), true);
521:
522: // User has read access, creating the variant should work
523: tomRepository.createVariant(document.getId(),
524: Branch.MAIN_BRANCH_ID,
525: Language.DEFAULT_LANGUAGE_ID, -1, branch1.getId(),
526: language1.getId(), true);
527:
528: tomRepository.createVariant(document.getId(),
529: Branch.MAIN_BRANCH_ID,
530: Language.DEFAULT_LANGUAGE_ID, -1, branch2.getId(),
531: language2.getId(), false);
532:
533: // remove the read access
534: acl.get(1).get(0).set(AclPermission.READ,
535: AclActionType.DENY);
536: acl.save();
537: accessManager.copyStagingToLive();
538:
539: // now create variant should not work
540: try {
541: tomRepository.createVariant(document.getId(),
542: Branch.MAIN_BRANCH_ID,
543: Language.DEFAULT_LANGUAGE_ID, -1, branch3
544: .getId(), language3.getId(), true);
545: fail("Creating branch should have failed because of access rights.");
546: } catch (AccessException e) {
547: }
548:
549: try {
550: Document variantDoc = tomRepository.createVariant(
551: document.getId(), Branch.MAIN_BRANCH_ID,
552: Language.DEFAULT_LANGUAGE_ID, -1, branch3
553: .getId(), language3.getId(), false);
554: variantDoc.setField("fieldType1", "notsecret");
555: fail("Creating branch should have failed because of access rights.");
556: } catch (AccessException e) {
557: }
558: }
559:
560: // test index and query features
561: {
562: Document document1 = repository.createDocument("q doc 1",
563: documentType1.getId());
564: document1.setPart(partType1.getId(), "text/xml",
565: "<html><body><p>gent</p></body></html>"
566: .getBytes("UTF-8"));
567: document1.setPart(partType2.getId(), "text/xml",
568: "<html><body><p>leuven</p></body></html>"
569: .getBytes("UTF-8"));
570: document1.save();
571:
572: Document variant1 = repository.createVariant(document1
573: .getId(), document1.getBranchId(), document1
574: .getLanguageId(), -1, branch1.getId(), language1
575: .getId(), false);
576: variant1.setPart(partType1.getId(), "text/xml",
577: "<html><body><p>kortrijk</p></body></html>"
578: .getBytes("UTF-8"));
579: variant1.setPart(partType2.getId(), "text/xml",
580: "<html><body><p>brugge</p></body></html>"
581: .getBytes("UTF-8"));
582: variant1.save();
583:
584: Document variant2 = repository.createVariant(document1
585: .getId(), variant1.getBranchId(), variant1
586: .getLanguageId(), -1, branch2.getId(), language1
587: .getId(), true);
588: variant2.setPart(partType1.getId(), "text/xml",
589: "<html><body><p>antwerpen</p></body></html>"
590: .getBytes("UTF-8"));
591: variant2.setPart(partType2.getId(), "text/xml",
592: "<html><body><p>zelzate</p></body></html>"
593: .getBytes("UTF-8"));
594: variant2.save();
595:
596: System.out
597: .println("Sleeping a bit to let fulltext indexer do its work");
598: Thread.sleep(10000);
599:
600: QueryManager queryManager = repository.getQueryManager();
601: SearchResultDocument result = queryManager.performQuery(
602: "select id where FullText('gent')", Locale.US);
603: assertEquals(1, result.getSearchResult().getRows()
604: .sizeOfRowArray());
605: SearchResultDocument.SearchResult.Rows.Row row = result
606: .getSearchResult().getRows().getRowArray(0);
607: assertEquals(document1.getId(), row.getDocumentId());
608: assertEquals(document1.getBranchId(), row.getBranchId());
609: assertEquals(document1.getLanguageId(), row.getLanguageId());
610:
611: result = queryManager.performQuery(
612: "select id where FullText('gent', 1, 1, 1, 2, 2)",
613: Locale.US);
614: assertEquals(0, result.getSearchResult().getRows()
615: .sizeOfRowArray());
616:
617: result = queryManager.performQuery(
618: "select id where FullText('brugge')", Locale.US);
619: assertEquals(1, result.getSearchResult().getRows()
620: .sizeOfRowArray());
621: row = result.getSearchResult().getRows().getRowArray(0);
622: assertEquals(variant1.getId(), row.getDocumentId());
623: assertEquals(variant1.getBranchId(), row.getBranchId());
624: assertEquals(variant1.getLanguageId(), row.getLanguageId());
625:
626: result = queryManager
627: .performQuery(
628: "select id where FullText('antwerpen and zelzate')",
629: Locale.US);
630: assertEquals(1, result.getSearchResult().getRows()
631: .sizeOfRowArray());
632: row = result.getSearchResult().getRows().getRowArray(0);
633: assertEquals(variant2.getId(), row.getDocumentId());
634: assertEquals(variant2.getBranchId(), row.getBranchId());
635: assertEquals(variant2.getLanguageId(), row.getLanguageId());
636:
637: result = queryManager.performQuery(
638: "select id, branchId, languageId, branch, language where id = '"
639: + document1.getId() + "' and languageId = "
640: + language1.getId() + " order by branchId",
641: Locale.US);
642: assertEquals(2, result.getSearchResult().getRows()
643: .sizeOfRowArray());
644: assertEquals("branch1", result.getSearchResult().getRows()
645: .getRowArray(0).getValueArray(3));
646: assertEquals("branch2", result.getSearchResult().getRows()
647: .getRowArray(1).getValueArray(3));
648: }
649:
650: // test DoesNotHaveVariant and variants identifier
651: {
652: Document document1 = repository.createDocument("ooo1",
653: documentType1.getId());
654: document1.setField(fieldType1.getId(), "ooo");
655: document1.save();
656:
657: Document document2 = repository.createDocument("ooo2",
658: documentType1.getId());
659: document2.setField(fieldType1.getId(), "ooo");
660: document2.save();
661:
662: Document document3 = repository.createDocument("ooo3",
663: documentType1.getId());
664: document3.setField(fieldType1.getId(), "ooo");
665: document3.save();
666:
667: repository.createVariant(document2.getId(),
668: Branch.MAIN_BRANCH_ID,
669: Language.DEFAULT_LANGUAGE_ID, -1, branch1.getId(),
670: language1.getId(), true);
671:
672: QueryManager queryManager = repository.getQueryManager();
673:
674: SearchResultDocument result = queryManager
675: .performQuery(
676: "select id where DoesNotHaveVariant('branch1', 'lang1') and $fieldType1 = 'ooo' order by id",
677: Locale.US);
678: assertEquals(2, result.getSearchResult().getRows()
679: .sizeOfRowArray());
680: assertEquals(document1.getId(), result.getSearchResult()
681: .getRows().getRowArray(0).getDocumentId());
682: assertEquals(document3.getId(), result.getSearchResult()
683: .getRows().getRowArray(1).getDocumentId());
684:
685: result = queryManager.performQuery(
686: "select id where DoesNotHaveVariant("
687: + branch1.getId() + ", "
688: + language1.getId()
689: + ") and $fieldType1 = 'ooo' order by id",
690: Locale.US);
691: assertEquals(2, result.getSearchResult().getRows()
692: .sizeOfRowArray());
693:
694: //
695: // test variants and variants.valueCount identifiers
696: //
697:
698: // test variants has any
699: result = queryManager
700: .performQuery(
701: "select id where language = 'default' and variants has any ('branch1:lang1', 'main:default') and $fieldType1 = 'ooo' order by id",
702: Locale.US);
703: assertEquals(3, result.getSearchResult().getRows()
704: .sizeOfRowArray());
705:
706: result = queryManager
707: .performQuery(
708: "select id where language = 'default' and variants has any ('branch1:lang1', 'branch2:lang2') and $fieldType1 = 'ooo' order by id",
709: Locale.US);
710: assertEquals(1, result.getSearchResult().getRows()
711: .sizeOfRowArray());
712:
713: result = queryManager
714: .performQuery(
715: "select id where language = 'default' and variants has any ('branch2:lang2') and $fieldType1 = 'ooo' order by id",
716: Locale.US);
717: assertEquals(0, result.getSearchResult().getRows()
718: .sizeOfRowArray());
719:
720: // test variants has all
721: result = queryManager
722: .performQuery(
723: "select id where language = 'default' and variants has all ('branch1:lang1', 'branch2:lang2') and $fieldType1 = 'ooo' order by id",
724: Locale.US);
725: assertEquals(0, result.getSearchResult().getRows()
726: .sizeOfRowArray());
727:
728: result = queryManager
729: .performQuery(
730: "select id where language = 'default' and variants has all ('branch1:lang1', 'main:default') and $fieldType1 = 'ooo' order by id",
731: Locale.US);
732: assertEquals(1, result.getSearchResult().getRows()
733: .sizeOfRowArray());
734:
735: // test variants has exactly
736: result = queryManager
737: .performQuery(
738: "select id where language = 'default' and variants has exactly ('branch1:lang1', 'main:default') and $fieldType1 = 'ooo' order by id",
739: Locale.US);
740: assertEquals(1, result.getSearchResult().getRows()
741: .sizeOfRowArray());
742:
743: result = queryManager
744: .performQuery(
745: "select id where language = 'default' and variants has exactly ('branch1:lang1') and $fieldType1 = 'ooo' order by id",
746: Locale.US);
747: assertEquals(0, result.getSearchResult().getRows()
748: .sizeOfRowArray());
749:
750: // test variants has none
751: result = queryManager
752: .performQuery(
753: "select id where language = 'default' and variants has none ('branch1:lang1') and $fieldType1 = 'ooo' order by id",
754: Locale.US);
755: assertEquals(2, result.getSearchResult().getRows()
756: .sizeOfRowArray());
757:
758: // test variants.valueCount
759: result = queryManager
760: .performQuery(
761: "select id where language = 'default' and variants.valueCount = 1 and $fieldType1 = 'ooo' order by id",
762: Locale.US);
763: assertEquals(2, result.getSearchResult().getRows()
764: .sizeOfRowArray());
765:
766: // test these things on the select-side
767: result = queryManager
768: .performQuery(
769: "select id, variants, variants.valueCount where language = 'default' and variants.valueCount = 2 and $fieldType1 = 'ooo' order by id",
770: Locale.US);
771: assertEquals(1, result.getSearchResult().getRows()
772: .sizeOfRowArray());
773: // the following is just to make sure it gets properly serialized as a multi-value link-type value
774: assertEquals(document2.getId(), result.getSearchResult()
775: .getRows().getRowArray(0).getMultiValueArray(0)
776: .getLinkValueArray(0).getDocumentId());
777: assertEquals("2", result.getSearchResult().getRows()
778: .getRowArray(0).getValueArray(1));
779:
780: }
781:
782: // test deletion of in-use variants should fail
783: {
784: Branch branchX = variantManager.createBranch("branchX");
785: branchX.save();
786:
787: Document document1 = repository.createDocument("haha",
788: documentType1.getId(), branchX.getId(),
789: Language.DEFAULT_LANGUAGE_ID);
790: document1.setField(fieldType1.getId(), "haha");
791: document1.save();
792:
793: try {
794: variantManager.deleteBranch(branchX.getId());
795: fail("Branch deletion should have failed because it is still in use.");
796: } catch (RepositoryException e) {
797: }
798:
799: repository.deleteDocument(document1.getId());
800: variantManager.deleteBranch(branchX.getId());
801: }
802:
803: // test updating of different variants in presence of locks by different users
804: // ..
805:
806: }
807: }
|