001: package org.ontoware.semversion;
002:
003: import static org.junit.Assert.assertEquals;
004: import static org.junit.Assert.assertFalse;
005: import static org.junit.Assert.assertNotNull;
006: import static org.junit.Assert.assertNull;
007: import static org.junit.Assert.assertTrue;
008:
009: import java.io.File;
010: import java.net.URISyntaxException;
011: import java.util.List;
012:
013: import org.junit.Assert;
014: import org.junit.Before;
015: import org.junit.Test;
016: import org.ontoware.aifbcommons.collection.ClosableIterator;
017: import org.ontoware.rdf2go.RDF2Go;
018: import org.ontoware.rdf2go.exception.ModelException;
019: import org.ontoware.rdf2go.model.Diff;
020: import org.ontoware.rdf2go.model.Model;
021: import org.ontoware.rdf2go.model.Statement;
022: import org.ontoware.rdf2go.model.impl.DiffImpl;
023: import org.ontoware.rdf2go.model.node.URI;
024: import org.ontoware.rdf2go.model.node.impl.URIImpl;
025: import org.ontoware.rdf2go.util.ModelUtils;
026: import org.ontoware.rdf2go.vocabulary.RDF;
027: import org.ontoware.rdf2go.vocabulary.RDFS;
028: import org.ontoware.semversion.impl.ModelCompareUtils;
029:
030: @SuppressWarnings("unused")
031: public class UsageTest {
032:
033: static final URI a = new URIImpl("test://a");
034:
035: static final URI b = new URIImpl("test://b");
036:
037: static final URI c = new URIImpl("test://c");
038:
039: private SemVersion semVersion;
040:
041: File persistenceDir = new File("./target/UsageTest");
042:
043: @Before
044: public void setUp() throws Exception {
045: semVersion = new SemVersion();
046: semVersion.startup(persistenceDir);
047: semVersion.deleteStore();
048: semVersion.createUser("Sebastian", "secret");
049: semVersion.createUser("admin", "admin");
050: }
051:
052: @Test
053: public void testBranchError() throws Exception {
054: Session session = semVersion.login("Sebastian", "secret");
055: VersionedModel vm = session
056: .createVersionedModel("GeneOntology");
057: Model m = session.getModel();
058: m.addStatement(new URIImpl("user://sebastian"), new URIImpl(
059: "rdfs://has"), new URIImpl("things://bag"));
060: vm.commitRoot(m, "mein erstes Modell");
061: session.close();
062:
063: semVersion.shutdown();
064: semVersion = new SemVersion();
065: semVersion.startup(persistenceDir);
066:
067: // login
068: session = semVersion.login("admin", "admin");
069: // get versioned model
070: VersionedModel versionedModel = session
071: .getVersionedModel("GeneOntology");
072: // get most recent version
073: Version rootVersion = versionedModel.getRoot();
074: // get real model content (actually a copy of it)
075: Model recentMainModel = rootVersion.getContent();
076: // change
077: recentMainModel.addStatement(new URIImpl("gene://cell"),
078: RDF.type, new URIImpl("gene://term"));
079: // commit
080: rootVersion.commitAsBranch(recentMainModel, "branch1",
081: "celltypes added", false);
082: recentMainModel.close();
083: session.close();
084:
085: // login
086: session = semVersion.login("Sebastian", "secret");
087: // get versioned model
088: VersionedModel versionedModel2 = session
089: .getVersionedModel("GeneOntology");
090: // get most recent version
091: Version rootVersion2 = versionedModel2.getRoot();
092: // get real model content (actually a copy of it)
093: Model recentMainModel2 = rootVersion2.getContent();
094: // change
095: recentMainModel2.addStatement(new URIImpl("user://sebastian"),
096: new URIImpl("rdfs://has"),
097: new URIImpl("things://paper"));
098: // commit
099:
100: boolean exceptionThrown = false;
101: try {
102: rootVersion.commitAsBranch(recentMainModel, "branch1",
103: "paper added", false);
104: session.close();
105: } catch (BranchlabelAlreadyUsedException e) {
106: exceptionThrown = true;
107: }
108: assertTrue(exceptionThrown);
109:
110: }
111:
112: @Test
113: public void testCommitConflict() throws Exception {
114: Session session = semVersion.login("Sebastian", "secret");
115: VersionedModel vm = session
116: .createVersionedModel("GeneOntology");
117: Model m = session.getModel();
118: m.addStatement(new URIImpl("user://sebastian"), new URIImpl(
119: "rdfs://has"), new URIImpl("things://bag"));
120: vm.commitRoot(m, "mein erstes Modell");
121: session.close();
122: semVersion.shutdown();
123: semVersion = new SemVersion();
124: semVersion.startup(persistenceDir);
125:
126: // login
127: session = semVersion.login("admin", "admin");
128: // get versioned model
129: VersionedModel versionedModel = session
130: .getVersionedModel("GeneOntology");
131: // get most recent version
132: Version rootVersion = versionedModel.getRoot();
133: // get real model content (actually a copy of it)
134: Model recentMainModel = rootVersion.getContent();
135: // change
136: recentMainModel.addStatement(new URIImpl("gene://cell"),
137: RDF.type, new URIImpl("gene://term"));
138: // commit
139: rootVersion.commit(recentMainModel, "celltypes added", false);
140: session.close();
141:
142: // login
143: session = semVersion.login("Sebastian", "secret");
144: // get versioned model
145: VersionedModel versionedModel2 = session
146: .getVersionedModel("GeneOntology");
147: // get most recent version
148: Version rootVersion2 = versionedModel2.getRoot();
149: // get real model content (actually a copy of it)
150: Model recentMainModel2 = rootVersion2.getContent();
151: // change
152: recentMainModel2.addStatement(new URIImpl("user://sebastian"),
153: new URIImpl("rdfs://has"),
154: new URIImpl("things://paper"));
155: // commit
156:
157: boolean exceptionThrown = false;
158: try {
159: rootVersion2.commit(recentMainModel2, "Paper added", false);
160: session.close();
161: } catch (CommitConflictException e) {
162: exceptionThrown = true;
163: }
164: assertTrue(exceptionThrown);
165: }
166:
167: @Test
168: public void testCommitRoot() throws URISyntaxException, Exception {
169: Session session = semVersion.login("Sebastian", "secret");
170: VersionedModel vm = session
171: .createVersionedModel("GeneOntology");
172: assertNotNull(vm);
173: assertNull(vm.getRoot());
174: session.close();
175:
176: session = semVersion.login("Sebastian", "secret");
177: vm = session.getVersionedModel("GeneOntology");
178: assertNotNull(vm);
179: assertNull(vm.getRoot());
180: Model m = session.getModel();
181: m.addStatement(new URIImpl("user://sebastian"), new URIImpl(
182: "rdfs://has"), new URIImpl("things://bag"));
183: assertNull(vm.getRoot());
184: vm.commitRoot(m, "mein erstes Modell");
185: assertNotNull(vm.getRoot());
186: session.close();
187: semVersion.shutdown();
188:
189: semVersion = new SemVersion();
190: semVersion.startup(persistenceDir);
191: session = semVersion.login("admin", "admin");
192: vm = session.getVersionedModel("GeneOntology");
193: assertEquals("mein erstes Modell", vm.getRoot().getLabel());
194: assertFalse(vm.getRoot().isSuggestion());
195: assertEquals("Sebastian", vm.getLastModifiedBy());
196: }
197:
198: @Test
199: public void testCompareTwoLatestVersions() throws Exception {
200: String FIRST_MODEL = "first model";
201: String SECOND_MODEL = "second model";
202: String GENE_ONTOLOGY = "GeneOntology";
203:
204: Session session = semVersion.login("Sebastian", "secret");
205: VersionedModel vm = session.createVersionedModel(GENE_ONTOLOGY);
206: Model rootModel = session.getModel();
207: assertEquals(0, rootModel.size());
208: rootModel.addStatement(a, RDFS.subClassOf, b);
209: rootModel.addStatement(b, RDFS.subClassOf, c);
210: assertEquals(2, rootModel.size());
211: Version firstVersion = vm.commitRoot(rootModel, FIRST_MODEL);
212:
213: // verify
214: Version firstVersion_ = vm.getRoot();
215: assertEquals(firstVersion_.getURI(), firstVersion_.getURI());
216: Model rootModel2 = firstVersion_.getContent();
217: assertEquals(2, rootModel2.size());
218: rootModel2.addStatement(a, RDFS.subClassOf, c);
219:
220: assertEquals(3, rootModel2.size());
221: Version secondVersion = firstVersion_.commit(rootModel2,
222: SECOND_MODEL, false);
223: Model secondModel = secondVersion.getContent();
224: assertEquals(3, secondModel.size());
225:
226: // rootModel should still have only 2 statements
227: rootModel2 = vm.getRoot().getContent();
228: assertEquals(2, rootModel2.size());
229: Version secondVersion_ = vm.getLastMainbranchVersion();
230: assertEquals(secondVersion.getURI(), secondVersion_.getURI());
231: Model secondModel_ = secondVersion_.getContent();
232:
233: assertEquals(3, secondModel_.size());
234:
235: // logout, login
236: session.close();
237: semVersion.shutdown();
238: semVersion = new SemVersion();
239: semVersion.startup(persistenceDir);
240: session = semVersion.login("Sebastian", "secret");
241:
242: // get versioned model
243: VersionedModel versionedModel = session
244: .getVersionedModel(GENE_ONTOLOGY);
245: assertEquals(GENE_ONTOLOGY, versionedModel.getLabel());
246:
247: // get most recent version and first parent
248: Version headVersion = versionedModel.getLastMainbranchVersion();
249: assertNotNull(headVersion.getFirstParent());
250: assertEquals(SECOND_MODEL, headVersion.getComment());
251: Model headModel = headVersion.getContent();
252: assertEquals(3, headModel.size());
253:
254: Version previousMainVersion = headVersion.getFirstParent();
255: assertNotNull(previousMainVersion);
256: assertEquals(FIRST_MODEL, previousMainVersion.getLabel());
257: Model previousMainModel = previousMainVersion.getContent();
258: assertEquals(2, previousMainModel.size());
259:
260: // calculate diff between the models
261: Diff diff = semVersion.getSemanticDiff_RDFS(previousMainModel,
262: headModel);
263: assertEquals(0, ModelUtils.size(diff.getAdded()));
264: assertEquals(0, ModelUtils.size(diff.getRemoved()));
265:
266: diff = semVersion
267: .getSyntacticDiff(previousMainModel, headModel);
268:
269: // System.out.println("Added:");
270: // diff.getAdded().dump(null);
271: // System.out.println("Removed:");
272: // diff.getRemoved().dump(null);
273: assertEquals(1, ModelUtils.size(diff.getAdded()));
274: assertEquals(0, ModelUtils.size(diff.getRemoved()));
275: }
276:
277: @Test
278: public void testCreateBranch() throws Exception {
279: Session session = semVersion.login("Sebastian", "secret");
280: VersionedModel vm = session
281: .createVersionedModel("GeneOntology");
282: Model m = session.getModel();
283: m.addStatement(new URIImpl("user://sebastian"), new URIImpl(
284: "rdfs://has"), new URIImpl("things://bag"));
285: vm.commitRoot(m, "meine erstes Modell");
286: session.close();
287:
288: semVersion.shutdown();
289: semVersion = new SemVersion();
290: semVersion.startup(persistenceDir);
291:
292: // login
293: session = semVersion.login("Sebastian", "secret");
294: // get versioned model
295: VersionedModel versionedModel = session
296: .getVersionedModel("GeneOntology");
297:
298: // get most recent version
299: Version recentMainVersion = versionedModel
300: .getLastMainbranchVersion();
301:
302: // get real model content (actually a copy of it)
303: Model recentMainModel = recentMainVersion.getContent();
304:
305: // change
306: recentMainModel.addStatement(new URIImpl("gene://cell"),
307: RDF.type, new URIImpl("gene://term"));
308:
309: // vm.dump();
310:
311: // commit
312: recentMainVersion.commitAsBranch(recentMainModel,
313: "branchLabels", "celltypes", false);
314: // vm.dump();
315: }
316:
317: @Test
318: public void testCreateFinalAsChildOfSuggestion() throws Exception {
319: Session session = semVersion.login("Sebastian", "secret");
320: VersionedModel vm = session
321: .createVersionedModel("GeneOntology");
322: Model m = session.getModel();
323: m.addStatement(new URIImpl("user://sebastian"), new URIImpl(
324: "rdfs://has"), new URIImpl("things://bag"));
325: vm.commitRoot(m, "mein erstes Modell");
326: session.close();
327: semVersion.shutdown();
328: semVersion = new SemVersion();
329: semVersion.startup(persistenceDir);
330: // login
331: session = semVersion.login("admin", "admin");
332: // get versioned model
333: VersionedModel versionedModel = session
334: .getVersionedModel("GeneOntology");
335: // get most recent version
336: Version rootVersion = versionedModel.getRoot();
337: // get real model content (actually a copy of it)
338: Model recentMainModel = rootVersion.getContent();
339: // change
340: recentMainModel.addStatement(new URIImpl("gene://cell"),
341: RDF.type, new URIImpl("gene://term"));
342: // commit
343: Version v = rootVersion.commit(recentMainModel,
344: "celltypes added", true);
345: Model newModel = v.getContent();
346: newModel.addStatement(new URIImpl("gene://cell"), RDF.type,
347: new URIImpl("gene://term2"));
348: boolean exceptionThrown = false;
349: try {
350: v.commit(newModel, "another cellType added", false);
351: } catch (InvalidChildOfSuggestionException iae) {
352: exceptionThrown = true;
353: }
354: assertTrue(exceptionThrown);
355: session.close();
356: }
357:
358: @Test
359: public void testCreateRoot() throws Exception {
360: semVersion.createUser("carlos", "secret");
361:
362: Session session = semVersion.login("carlos", "secret");
363:
364: // create a versioned model
365: VersionedModel vm = session
366: .createVersionedModel("Gene Ontology 2005");
367:
368: assertNull("should be null but is "
369: + ((VersionedModel) vm).getRoot(),
370: ((VersionedModel) vm).getRoot());
371:
372: session.close();
373: semVersion.shutdown();
374: semVersion = new SemVersion();
375: semVersion.startup(persistenceDir);
376: session = semVersion.login("carlos", "secret");
377: assertEquals("carlos", session.getUser().getName());
378: vm = session.getVersionedModel("Gene Ontology 2005");
379: assertEquals("carlos", vm.getUser().getName());
380:
381: // create a triple set with the content of our root version
382: // for testing purposes, we just create an empty triple set with
383: // a random uri
384: Model rootContent = session.getModel();
385:
386: // commit the triple set as the root content
387: assertNull("should be null but is "
388: + ((VersionedModel) vm).getRoot(),
389: ((VersionedModel) vm).getRoot());
390: vm
391: .commitRoot(
392: rootContent, // triple set
393: "My Root Version", // label
394: "", // comment
395: new URIImpl(
396: "urn:semversion.ontoware.org/GO14072005/V1"), // version
397: // uri
398: new URIImpl("urn:semversion.ontoware.org") // provenance
399: );
400:
401: session.close();
402: semVersion.shutdown();
403: semVersion = new SemVersion();
404: semVersion.startup(persistenceDir);
405: session = semVersion.login("Sebastian", "secret");
406: vm = session.getVersionedModel("Gene Ontology 2005");
407:
408: assertTrue(vm instanceof VersionedModel);
409: assertNotNull(((VersionedModel) vm).getRoot());
410:
411: assertEquals("There should be exactly 1 (the root version)", 1,
412: vm.getVersionCount());
413:
414: Version vers = vm.getFirstVersion();
415: assertNotNull(vers);
416: assertEquals("carlos", vers.getUser().getName());
417: }
418:
419: @Test
420: public void testCreateVersionedModel() throws Exception {
421: Session session = semVersion.login("Sebastian", "secret");
422: VersionedModel vm = session
423: .createVersionedModel("GeneOntology");
424: assertNotNull(vm);
425: session.close();
426: semVersion.shutdown();
427: semVersion = new SemVersion();
428: semVersion.startup(persistenceDir);
429: session = semVersion.login("admin", "admin");
430: vm = session.getVersionedModel("GeneOntology");
431: assertNotNull(vm);
432: assertEquals(0, vm.getAllVersions().size());
433: assertNull(vm.getFirstVersion());
434: assertNull(vm.getLastMainbranchVersion());
435: session.close();
436: }
437:
438: @Test
439: public void testCreateVersionedModelWithSameName() throws Exception {
440: Session session = semVersion.login("Sebastian", "secret");
441: VersionedModel vm = session
442: .createVersionedModel("GeneOntology");
443: assertNotNull(vm);
444: session.close();
445: semVersion.shutdown();
446: semVersion = new SemVersion();
447: semVersion.startup(persistenceDir);
448: session = semVersion.login("admin", "admin");
449: try {
450: vm = session.createVersionedModel("GeneOntology");
451: Assert.fail();
452: } catch (DuplicateLabelException e) {
453: // ok
454: }
455: session.close();
456: }
457:
458: @Test
459: public void testCreateVersionedModelWithValidTime()
460: throws Exception {
461: Session session = semVersion.login("Sebastian", "secret");
462:
463: VersionedModel vm = session.createVersionedModel(new URIImpl(
464: "urn:semversion.ontoware.org/GO14072005"),
465: "GeneOntology");
466: assertNotNull(vm);
467: VersionedModel vm2 = session.getVersionedModel("GeneOntology");
468: assertTrue(vm.equals(vm2));
469: session.close();
470: }
471:
472: @SuppressWarnings("deprecation")
473: @Test
474: public void testGettersVersionedModel() throws Exception {
475: semVersion.createUser("carlos", "secret");
476: Session session = semVersion.login("carlos", "secret");
477:
478: VersionedModel vm = session.createVersionedModel(new URIImpl(
479: "urn:semversion.ontoware.org/GO14082005"),
480: "Gene Ontology 2005");
481:
482: vm
483: .commitRoot(
484: session.getModel(),
485: "My Root Version",
486: "",
487: new URIImpl(
488: "urn:semversion.ontoware.org/GO14082005/V1"),
489: new URIImpl("urn:semversion.ontoware.org"));
490:
491: session.close();
492: semVersion.shutdown();
493: semVersion = new SemVersion();
494: semVersion.startup(persistenceDir);
495: session = semVersion.login("Sebastian", "secret");
496: vm = session.getVersionedModel("Gene Ontology 2005");
497:
498: assertNotNull(vm.getLastVersions());
499: assertTrue(vm.getLastVersions().size() > 0);
500: assertEquals("carlos", vm.getLastModifiedBy());
501:
502: List<User> theUsers = vm.getListLastModifiedBy();
503: assertEquals("carlos", theUsers.get(0).getName());
504:
505: List<Version> lst1 = vm.getVersions();
506: assertEquals(1, lst1.size());
507: Version vers1 = lst1.get(0);
508: assertNotNull(vers1);
509: assertEquals("My Root Version", vers1.getLabel());
510: }
511:
512: @Test
513: public void testGetVersionedModel() throws Exception {
514: // basically: do what users will do
515:
516: // check count of versions
517: // get first and last and compare by uri
518: // set flags
519:
520: semVersion.createUser("carlos", "secret");
521: Session session = semVersion.login("carlos", "secret");
522:
523: // create VersionedModel
524: VersionedModel vm = session.createVersionedModel(new URIImpl(
525: "urn:semversion.ontoware.org/GO14072005"),
526: "Gene Ontology 2005");
527:
528: // commit root/initial version
529: Model m = session.getModel();
530: assertNotNull(m);
531: m.addStatement(new URIImpl("gene://cell_1"), RDF.type,
532: new URIImpl("gene://cell"));
533: assertEquals(1, m.size());
534: ClosableIterator<Statement> it = m.iterator();
535: Statement s = it.next();
536: it.close();
537: assertEquals(new URIImpl("gene://cell_1"), s.getSubject());
538: assertEquals(RDF.type, s.getPredicate());
539: assertEquals(new URIImpl("gene://cell"), s.getObject());
540: vm.commitRoot(m, "My root Version");
541: assertTrue(ModelCompareUtils.equals(m, vm
542: .getLastMainbranchVersion().getContent()));
543: m.close();
544:
545: // commit a diff
546: DiffImpl diff = new DiffImpl();
547: diff.addStatement(new URIImpl("gene://cell_2"), RDF.type,
548: new URIImpl("gene://cell"));
549: diff.removeStatement(new URIImpl("gene://cell_1"), RDF.type,
550: new URIImpl("gene://cell"));
551:
552: Version lastMainBranch = vm.getLastMainbranchVersion();
553: Version diffCommitedVersion = lastMainBranch.commit(diff,
554: "second Version", new URIImpl("model://diff"), null,
555: false);
556:
557: Model m_ = diffCommitedVersion.getContent();
558:
559: assertEquals(1, m_.size());
560: it = m_.iterator();
561: s = it.next();
562: it.close();
563: assertEquals(new URIImpl("gene://cell_2"), s.getSubject());
564: assertEquals(RDF.type, s.getPredicate());
565: assertEquals(new URIImpl("gene://cell"), s.getObject());
566: m_.close();
567:
568: Model m2 = vm.getLastMainbranchVersion().getContent();
569: assertNotNull(m2);
570: assertEquals(1, m2.size());
571: it = m2.iterator();
572: Statement stmt = it.next();
573: it.close();
574: m2.close();
575:
576: assertEquals(new URIImpl("gene://cell_2"), stmt.getSubject());
577: assertEquals(new URIImpl("gene://cell"), stmt.getObject());
578: assertEquals(RDF.type, stmt.getPredicate());
579:
580: Diff newDiff = semVersion.getSyntacticDiff(vm.getRoot()
581: .getContent(), vm.getLastMainbranchVersion()
582: .getContent());
583: assertEquals(diff.getAdded(), newDiff.getAdded());
584: assertEquals(diff.getRemoved(), newDiff.getRemoved());
585:
586: // commit another diff
587: Diff diff2 = new DiffImpl();
588: diff2.addStatement(new URIImpl("gene://cell_3"), RDF.type,
589: new URIImpl("gene://cell"));
590: diff2.addStatement(new URIImpl("gene://cell_4"), RDF.type,
591: new URIImpl("gene://cell"));
592:
593: Version lastMainBranchVersion = vm.getLastMainbranchVersion();
594: lastMainBranchVersion.commit(diff2, "third Version",
595: new URIImpl("model://diff2"), null, false);
596:
597: Model m3 = vm.getLastMainbranchVersion().getContent();
598: assertNotNull(m3);
599: assertEquals(3, m3.size());
600: assertEquals("third Version", vm.getLastMainbranchVersion()
601: .getComment());
602:
603: assertEquals("commit", vm.getLastMainbranchVersion()
604: .getChangeCause());
605:
606: List<Change> changes = vm.getChangeLog();
607: assertEquals(vm.getAllVersions().size(), changes.size());
608: for (Change change : changes) {
609: System.out.println(change.getCreationCause());
610: }
611: }
612:
613: /**
614: * Get a List of all VersionedModels, checkout one, change that model and
615: * commit it
616: */
617: @Test
618: public void testListCheckoutChangeCommit() throws Exception {
619: Session session = semVersion.login("Sebastian", "secret");
620: VersionedModel vm = session
621: .createVersionedModel("GeneOntology");
622: assertNotNull(vm);
623: Version rootVersion = vm.getRoot();
624: assertNull(rootVersion);
625: Model m = session.getModel();
626: m.addStatement(new URIImpl("user://sebastian"), new URIImpl(
627: "rdfs://has"), new URIImpl("things://bag"));
628: vm.commitRoot(m, "meine erstes Modell");
629:
630: session.close();
631: semVersion.shutdown();
632: semVersion = new SemVersion();
633: semVersion.startup(persistenceDir);
634: session = semVersion.login("admin", "admin");
635:
636: // semVersion.dump();
637:
638: // get versioned model
639: VersionedModel versionedModel = session
640: .getVersionedModel("GeneOntology");
641: assertNotNull(versionedModel);
642: // get most recent version
643: Version recentMainVersion = versionedModel
644: .getLastMainbranchVersion();
645: // get real model content (actually a copy of it)
646: Model recentMainModel = recentMainVersion.getContent();
647: // change
648: recentMainModel.addStatement(new URIImpl("gene://cell"),
649: RDF.type, new URIImpl("gene://term"));
650: // commit
651: recentMainVersion.commit(recentMainModel, "celltypes", false);
652:
653: // semVersion.dump();
654:
655: }
656:
657: @Test
658: public void testMemoryModelCommit() throws Exception {
659: semVersion.createUser("carlos", "secret");
660: Session session = semVersion.login("carlos", "secret");
661:
662: VersionedModel vm = session.createVersionedModel(new URIImpl(
663: "urn:semversion.ontoware.org/GO14072005"),
664: "Gene Ontology 2005");
665:
666: Model m = RDF2Go.getModelFactory().createModel();
667: m.open();
668: m.addStatement(new URIImpl("gene://cell_1"), RDF.type,
669: new URIImpl("gene://cell"));
670: vm.commitRoot(m, "root Version");
671: assertTrue(ModelCompareUtils.equals(m, vm
672: .getLastMainbranchVersion().getContent()));
673: }
674:
675: // TODO test branch & then merge
676: // @Test
677: // public void testMerge() throws Exception {
678: // Session session = semVersion.login("Sebastian", "secret");
679: // VersionedModel vm = session.createVersionedModel("GeneOntology");
680: // Model m = session.getModel();
681: // m.addStatement(new URIImpl("user://sebastian"), new URIImpl(
682: // "rdfs://has"), new URIImpl("things://bag1"));
683: // vm.commitRoot(m, "mein erstes Modell");
684: // session.close();
685: // semVersion.shutdown();
686: // semVersion = new SemVersion();
687: // semVersion.startup(persistenceDir);
688: //
689: // /*
690: // * login, merge Models, logout
691: // */
692: // session = semVersion.login("Sebastian", "secret");
693: // vm = session.getVersionedModel("GeneOntology");
694: // m = session.getModel();
695: // m.addStatement(new URIImpl("user://sebastian"), new URIImpl(
696: // "rdfs://has"), new URIImpl("things://ball"));
697: //
698: // Version latest = vm.getLastMainbranchVersion();
699: // assertNotNull(latest);
700: // assertEquals(0, latest.getAllChildren().length);
701: // Version child = latest.merge(m, "added", true);
702: // semVersion.shutdown();
703: // semVersion = new SemVersion();
704: // semVersion.startup(persistenceDir);
705: // session = semVersion.login("admin", "admin");
706: // vm = session.getVersionedModel("GeneOntology");
707: // latest = vm.getLastMainbranchVersion();
708: // child = vm.getLastMainbranchVersion().getAllChildren()[0];
709: // assertEquals(1, latest.getAllChildren().length);
710: // assertEquals(2, child.getContent().size());
711: // ClosableIterator<? extends Statement> iter = child.getContent()
712: // .findStatements(Variable.ANY, Variable.ANY,
713: // new URIImpl("things://bag1"));
714: // assertTrue(iter.hasNext());
715: // Statement s = iter.next();
716: // assertEquals(new URIImpl("user://sebastian"), s.getSubject());
717: // assertFalse(iter.hasNext());
718: //
719: // List<Change> changes = vm.getChangeLog();
720: // assertEquals(2, changes.size());
721: // for (Change change : changes) {
722: // Version v = change.getNewVersion();
723: // if (v.getComment().equals("added")) {
724: // assertEquals("merge", change.getCreationCause());
725: // } else {
726: // assertEquals("commit", change.getCreationCause());
727: // }
728: // }
729: // session.close();
730: // }
731:
732: @Test
733: public void testNavigationalGettersVersion() throws LoginException,
734: ModelException {
735: User carlos = semVersion.createUser("carlos", "secret");
736: Session session = semVersion.login("carlos", "secret");
737:
738: VersionedModel vm = session.createVersionedModel(new URIImpl(
739: "urn:semversion.ontoware.org/GO14072005"),
740: "Gene Ontology 2005");
741:
742: vm
743: .commitRoot(
744: session.getModel(),
745: "My Root Version",
746: "",
747: new URIImpl(
748: "urn:semversion.ontoware.org/GO14072005/V1"),
749: new URIImpl("urn:semversion.ontoware.org"));
750:
751: Version vRoot = vm.getFirstVersion();
752: assertNotNull(vRoot);
753:
754: vRoot
755: .commit(
756: session.getModel(),
757: "My Second Version",
758: new URIImpl(
759: "urn:semversion.ontoware.org/GO14072005/V2"),
760: new URIImpl("urn:semversion.ontoware.org"),
761: false);
762:
763: List<Version> lst1 = vm.getLastVersions();
764: Version v2 = lst1.get(0);
765: assertNotNull(v2);
766:
767: Version v3 = v2
768: .commit(
769: session.getModel(),
770: "My Third Version",
771: new URIImpl(
772: "urn:semversion.ontoware.org/GO14072005/V3"),
773: new URIImpl("urn:semversion.ontoware.org"),
774: false);
775: assertNotNull(v3);
776:
777: List<Version> lst2 = vm.getLastVersions();
778: assertEquals(v3, lst2.get(0));
779:
780: Version theV2 = v3.getPrevVersion();
781: assertNotNull(theV2);
782: assertEquals(v2, theV2);
783: Object theVNull = v3.getSecondParent();
784: assertNull(theVNull);
785:
786: Version lst3 = v3.getPrevVersion();
787: assertNotNull(lst3);
788: assertEquals(v2, lst3);
789:
790: Version lst4 = v2.getPrevVersion();
791: assertNotNull(lst4);
792: assertEquals(vRoot, lst4);
793:
794: Version lst5 = vRoot.getPrevVersion();
795: assertNull(lst5);
796:
797: List<Version> lst6 = v3.getNextVersions();
798: assertEquals(0, lst6.size());
799:
800: }
801:
802: @Test
803: public void testRootIsNull() throws Exception {
804: Session session = semVersion.login("Sebastian", "secret");
805: VersionedModel vm = session
806: .createVersionedModel("GeneOntology");
807: assertNotNull(vm);
808: session.close();
809: semVersion.shutdown();
810: semVersion = new SemVersion();
811: semVersion.startup(persistenceDir);
812: session = semVersion.login("admin", "admin");
813: vm = session.getVersionedModel("GeneOntology");
814: assertNotNull(vm);
815: assertNull(vm.getRoot());
816: session.close();
817: }
818:
819: @Test(expected=RuntimeException.class)
820: public void testUserCreation() {
821:
822: User carlos = semVersion.createUser("carlos", "secret");
823: assertNotNull(carlos);
824: assertEquals(carlos.getName(), "carlos");
825: assertEquals(carlos.getPassword(), "secret");
826: semVersion.createUser("admin", "anything");
827: }
828:
829: @Test
830: public void testViewChangeLog() throws Exception {
831:
832: Session session = semVersion.login("Sebastian", "secret");
833: VersionedModel vm = session
834: .createVersionedModel("GeneOntology");
835: Model m = session.getModel();
836: m.addStatement(new URIImpl("user://sebastian"), new URIImpl(
837: "rdfs://has"), new URIImpl("things://bag"));
838: // vm.commitRoot(m, "mein erstes Modell", URIImpl
839: // ("version://1"), new ValidTime(new Date(),
840: // ValidTime.NOW), VersionedItem.NO_PROVENANCE);
841: vm.commitRoot(m, "mein erstes Modell");
842: session.close();
843: semVersion.shutdown();
844: semVersion = new SemVersion();
845: semVersion.startup(persistenceDir);
846:
847: // login
848: session = semVersion.login("Sebastian", "secret");
849:
850: // get versioned model
851: VersionedModel versionedModel = session
852: .getVersionedModel("GeneOntology");
853:
854: List<Change> changes = versionedModel.getChangeLog();
855: assertEquals(1, changes.size());
856: for (Change change : changes) {
857: Version v = change.getNewVersion();
858: assertEquals("mein erstes Modell", v.getLabel());
859: assertEquals("commit", change.getCreationCause());
860: }
861: }
862:
863: @Test
864: public void testViewSuggestions() throws Exception {
865: Session session = semVersion.login("Sebastian", "secret");
866: VersionedModel vm = session
867: .createVersionedModel("GeneOntology");
868: Model m = session.getModel();
869: m.addStatement(new URIImpl("user://sebastian"), new URIImpl(
870: "rdfs://has"), new URIImpl("things://bag"));
871: vm.commitRoot(m, "meine erstes Modell");
872: session.close();
873:
874: semVersion.shutdown();
875: semVersion = new SemVersion();
876: semVersion.startup(persistenceDir);
877:
878: // login
879: session = semVersion.login("Sebastian", "secret");
880:
881: // get versioned model
882: VersionedModel versionedModel = session
883: .getVersionedModel("GeneOntology");
884:
885: Version latestVersion = versionedModel
886: .getLastMainbranchVersion();
887:
888: List<Version> suggestions = latestVersion.getSuggestions();
889:
890: for (Version v : suggestions) {
891: assertTrue(v.isSuggestion());
892: assertNull(v.getBranchLabel());
893: System.out.println("User " + v.getUser()
894: + " has made a suggestion at "
895: + v.getCreationTime());
896: }
897: }
898:
899: }
|