001: package com.sun.portal.app.filesharing.repo;
002:
003: import com.sun.portal.app.filesharing.util.JdbcTestCase;
004: import com.sun.portal.app.filesharing.util.SQLExecutor;
005: import com.sun.portal.app.filesharing.util.SQLTask;
006: import com.sun.portal.app.filesharing.util.IOUtils;
007:
008: import java.io.*;
009: import java.sql.Connection;
010: import java.sql.SQLException;
011: import java.sql.Statement;
012: import java.util.Set;
013: import java.util.HashSet;
014: import java.util.Iterator;
015:
016: /**
017: * @author Alejandro Abdelnur
018: */
019: public class JdbcRepositoryTest extends JdbcTestCase {
020:
021: public JdbcRepositoryTest() throws Exception {
022: super ("testdb1");
023: }
024:
025: public void setUp() throws Exception {
026: SQLExecutor sqlExec = getSQLExecutor();
027: try {
028: sqlExec.execute(new DropTableSQLTask());
029: } catch (SQLException ex) {
030: }
031: sqlExec.execute(new CreateTableSQLTask());
032: }
033:
034: public static class CreateTableSQLTask implements SQLTask {
035: public void run(Connection conn) throws SQLException {
036: Statement stat = conn.createStatement();
037: try {
038: StringBuffer sb = new StringBuffer();
039: BufferedReader br = new BufferedReader(new FileReader(
040: "src/conf/30createtables.sql"));
041: String s = br.readLine();
042: while (s != null) {
043: sb.append(s).append(" ");
044: s = br.readLine();
045: }
046: br.close();
047: s = sb.toString();
048: s = s.substring(0, s.length() - 2);
049: stat.execute(s);
050: } catch (IOException ex) {
051: throw new SQLException(ex.getMessage());
052: }
053: stat.close();
054: }
055: }
056:
057: public static class DropTableSQLTask implements SQLTask {
058: public void run(Connection conn) throws SQLException {
059: Statement stat = conn.createStatement();
060: stat.execute("drop table filesystem");
061: stat.close();
062: }
063: }
064:
065: public static class DeleteTableSQLTask implements SQLTask {
066: public void run(Connection conn) throws SQLException {
067: Statement stat = conn.createStatement();
068: stat.execute("delete from filesystem");
069: stat.close();
070: }
071: }
072:
073: private Repository getRepository() throws Exception {
074: return new JdbcRepository(null, "dummy");
075: }
076:
077: private static final byte[] PAYLOAD = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
078: .getBytes();
079:
080: public void testRepository() throws Exception {
081: Repository repo = getRepository();
082: InputStream is;
083: OutputStream os;
084: RepoItem f1 = new RepoItem(RepoItem.ROOT, "f1.file", "owner",
085: PAYLOAD.length);
086: RepoItem d1 = new RepoItem(RepoItem.ROOT, "d1.dir", "owner");
087: RepoItem f1d1 = new RepoItem(d1, "f1d1.file", "owner",
088: PAYLOAD.length);
089: RepoItem d1d1 = new RepoItem(d1, "d1d1.dir", "owner");
090: RepoItem f1d1d1 = new RepoItem(d1d1, "f1d1d1.file", "owner",
091: PAYLOAD.length);
092: RepoItem f2 = new RepoItem(RepoItem.ROOT, "f2.file", "owner",
093: PAYLOAD.length);
094: RepoItem d2 = new RepoItem(RepoItem.ROOT, "d2.dir", "owner");
095: RepoItem f2d2 = new RepoItem(d2, "f2d2.file", "owner",
096: PAYLOAD.length);
097: RepoItem d2d2 = new RepoItem(d2, "d2d2.dir", "owner");
098: RepoItem item1;
099: RepoItem item2;
100: RepoItem[] content1;
101: RepoItem[] content2;
102: Set set1;
103: Set set2;
104: /*
105: // get emtpy ROOT content
106: content1 = repo.getContent(RepoItem.ROOT);
107: assertEquals(content1.length,0);
108:
109: // add file at root
110: assertNull(repo.getItemInfo(f1));
111: is = new ByteArrayInputStream(PAYLOAD);
112: repo.addFile(f1,is);
113: assertNotNull(repo.getItemInfo(f1));
114:
115: // add folder at root
116: assertNull(repo.getItemInfo(d1));
117: repo.addFolder(d1);
118: assertNotNull(repo.getItemInfo(d1));
119:
120: // add file at folder
121: assertNull(repo.getItemInfo(f1d1));
122: is = new ByteArrayInputStream(PAYLOAD);
123: repo.addFile(f1d1,is);
124: assertNotNull(repo.getItemInfo(f1d1));
125:
126: // add folder at folder
127: assertNull(repo.getItemInfo(d1d1));
128: repo.addFolder(d1d1);
129: assertNotNull(repo.getItemInfo(d1d1));
130:
131: // get info file at root
132: item1 = repo.getItemInfo(f1);
133: assertNotNull(item1);
134: assertEquals(item1.getParent(),f1.getParent());
135: assertEquals(item1.getName(),f1.getName());
136: assertEquals(item1.getCreator(),f1.getCreator());
137: assertFalse(item1.isDirectory());
138: assertFalse(item1.getCreated()==0L);
139: assertFalse(item1.getLastModified()==0L);
140: assertEquals(item1.getLength(),PAYLOAD.length);
141:
142: // get info file at folder
143: item1 = repo.getItemInfo(f1d1);
144: assertNotNull(item1);
145: assertEquals(item1.getParent(),f1d1.getParent());
146: assertEquals(item1.getName(),f1d1.getName());
147: assertEquals(item1.getCreator(),f1d1.getCreator());
148: assertFalse(item1.isDirectory());
149: assertFalse(item1.getCreated()==0L);
150: assertFalse(item1.getLastModified()==0L);
151: assertEquals(item1.getLength(),PAYLOAD.length);
152:
153: // get info folder at root
154: item1 = repo.getItemInfo(d1);
155: assertNotNull(item1);
156: assertEquals(item1.getParent(),d1.getParent());
157: assertEquals(item1.getName(),d1.getName());
158: assertEquals(item1.getCreator(),d1.getCreator());
159: assertTrue(item1.isDirectory());
160: assertFalse(item1.getCreated()==0L);
161: assertFalse(item1.getLastModified()==0L);
162:
163: // get info folder at folder
164: item1 = repo.getItemInfo(d1d1);
165: assertNotNull(item1);
166: assertEquals(item1.getParent(),d1d1.getParent());
167: assertEquals(item1.getName(),d1d1.getName());
168: assertEquals(item1.getCreator(),d1d1.getCreator());
169: assertTrue(item1.isDirectory());
170: assertFalse(item1.getCreated()==0L);
171: assertFalse(item1.getLastModified()==0L);
172:
173: // get content at root
174: content1 = repo.getContent(RepoItem.ROOT);
175: assertNotNull(content1);
176: content2 = new RepoItem[2];
177: content2[0] = f1;
178: content2[1] = d1;
179: assertEquals(array2Set(content1),array2Set(content2));
180:
181: // get content at folder
182: content1 = repo.getContent(d1);
183: assertNotNull(content1);
184: content2 = new RepoItem[2];
185: content2[0] = f1d1;
186: content2[1] = d1d1;
187: assertEquals(array2Set(content1),array2Set(content2));
188:
189: // delete empty folder at folder
190: assertNotNull(repo.getItemInfo(d1d1));
191: repo.deleteFolder(d1d1,false);
192: assertNull(repo.getItemInfo(d1d1));
193:
194: // delete file at folder
195: assertNotNull(repo.getItemInfo(f1d1));
196: repo.deleteFile(f1d1);
197: assertNull(repo.getItemInfo(f1d1));
198:
199: // delete empty folder at root
200: assertNotNull(repo.getItemInfo(d1));
201: repo.deleteFolder(d1,false);
202: assertNull(repo.getItemInfo(d1));
203:
204: // delete file at root
205: assertNotNull(repo.getItemInfo(f1));
206: repo.deleteFile(f1);
207: assertNull(repo.getItemInfo(f1));
208:
209: cleanRepo();
210:
211: //// adding files & folders for next 2 tests
212: is = new ByteArrayInputStream(PAYLOAD);
213: repo.addFile(f1,is);
214: repo.addFolder(d1);
215: is = new ByteArrayInputStream(PAYLOAD);
216: repo.addFile(f1d1,is);
217: repo.addFolder(d1d1);
218: is = new ByteArrayInputStream(PAYLOAD);
219: repo.addFile(f1d1d1,is);
220:
221: // delete non-empty folder at folder
222: assertNotNull(repo.getItemInfo(d1d1));
223: repo.deleteFolder(d1d1,true);
224: assertNull(repo.getItemInfo(d1d1));
225:
226: // delete non-empty folder at root
227: assertNotNull(repo.getItemInfo(d1));
228: repo.deleteFolder(d1,true);
229: assertNull(repo.getItemInfo(d1));
230:
231: // copy file from root to folder
232:
233: cleanRepo();
234:
235: //// adding files & folders for next test
236: is = new ByteArrayInputStream(PAYLOAD);
237: repo.addFile(f1,is);
238: repo.addFolder(d2);
239:
240: item1 = new RepoItem(d2,f1.getName(),"owner");
241: assertNull(repo.getItemInfo(item1));
242: repo.copy(f1,d2);
243: assertNotNull(repo.getItemInfo(item1));
244:
245: // copy file from folder to root
246:
247: cleanRepo();
248:
249: //// adding files & folders for next test
250: is = new ByteArrayInputStream(PAYLOAD);
251: repo.addFolder(d1);
252: repo.addFile(f1d1,is);
253:
254: item1 = new RepoItem(RepoItem.ROOT,f1d1.getName(),"owner");
255: assertNull(repo.getItemInfo(item1));
256: repo.copy(f1d1,RepoItem.ROOT);
257: assertNotNull(repo.getItemInfo(item1));
258:
259: // copy folder from root to folder
260:
261: cleanRepo();
262:
263: //// adding files & folders for next test
264: is = new ByteArrayInputStream(PAYLOAD);
265: repo.addFolder(d1);
266: repo.addFolder(d1d1);
267: repo.addFile(f1d1,is);
268: repo.addFolder(d2);
269:
270: item1 = new RepoItem(d2,d1.getName(),"owner");
271: assertNull(repo.getItemInfo(item1));
272: repo.copy(d1,d2);
273: assertNotNull(repo.getItemInfo(item1));
274:
275: set1 = getAllContent(d1);
276: set2 = getAllContent(item1);
277: assertEquals(repoItem2String(set1,d1.getParent()),
278: repoItem2String(set2,item1.getParent()));
279:
280: // copy folder from folder to root
281:
282: cleanRepo();
283:
284: //// adding files & folders for next test
285: is = new ByteArrayInputStream(PAYLOAD);
286: repo.addFolder(d1);
287: repo.addFolder(d1d1);
288: repo.addFile(f1d1d1,is);
289:
290: item1 = new RepoItem(RepoItem.ROOT,d1d1.getName(),"owner");
291: assertNull(repo.getItemInfo(item1));
292: repo.copy(d1d1,RepoItem.ROOT);
293: assertNotNull(repo.getItemInfo(item1));
294:
295: set1 = getAllContent(d1d1);
296: set2 = getAllContent(item1);
297: assertEquals(repoItem2String(set1,d1d1.getParent()),
298: repoItem2String(set2,item1.getParent()));
299:
300: */
301:
302: // move file from root to folder
303: cleanRepo();
304:
305: //// adding files & folders for next test
306: is = new ByteArrayInputStream(PAYLOAD);
307: repo.addFile(f1, is);
308: repo.addFolder(d2);
309:
310: item1 = new RepoItem(d2, f1.getName(), "owner");
311: assertNull(repo.getItemInfo(item1));
312: repo.move(f1, d2);
313: assertNotNull(repo.getItemInfo(item1));
314:
315: // move file from folder to root
316:
317: cleanRepo();
318:
319: //// adding files & folders for next test
320: is = new ByteArrayInputStream(PAYLOAD);
321: repo.addFolder(d1);
322: repo.addFile(f1d1, is);
323:
324: item1 = new RepoItem(RepoItem.ROOT, f1d1.getName(), "owner");
325: assertNull(repo.getItemInfo(item1));
326: repo.move(f1d1, RepoItem.ROOT);
327: assertNotNull(repo.getItemInfo(item1));
328:
329: // move folder from root to folder
330: cleanRepo();
331:
332: //// adding files & folders for next test
333: is = new ByteArrayInputStream(PAYLOAD);
334: repo.addFolder(d1);
335: repo.addFolder(d1d1);
336: repo.addFile(f1d1, is);
337: repo.addFolder(d2);
338:
339: set1 = getAllContent(d1);
340:
341: item1 = new RepoItem(d2, d1.getName(), "owner");
342: assertNull(repo.getItemInfo(item1));
343: repo.move(d1, d2);
344: assertNotNull(repo.getItemInfo(item1));
345:
346: set2 = getAllContent(item1);
347: assertEquals(repoItem2String(set1, d1.getParent()),
348: repoItem2String(set2, item1.getParent()));
349:
350: // move folder from folder to root
351: cleanRepo();
352:
353: //// adding files & folders for next test
354: is = new ByteArrayInputStream(PAYLOAD);
355: repo.addFolder(d1);
356: repo.addFolder(d1d1);
357: repo.addFile(f1d1, is);
358: repo.addFolder(d2);
359:
360: set1 = getAllContent(d1d1);
361:
362: item1 = new RepoItem(RepoItem.ROOT, d1d1.getName(), "owner");
363: assertNull(repo.getItemInfo(item1));
364: repo.move(d1d1, RepoItem.ROOT);
365: assertNotNull(repo.getItemInfo(item1));
366:
367: set2 = getAllContent(item1);
368: assertEquals(repoItem2String(set1, d1d1.getParent()),
369: repoItem2String(set2, item1.getParent()));
370:
371: // rename file in root
372: cleanRepo();
373:
374: //// adding files & folders for next test
375: is = new ByteArrayInputStream(PAYLOAD);
376: repo.addFile(f1, is);
377: repo.addFolder(d2);
378:
379: item1 = new RepoItem(f1.getParent(), "XXX", "owner");
380: assertNull(repo.getItemInfo(item1));
381: repo.rename(f1, item1.getName());
382: assertNotNull(repo.getItemInfo(item1));
383:
384: // rename file in folder
385: cleanRepo();
386:
387: //// adding files & folders for next test
388: is = new ByteArrayInputStream(PAYLOAD);
389: repo.addFolder(d1);
390: repo.addFile(f1d1, is);
391: repo.addFolder(d2);
392:
393: item1 = new RepoItem(f1d1.getParent(), "XXX", "owner");
394: assertNull(repo.getItemInfo(item1));
395: repo.rename(f1d1, item1.getName());
396: assertNotNull(repo.getItemInfo(item1));
397:
398: // rename folder in root
399: cleanRepo();
400:
401: //// adding files & folders for next test
402: is = new ByteArrayInputStream(PAYLOAD);
403: repo.addFolder(d1);
404: repo.addFile(f1d1, is);
405: repo.addFolder(d2);
406:
407: set1 = getAllContent(d1);
408:
409: item1 = new RepoItem(d1.getParent(), "XXX", "owner");
410: assertNull(repo.getItemInfo(item1));
411: repo.rename(d1, item1.getName());
412: assertNotNull(repo.getItemInfo(item1));
413:
414: set2 = getAllContent(item1);
415:
416: assertEquals(repoItem2String(set1, d1), repoItem2String(set2,
417: item1));
418:
419: // rename folder in folder
420: cleanRepo();
421:
422: //// adding files & folders for next test
423: is = new ByteArrayInputStream(PAYLOAD);
424: repo.addFolder(d1);
425: repo.addFolder(d1d1);
426: repo.addFile(f1d1d1, is);
427: repo.addFolder(d2);
428:
429: set1 = getAllContent(d1d1);
430:
431: item1 = new RepoItem(d1d1.getParent(), "XXX", "owner");
432: assertNull(repo.getItemInfo(item1));
433: repo.rename(d1d1, item1.getName());
434: assertNotNull(repo.getItemInfo(item1));
435:
436: set2 = getAllContent(item1);
437:
438: assertEquals(repoItem2String(set1, d1d1), repoItem2String(set2,
439: item1));
440:
441: }
442:
443: private Set array2Set(Object[] array) {
444: Set set = new HashSet();
445: for (int i = 0; array != null && i < array.length; i++) {
446: set.add(array[i]);
447: }
448: return set;
449: }
450:
451: private Set getAllContent(RepoItem folder) throws Exception {
452: Set s = new HashSet();
453: Repository repo = getRepository();
454: RepoItem[] content = repo.getContent(folder);
455: s.addAll(array2Set(content));
456: for (int i = 0; i < content.length; i++) {
457: if (content[i].isDirectory()) {
458: s.addAll(getAllContent(content[i]));
459: }
460: }
461: return s;
462: }
463:
464: private Set repoItem2String(Set repoItems, RepoItem repoItemToTrim) {
465: int trimPrefix = (repoItemToTrim.equals(RepoItem.ROOT)) ? 1
466: : repoItemToTrim.getPath().length() + 1;
467: Set s = new HashSet();
468: Iterator i = repoItems.iterator();
469: while (i.hasNext()) {
470: RepoItem item = (RepoItem) i.next();
471: s.add(item.getPath().substring(trimPrefix));
472: }
473: return s;
474: }
475:
476: private void cleanRepo() throws Exception {
477: SQLExecutor sqlExec = getSQLExecutor();
478: sqlExec.execute(new DeleteTableSQLTask());
479: }
480:
481: public void testAddFile() throws Exception {
482: Repository r = getRepository();
483:
484: InputStream is = new ByteArrayInputStream(PAYLOAD);
485: RepoItem rItem = new RepoItem(RepoItem.ROOT, "f0.txt", "owner",
486: PAYLOAD.length);
487: r.addFile(rItem, is);
488: }
489:
490: public void testGetFile() throws Exception {
491: Repository r = getRepository();
492:
493: InputStream is = new ByteArrayInputStream(PAYLOAD);
494: RepoItem rItem = new RepoItem(RepoItem.ROOT, "f1.txt", "owner",
495: PAYLOAD.length);
496: r.addFile(rItem, is);
497:
498: is = r.getFile(rItem);
499: assertNotNull(r.getFile(rItem));
500:
501: ByteArrayOutputStream baos = new ByteArrayOutputStream();
502: IOUtils.copyStream(is, baos);
503: baos.close();
504: byte[] readData = baos.toByteArray();
505: if (readData.length != PAYLOAD.length) {
506: assertTrue("different size", false);
507: }
508: for (int i = 0; i < readData.length; i++) {
509: assertEquals(readData[i], PAYLOAD[i]);
510: }
511:
512: }
513:
514: public void testDeleteFile() throws Exception {
515: Repository r = getRepository();
516:
517: InputStream is = new ByteArrayInputStream(PAYLOAD);
518: RepoItem rItem = new RepoItem(RepoItem.ROOT, "f2.txt", "owner",
519: PAYLOAD.length);
520: r.addFile(rItem, is);
521: assertNotNull(r.getFile(rItem));
522:
523: r.deleteFile(rItem);
524: assertNull(r.getFile(rItem));
525: }
526:
527: public void testGetInfo() throws Exception {
528: Repository r = getRepository();
529:
530: InputStream is = new ByteArrayInputStream(PAYLOAD);
531: RepoItem rItem = new RepoItem(RepoItem.ROOT, "f3.txt", "owner",
532: PAYLOAD.length);
533: r.addFile(rItem, is);
534:
535: RepoItem readRItem = r.getItemInfo(rItem);
536: assertNotNull(readRItem);
537: assertEquals(rItem.getParent(), readRItem.getParent());
538: assertEquals(rItem.getName(), readRItem.getName());
539: assertEquals(rItem.getCreator(), readRItem.getCreator());
540: assertFalse(readRItem.isDirectory());
541: assertFalse(readRItem.getCreated() == 0L);
542: assertFalse(readRItem.getLastModified() == 0L);
543: assertEquals(readRItem.getLength(), PAYLOAD.length);
544:
545: }
546:
547: public void testAddFolder() throws Exception {
548: Repository repo = getRepository();
549: RepoItem folder = new RepoItem(RepoItem.ROOT, "f0", "owner");
550: repo.addFolder(folder);
551: RepoItem readRItem = repo.getItemInfo(folder);
552: assertNotNull(readRItem);
553: assertEquals(folder.getParent(), readRItem.getParent());
554: assertEquals(folder.getName(), readRItem.getName());
555: assertEquals(folder.getCreator(), readRItem.getCreator());
556: assertTrue(readRItem.isDirectory());
557: assertFalse(readRItem.getCreated() == 0L);
558: assertFalse(readRItem.getLastModified() == 0L);
559: assertEquals(readRItem.getLength(), 0);
560: }
561:
562: public void testGetContent() throws Exception {
563: Repository repo = getRepository();
564: RepoItem i1 = new RepoItem(RepoItem.ROOT, "f1", "owner");
565: repo.addFolder(i1);
566: RepoItem i2 = new RepoItem(i1, "f2", "owner");
567: repo.addFolder(i2);
568: RepoItem i3 = new RepoItem(i1, "f3", "owner");
569: repo.addFolder(i3);
570: InputStream is = new ByteArrayInputStream(PAYLOAD);
571: RepoItem i4 = new RepoItem(RepoItem.ROOT, "f.txt", "owner",
572: PAYLOAD.length);
573: repo.addFile(i4, is);
574:
575: is = new ByteArrayInputStream(PAYLOAD);
576: RepoItem i5a = new RepoItem(i2, "a.txt", "owner",
577: PAYLOAD.length);
578: repo.addFile(i5a, is);
579: is = new ByteArrayInputStream(PAYLOAD);
580: RepoItem i5aa = new RepoItem(i2, "aa.txt", "owner",
581: PAYLOAD.length);
582: repo.addFile(i5aa, is);
583: is = new ByteArrayInputStream(PAYLOAD);
584: RepoItem i5ab = new RepoItem(i2, "ab.txt", "owner",
585: PAYLOAD.length);
586: repo.addFile(i5ab, is);
587:
588: Set root = new HashSet();
589: root.add(i1);
590: root.add(i4);
591: Set f1 = new HashSet();
592: f1.add(i2);
593: f1.add(i3);
594:
595: RepoItem[] content = repo.getContent(RepoItem.ROOT);
596: Set result = new HashSet();
597: for (int i = 0; i < content.length; i++) {
598: result.add(content[i]);
599: }
600: assertEquals(root, result);
601:
602: content = repo.getContent(i1);
603: result = new HashSet();
604: for (int i = 0; i < content.length; i++) {
605: result.add(content[i]);
606: }
607: assertEquals(f1, result);
608:
609: try {
610: content = repo.getContent(new RepoItem(RepoItem.ROOT,
611: "caca", "owner"));
612: } catch (RepoException ex) {
613: assertEquals(ex.getId(), "J060");
614: }
615:
616: Set s1;
617: Set s2;
618:
619: content = repo.getContent(i2, "*");
620: s1 = new HashSet();
621: s1.add(i5a);
622: s1.add(i5aa);
623: s1.add(i5ab);
624: s2 = new HashSet();
625: for (int i = 0; i < content.length; i++) {
626: s2.add(content[i]);
627: }
628: assertEquals(s1, s2);
629:
630: content = repo.getContent(i2, "a*.txt");
631: s1 = new HashSet();
632: s1.add(i5a);
633: s1.add(i5aa);
634: s1.add(i5ab);
635: s2 = new HashSet();
636: for (int i = 0; i < content.length; i++) {
637: s2.add(content[i]);
638: }
639: assertEquals(s1, s2);
640:
641: content = repo.getContent(i2, "a?.txt");
642: s1 = new HashSet();
643: s1.add(i5aa);
644: s1.add(i5ab);
645: s2 = new HashSet();
646: for (int i = 0; i < content.length; i++) {
647: s2.add(content[i]);
648: }
649: assertEquals(s1, s2);
650:
651: content = repo.getContent(i2, "?b.txt");
652: s1 = new HashSet();
653: s1.add(i5ab);
654: s2 = new HashSet();
655: for (int i = 0; i < content.length; i++) {
656: s2.add(content[i]);
657: }
658: assertEquals(s1, s2);
659:
660: }
661:
662: public void testDeleteFolder() throws Exception {
663: Repository repo = getRepository();
664: RepoItem f1 = new RepoItem(RepoItem.ROOT, "f1", "owner");
665: repo.addFolder(f1);
666: RepoItem f2 = new RepoItem(f1, "f2", "owner");
667: repo.addFolder(f2);
668: RepoItem f3 = new RepoItem(f1, "f3", "owner");
669: repo.addFolder(f3);
670: RepoItem f4 = new RepoItem(f3, "f4", "owner");
671: repo.addFolder(f4);
672:
673: assertNotNull(repo.getItemInfo(f2));
674: repo.deleteFolder(f2, false);
675: assertNull(repo.getItemInfo(f2));
676:
677: f2 = new RepoItem(f1, "f2", "owner");
678: repo.addFolder(f2);
679:
680: assertNotNull(repo.getItemInfo(f2));
681: repo.deleteFolder(f2, true);
682: assertNull(repo.getItemInfo(f2));
683:
684: assertNotNull(repo.getItemInfo(f3));
685: try {
686: repo.deleteFolder(f3, false);
687: assertTrue(false);
688: } catch (RepoException ex) {
689: }
690: assertNotNull(repo.getItemInfo(f3));
691:
692: assertNotNull(repo.getItemInfo(f3));
693: repo.deleteFolder(f3, true);
694: assertNull(repo.getItemInfo(f3));
695:
696: }
697:
698: public void testCopy() throws Exception {
699: Repository repo = getRepository();
700: RepoItem f1 = new RepoItem(RepoItem.ROOT, "f1", "owner");
701: repo.addFolder(f1);
702: RepoItem f2 = new RepoItem(RepoItem.ROOT, "f2", "owner");
703:
704: RepoItem f3 = new RepoItem(RepoItem.ROOT, "f3", "owner");
705: repo.addFolder(f3);
706: RepoItem a1 = new RepoItem(f1, "a1", "owner");
707: repo.addFolder(a1);
708: RepoItem a2 = new RepoItem(f1, "a2", "owner");
709: repo.addFolder(a2);
710: RepoItem a3 = new RepoItem(f1, "a3", "owner");
711: repo.addFolder(a3);
712: InputStream is = new ByteArrayInputStream(PAYLOAD);
713: RepoItem b1 = new RepoItem(RepoItem.ROOT, "b1.txt", "owner",
714: PAYLOAD.length);
715: repo.addFile(b1, is);
716: is = new ByteArrayInputStream(PAYLOAD);
717: RepoItem b2 = new RepoItem(f1, "b2.txt", "owner",
718: PAYLOAD.length);
719: repo.addFile(b2, is);
720: is = new ByteArrayInputStream(PAYLOAD);
721: RepoItem b4 = new RepoItem(RepoItem.ROOT, "a3.txt", "owner",
722: PAYLOAD.length);
723: repo.addFile(b4, is);
724:
725: RepoItem b3 = new RepoItem(RepoItem.ROOT, "b3.txt", "owner");
726:
727: try {
728: repo.copy(b3, f1);
729: assertTrue(false);
730: } catch (RepoException ex) {
731: }
732:
733: try {
734: repo.copy(f1, b2);
735: assertTrue(false);
736: } catch (RepoException ex) {
737: }
738:
739: try {
740: repo.copy(b4, f1);
741: assertTrue(false);
742: } catch (RepoException ex) {
743: }
744:
745: RepoItem r;
746:
747: r = new RepoItem(f1, b1.getName(), "owner");
748: assertNull(repo.getItemInfo(r));
749: repo.copy(b1, r);
750: assertNotNull(repo.getItemInfo(r));
751:
752: assertNull(repo.getItemInfo(f2));
753: repo.copy(f1, f2);
754: assertNotNull(repo.getItemInfo(f2));
755:
756: RepoItem[] f1Contents = repo.getContent(f1);
757: RepoItem[] f2Contents = repo.getContent(new RepoItem(f2, f1
758: .getName(), "c"));
759: assertEquals(f1Contents.length, f2Contents.length);
760: Set names1 = new HashSet();
761: Set names2 = new HashSet();
762: for (int i = 0; i < f1Contents.length; i++) {
763: names1.add(f1Contents[i].getName());
764: names2.add(f2Contents[i].getName());
765: }
766: assertEquals(names1, names2);
767:
768: }
769:
770: private void flattenDir(Repository repo, RepoItem f1, String depth,
771: Set set) throws RepoException {
772: RepoItem[] files = repo.getContent(f1);
773: for (int i = 0; i < files.length; i++) {
774: set.add(depth + "/" + files[i].getName());
775: if (files[i].isDirectory()) {
776: flattenDir(repo, files[i], depth + "/"
777: + files[i].getName(), set);
778: }
779: }
780: }
781:
782: public void testMove() throws Exception {
783: Repository repo = getRepository();
784: RepoItem f1 = new RepoItem(RepoItem.ROOT, "f1", "owner");
785: repo.addFolder(f1);
786: RepoItem f2 = new RepoItem(RepoItem.ROOT, "f2", "owner");
787: repo.addFolder(f2);
788: RepoItem f3 = new RepoItem(RepoItem.ROOT, "f3", "owner");
789: repo.addFolder(f3);
790: RepoItem a1 = new RepoItem(f1, "a1", "owner");
791: repo.addFolder(a1);
792: RepoItem a2 = new RepoItem(f1, "a2", "owner");
793: repo.addFolder(a2);
794: RepoItem a3 = new RepoItem(f1, "a3", "owner");
795: repo.addFolder(a3);
796: InputStream is = new ByteArrayInputStream(PAYLOAD);
797: RepoItem b1 = new RepoItem(RepoItem.ROOT, "b1.txt", "owner",
798: PAYLOAD.length);
799: repo.replaceFile(b1, is);
800: is = new ByteArrayInputStream(PAYLOAD);
801: RepoItem b2 = new RepoItem(f1, "b2.txt", "owner",
802: PAYLOAD.length);
803: repo.replaceFile(b2, is);
804: is = new ByteArrayInputStream(PAYLOAD);
805: RepoItem b4 = new RepoItem(RepoItem.ROOT, "b4.txt", "owner",
806: PAYLOAD.length);
807: repo.replaceFile(b4, is);
808:
809: RepoItem r = new RepoItem(f2, b1.getName(), "owner");
810: assertNull(repo.getItemInfo(r));
811: repo.move(b1, r);
812: assertNotNull(repo.getItemInfo(r));
813:
814: r = new RepoItem(f2, f1.getName(), "owner");
815: assertNull(repo.getItemInfo(r));
816: repo.move(f1, r);
817: assertNotNull(repo.getItemInfo(r));
818: }
819:
820: public void testRename() throws Exception {
821: Repository repo = getRepository();
822: RepoItem f1 = new RepoItem(RepoItem.ROOT, "f1", "owner");
823: repo.addFolder(f1);
824: RepoItem a1 = new RepoItem(f1, "a1", "owner");
825: repo.addFolder(a1);
826: InputStream is = new ByteArrayInputStream(PAYLOAD);
827: RepoItem b1 = new RepoItem(RepoItem.ROOT, "b1.txt", "owner");
828: repo.addFile(b1, is);
829:
830: RepoItem r = new RepoItem(b1.getParent(), "xxx", "owner");
831: assertNull(repo.getItemInfo(r));
832: repo.rename(b1, "xxx");
833: assertNotNull(repo.getItemInfo(r));
834:
835: r = new RepoItem(f1.getParent(), "yyy", "owner");
836: assertNull(repo.getItemInfo(r));
837: repo.rename(f1, "yyy");
838: assertNotNull(repo.getItemInfo(r));
839: }
840:
841: }
|