Source code: org/acs/damsel/srvr/db/TestDBUtils.java
1 package org.acs.damsel.srvr.db;
2
3 import java.sql.*;
4 import java.util.*;
5
6 import org.acs.damsel.srvr.asset.*;
7 import org.acs.damsel.srvr.collection.*;
8 import org.acs.damsel.srvr.collection.Collection;
9 import org.acs.damsel.srvr.schema.*;
10 import org.acs.damsel.srvr.search.*;
11 import org.acs.damsel.srvr.user.*;
12 import org.apache.log4j.*;
13 import junit.framework.*;
14 import org.acs.damsel.srvr.group.*;
15
16 /*
17 * <p>Title: Digital Assets Management System for Electronic Library</p>
18 * <p>Description: Test cases for the DBUtils class</p>
19 * <p>Copyright: Copyright (c) 2003</p>
20 * @version 1.0
21 */
22 public class TestDBUtils extends TestCase {
23 private DBUtils dBUtils = null;
24 private static Logger log = Logger.getLogger(AssetDB.class);
25
26 public TestDBUtils(String name) {
27 super(name);
28 }
29
30 protected void setUp() throws Exception {
31 super.setUp();
32 dBUtils = DBUtils.instance();
33 }
34
35 /* Test simpleSearch method */
36 public void testSimpleSearch() {
37 try {
38 AssetDB assetDB = AssetDB.instance();
39 Asset a = new Asset();
40 AssetDescriptor fileNameAD = new AssetDescriptor();
41 AssetDescriptor titleAD = new AssetDescriptor();
42 AssetDescriptor descriptionAD = new AssetDescriptor();
43 fileNameAD.setTag("FileName");
44 fileNameAD.setValue("foo1.jpg");
45 titleAD.setTag("Title");
46 titleAD.setValue("Fubar");
47 AssetDescriptorCollection adc = new AssetDescriptorCollection();
48 adc.addAssetDescriptor(fileNameAD);
49 adc.addAssetDescriptor(titleAD);
50 a.setAssetDescriptors(adc);
51 Collection c = new Collection();
52 c.setCollectionName("FooColl");
53 c.setDescription("This is the Foo collection");
54 c.setGroupName("Editor");
55 c.setOwnerName("MForrester");
56 c.setPermissionID("127");
57 c.setRepositoryName("MichellesRepository");
58 c.setSchemaName("Default");
59 assetDB.addCollection(c);
60 assetDB.addAsset(a, c.getCollectionName());
61
62 String keyword = "Fubar";
63 CollectionView results = null;
64
65 results = dBUtils.simpleSearch(keyword, "Title", "FooColl");
66 this.assertNotNull(results);
67 this.assertEquals(1, results.size());
68 this.assertTrue(results.contains(a));
69 for (Iterator i = results.iterator(); i.hasNext(); ) {
70 log.info(i.next());
71 }
72 assetDB.deleteCollection(c);
73 assetDB.deleteAsset(a);
74 assetDB.removeAssetFromAllCollections(a);
75 }
76 catch (SQLException ex) {
77 this.fail("Caught unexpected SQLException during testSimpleSearch");
78 ex.printStackTrace();
79 }
80 catch (SchemaException ex2) {
81 this.fail("Unexpected SchemaException caught in testContains : " + ex2.getMessage());
82 }
83 }
84
85 public void testAdvancedSearch() {
86 try {
87 AssetDB assetDB = AssetDB.instance();
88 Asset a = new Asset();
89 AssetDescriptor fileNameAD = new AssetDescriptor();
90 AssetDescriptor titleAD = new AssetDescriptor();
91 fileNameAD.setTag("FileName");
92 fileNameAD.setValue("testAS.jpg");
93 titleAD.setTag("Title");
94 titleAD.setValue("Test Advanced Search");
95 AssetDescriptorCollection adc = new AssetDescriptorCollection();
96 adc.addAssetDescriptor(fileNameAD);
97 adc.addAssetDescriptor(titleAD);
98 a.setAssetDescriptors(adc);
99 Collection c = new Collection();
100 c.setCollectionName("TestASColl");
101 assetDB.addCollection(c);
102 assetDB.addAsset(a, c.getCollectionName());
103
104 CollectionView results = null;
105 AdvancedSearchParams params = new AdvancedSearchParams();
106 SearchPair sp = new SearchPair();
107 sp.setField("Title");
108 sp.setValue("Test Advanced Search");
109 params.addExactSearchPair(sp);
110 params.setCollectionName("TestASColl");
111
112 results = dBUtils.advancedSearch(params);
113 this.assertNotNull(results);
114 this.assertEquals(1, results.size());
115 this.assertTrue(results.contains(a));
116
117 AssetDB.instance().deleteCollection(c);
118 AssetDB.instance().deleteAsset(a);
119 AssetDB.instance().removeAssetFromAllCollections(a);
120 }
121 catch (SQLException ex) {
122 this.fail("Caught unexpected SQLException during testAdvancedSearch");
123 ex.printStackTrace();
124 }
125 catch (SchemaException ex2) {
126 this.fail("Unexpected SchemaException caught in testContains : " + ex2.getMessage());
127 }
128 }
129
130 public void testBrowseDB() {
131 try {
132 CollectionView myView;
133
134 Collection c = new Collection();
135 c.setCollectionName("newCollection");
136 c.setSchemaName("Default");
137 AssetDB.instance().addCollection(c);
138
139 Asset a = new Asset();
140 AssetDescriptor fileNameAD = new AssetDescriptor();
141 AssetDescriptor titleAD = new AssetDescriptor();
142 AssetDescriptor descriptionAD = new AssetDescriptor();
143 fileNameAD.setTag("FileName");
144 fileNameAD.setValue("browseDBAsset.jpg");
145 titleAD.setTag("Title");
146 titleAD.setValue("AssetBrowse");
147 AssetDescriptorCollection adc = new AssetDescriptorCollection();
148 adc.addAssetDescriptor(fileNameAD);
149 adc.addAssetDescriptor(titleAD);
150 a.setAssetDescriptors(adc);
151 AssetDB.instance().addAsset(a, "newCollection");
152
153 myView = dBUtils.browseDB("a", "Title", "newCollection");
154 this.assertEquals(1, myView.size());
155 this.assertTrue(myView.contains(a));
156 AssetDB.instance().deleteAsset(a);
157 AssetDB.instance().deleteCollection(c);
158 AssetDB.instance().removeAssetFromAllCollections(a);
159 }
160 catch (SQLException ex) {
161 log.error(ex.getSQLState());
162 }
163 catch (SchemaException ex2) {
164 this.fail("Unexpected SchemaException caught in testContains : " + ex2.getMessage());
165 }
166 }
167
168 /* Test canDoHighPerm method */
169 public void testCanDoHighPerm() {
170 try {
171 User user1 = new User();
172 User user2 = new User();
173 user1.setUserName("Michelle");
174 user1.setMiddleInitial("C");
175 user2.setUserName("Christy");
176 user2.setMiddleInitial("F");
177 String colName = new String();
178 colName = "CanEditCollections";
179 this.assertEquals(1, AssetDB.instance().addUser(user1));
180 this.assertEquals(1, AssetDB.instance().addUser(user2));
181 AssetDB.instance().addUserToGroup(user1.getUserName(), "Administrators");
182 AssetDB.instance().addUserToGroup(user2.getUserName(), "Users");
183 this.assertTrue(dBUtils.canDoHighPerm("Michelle", colName));
184 this.assertFalse(dBUtils.canDoHighPerm("Christy", colName));
185 AssetDB.instance().deleteUser(user1);
186 AssetDB.instance().deleteUser(user2);
187 }
188 catch (SQLException ex) {
189 this.fail("SQL exception");
190 }
191 }
192
193 /*Test canDoLowPerm method*/
194 public void testCanDoLowPerm() throws SQLException, SchemaException {
195 User user1 = new User();
196 User user2 = new User();
197 User user3 = new User();
198 User user4 = new User();
199 user1.setUserName("Michelle");
200 user1.setMiddleInitial("C");
201 user2.setUserName("Christy");
202 user2.setMiddleInitial("F");
203 user3.setUserName("Demandypants");
204 user3.setMiddleInitial("U");
205 user4.setUserName("bob");
206 user4.setMiddleInitial("b");
207 String userName1 = user1.getUserName();
208 String userName2 = user2.getUserName();
209 String userName3 = user3.getUserName();
210 String userName4 = user4.getUserName();
211 AssetDB.instance().addUser(user1);
212 AssetDB.instance().addUser(user2);
213 AssetDB.instance().addUser(user3);
214 AssetDB.instance().addUser(user4);
215 AssetDB.instance().addUserToGroup(user1.getUserName(), "Editor");
216 AssetDB.instance().addUserToGroup(user2.getUserName(), "Editor");
217 AssetDB.instance().addUserToGroup(user3.getUserName(), "User");
218 AssetDB.instance().addUserToGroup(user4.getUserName(), "Administrators");
219 Collection c = new Collection();
220 c.setCollectionName("permTester");
221 c.setOwnerName("Michelle");
222 c.setGroupName("Editor");
223 c.setPermissionID("95");
224 AssetDB.instance().addCollection(c);
225
226 this.assertTrue(dBUtils.canDoLowPerm(userName1, "Delete", "CollectionTable",
227 "CollectionName", "permTester"));
228 this.assertFalse(dBUtils.canDoLowPerm(userName2, "Delete",
229 "CollectionTable", "CollectionName",
230 "permTester"));
231 this.assertFalse(dBUtils.canDoLowPerm(userName3, "Delete",
232 "CollectionTable", "CollectionName",
233 "permTester"));
234 this.assertTrue(dBUtils.canDoLowPerm(userName4, "Delete", "CollectionTable",
235 "CollectionName", "permTester"));
236 AssetDB.instance().deleteCollection(c);
237 AssetDB.instance().deleteUser(user1);
238 AssetDB.instance().deleteUser(user2);
239 AssetDB.instance().deleteUser(user3);
240 AssetDB.instance().deleteUser(user4);
241 }
242
243 protected void tearDown() throws Exception {
244 dBUtils = null;
245 super.tearDown();
246 }
247
248 public void testEncode() {
249 Vector v = new Vector();
250 v.add("noquote");
251 v.add("'quote'");
252 v.add("\"double\"quote\"");
253 v.add("noquote2");
254
255 v = DBUtils.encode(v);
256
257 String s = (String) v.get(0);
258 this.assertEquals("noquote", s);
259 s = (String) v.get(1);
260 this.assertEquals("''quote''", s);
261 s = (String) v.get(2);
262 //@todo add test for encoded double quote
263 s = (String) v.get(3);
264 this.assertEquals("noquote2", s);
265 }
266
267 public void testDecode() {
268 Vector v = new Vector();
269 v.add("noquote");
270 v.add("'quote'");
271 v.add("\"double\"quote\"");
272 v.add("noquote2");
273
274 v = DBUtils.encode(v);
275 v = DBUtils.decode(v);
276
277 String s = (String) v.get(0);
278 this.assertEquals("noquote", s);
279 s = (String) v.get(1);
280 this.assertEquals("'quote'", s);
281 s = (String) v.get(2);
282 this.assertEquals("\"double\"quote\"", s);
283 s = (String) v.get(3);
284 this.assertEquals("noquote2", s);
285 }
286
287 public void testGetUsersCollections() {
288 try {
289 User user1 = new User();
290 User user2 = new User();
291 User user3 = new User();
292 user1.setUserName("testGUCAdmin");
293 user2.setUserName("testGUCEditor");
294 user3.setUserName("testGUCUser");
295 AssetDB assetDB = AssetDB.instance();
296 assetDB.addUserToGroup(user1.getUserName(), "Administrators");
297 assetDB.addUserToGroup(user2.getUserName(), "Editors");
298 assetDB.addUserToGroup(user3.getUserName(), "Users");
299 Collection coll1 = new Collection();
300 Collection coll2 = new Collection();
301 coll1.setCollectionName("testGUCColl1");
302 coll2.setCollectionName("testGUCColl2");
303 coll1.setGroupName("Editors");
304 coll1.setPermissionID("15");
305 coll2.setPermissionID("15");
306 assetDB.addCollection(coll1);
307 assetDB.addCollection(coll2);
308
309 //getting list of viewable collections for each user
310 Vector adminTest = DBUtils.instance().getUsersCollections(user1);
311 Vector editorTest = DBUtils.instance().getUsersCollections(user2);
312 Vector userTest = DBUtils.instance().getUsersCollections(user3);
313
314 //checking that admin can view both collections
315 this.assertTrue(adminTest.contains("testGUCColl1"));
316 this.assertTrue(adminTest.contains("testGUCColl2"));
317
318 //checking that editor can only view testGUCColl1
319 this.assertTrue(editorTest.contains("testGUCColl1"));
320 this.assertFalse(editorTest.contains("testGUCColl2"));
321
322 //checking that user cannot view either of the collections
323 this.assertFalse(userTest.contains("testGUCColl1"));
324 this.assertFalse(userTest.contains("testGUCColl2"));
325
326 assetDB.deleteUser(user1);
327 assetDB.deleteUser(user2);
328 assetDB.deleteUser(user3);
329 assetDB.deleteCollection(coll1);
330 assetDB.deleteCollection(coll2);
331 }
332 catch (SQLException ex) {
333 this.fail("Unexpect SQLException caught in testGetUsersCollections " +
334 ex.getMessage());
335 }
336 catch (SchemaException ex2) {
337 this.fail("Unexpected SchemaException caught in testContains : " + ex2.getMessage());
338 }
339 }
340
341 public void testGetPermissionsString() {
342 this.assertEquals(7, dBUtils.getPermissions("rwd------"));
343 this.assertEquals(511, dBUtils.getPermissions("rwdrwdrwd"));
344 this.assertEquals(0, dBUtils.getPermissions("---------"));
345 this.assertEquals( -1, dBUtils.getPermissions("rrrrrrrrrr"));
346 this.assertEquals( -1, dBUtils.getPermissions("rwdrwdrw"));
347 }
348
349 public void testGetPermissionID() {
350 this.assertEquals("rwd------", dBUtils.getPermissions(7));
351 this.assertEquals("rwdrwdrwd", dBUtils.getPermissions(511));
352 this.assertEquals("---------", dBUtils.getPermissions(0));
353 this.assertEquals(null, dBUtils.getPermissions(-1));
354 this.assertEquals(null, dBUtils.getPermissions(513));
355 }
356
357
358 public void testIsCollectionPrivate() {
359 try {
360 Collection coll = new Collection();
361 coll.setCollectionName("TestIsCollectionPrivateCollection");
362 coll.setPermissionID( Integer.toString(dBUtils.getPermissions("rwdrwd---")));
363 AssetDB.instance().addCollection(coll);
364 this.assertTrue(dBUtils.isCollectionPrivate(coll.getCollectionName()));
365 AssetDB.instance().deleteCollection(coll);
366 coll.setPermissionID( Integer.toString(dBUtils.getPermissions("rwdrwdrwd")));
367 AssetDB.instance().addCollection(coll);
368 this.assertFalse(dBUtils.isCollectionPrivate(coll.getCollectionName()));
369 AssetDB.instance().deleteCollection(coll);
370 }
371 catch (SQLException ex) {
372 this.fail("Unexpected SQLException caught in testIsCollectionPrivate: " + ex.getMessage());
373 }
374 catch (SchemaException ex2) {
375 this.fail("Unexpected SchemaException caught in testContains : " + ex2.getMessage());
376 }
377 }
378
379 public void testGetEditableCollections() {
380 User user = new User();
381 user.setUserName("editingUser");
382 Collection collection = new Collection();
383 Collection coll = new Collection();
384 coll.setCollectionName("NonEditableCollection");
385 collection.setCollectionName("EditableCollection");
386
387 try {
388 collection.setPermissionID(Integer.toString(dBUtils.getPermissions("rwdrwd---")));
389 collection.setGroupName("getEditableCollectionsGroup");
390 Group ug = new Group();
391 ug.setGroupName("getEditableCollectionsGroup");
392 ug.setCanEditCollections(true);
393 AssetDB adb = AssetDB.instance();
394 adb.addUser(user);
395 adb.addCollection(collection);
396 adb.addGroup(ug);
397 adb.addUserToGroup(user.getUserName(), ug.getGroupName());
398 Vector results = dBUtils.getEditableCollections(user);
399 this.assertNotNull(results);
400 this.assertTrue(results.contains("EditableCollection"));
401 this.assertFalse(results.contains("NonEditableCollection"));
402 adb.deleteUser(user);
403 adb.deleteCollection(collection);
404 adb.deleteGroup(ug.getGroupName());
405 }
406 catch (SQLException ex) {
407 this.fail("Caught unexpected SQLException in estGetEditableCollections" +
408 ex.getMessage());
409 ex.printStackTrace();
410 }
411 catch (SchemaException ex2) {
412 this.fail("Unexpected SchemaException caught in testContains : " + ex2.getMessage());
413 }
414 }
415
416 public void testGetEditableSchemas(){
417 try {
418 DBUtils db = DBUtils.instance();
419 AssetDB assetDB = AssetDB.instance();
420 User user1 = new User();
421 User user2 = new User();
422 User user3 = new User();
423 user1.setUserName("testGetEditableSchemasUser1");
424 user2.setUserName("testGetEditableSchemasUser2");
425 user3.setUserName("testGetEditableSchemasUser3");
426 assetDB.addUser(user1);
427 assetDB.addUser(user2);
428 assetDB.addUser(user3);
429 assetDB.addUserToGroup(user1.getUserName(), "Administrators");
430 assetDB.addUserToGroup(user2.getUserName(), "Editors");
431 assetDB.addUserToGroup(user3.getUserName(), "Users");
432
433 Schema s1 = new Schema();
434 Schema s2 = new Schema();
435 Schema s3 = new Schema();
436 s1.setName("testGetEditableSchemasSchema1");
437 s2.setName("testGetEditableSchemasSchema2");
438 s3.setName("testGetEditableSchemasSchema3");
439 s1.setOwnerName(user1.getUserName());
440 s2.setOwnerName(user2.getUserName());
441 s3.setOwnerName("testGetEditableSchemasNullUser");
442 s1.setGroupName("Administrators");
443 s2.setGroupName("Editors");
444 s3.setGroupName("Editors");
445 s1.setPermissionID("79");
446 s2.setPermissionID("79");
447 s3.setPermissionID("95");
448 assetDB.addSchema(s1);
449 assetDB.addSchema(s2);
450 assetDB.addSchema(s3);
451
452 Vector one = db.getEditableSchemas(user1);
453 Vector two = db.getEditableSchemas(user2);
454 Vector three = db.getEditableSchemas(user3);
455
456 this.assertTrue(one.contains(s1.getName()));
457 this.assertTrue(one.contains(s2.getName()));
458 this.assertTrue(one.contains(s3.getName()));
459
460 this.assertTrue(two.contains(s2.getName()));
461 this.assertTrue(two.contains(s3.getName()));
462 this.assertFalse(two.contains(s1.getName()));
463
464 this.assertFalse(three.contains(s1.getName()));
465 this.assertFalse(three.contains(s2.getName()));
466 this.assertFalse(three.contains(s3.getName()));
467
468 assetDB.deleteSchema(s1);
469 assetDB.deleteSchema(s2);
470 assetDB.deleteSchema(s3);
471 assetDB.deleteUser(user1);
472 assetDB.deleteUser(user2);
473 assetDB.deleteUser(user3);
474 }
475 catch (SQLException ex) {
476 this.fail("Caught unexpected SQLException in estGetEditableCollections" + ex.getMessage());
477 ex.printStackTrace();
478 }
479 }
480
481 /*
482 * Tests method to return a list of all permissions for groups in the Groups table
483 * NOTE: test is hard coded
484 */
485 public void testGetPermissionsList() {
486 try {
487 Vector permissions = dBUtils.getPermissionsList();
488 this.assertTrue(permissions.contains("CanEditAssets"));
489 this.assertFalse(permissions.contains("GroupName"));
490 }
491 catch (SQLException ex) {
492 this.fail("Unexpected SQLException caught in testGetPermissionsList: " + ex.getMessage());
493 }
494 }
495
496 /* Test method getUsersFavorites by adding assets to usersFavorites and then
497 getting them to make sure get works. */
498 public void testGetUsersFavorites() {
499 try {
500 AssetDB assetDB = AssetDB.instance();
501 // Create/populate a user
502 User user = new User();
503 User user2 = new User();
504 user.setUserName("testGetUsersFavoritesUser");
505 user2.setUserName("testGetUsersFavoritesUser2");
506
507 // Create/populate an asset and add to database
508 Asset asset1 = new Asset();
509 AssetDescriptor ad = new AssetDescriptor();
510 AssetDescriptorCollection adc = new AssetDescriptorCollection();
511
512 ad.setTag("FileName");
513 ad.setValue("testGetUsersFavorites.jpg");
514 adc.addAssetDescriptor(ad);
515 asset1.setAssetDescriptors(adc);
516 assetDB.addAsset(asset1, "AllAssets");
517 assetDB.addAssetToFavorites(asset1, user);
518
519 // Create/populate another asset and add to database
520 Asset asset2 = new Asset();
521 AssetDescriptor ad2 = new AssetDescriptor();
522 AssetDescriptorCollection adc2 = new AssetDescriptorCollection();
523
524 ad2.setTag("FileName");
525 ad2.setValue("testGetUsersFavorites2.jpg");
526 adc2.addAssetDescriptor(ad2);
527 asset2.setAssetDescriptors(adc2);
528 assetDB.addAsset(asset2, "AllAssets");
529 assetDB.addAssetToFavorites(asset2, user);
530
531 // Create/populate a third asset and add to another users favorites
532 Asset asset3 = new Asset();
533 AssetDescriptor ad3 = new AssetDescriptor();
534 AssetDescriptorCollection adc3 = new AssetDescriptorCollection();
535
536 ad3.setTag("FileName");
537 ad3.setValue("testGetUsersFavorites3.jpg");
538 adc3.addAssetDescriptor(ad3);
539 asset3.setAssetDescriptors(adc3);
540 assetDB.addAsset(asset3, "AllAssets");
541 assetDB.addAssetToFavorites(asset3, user2);
542
543 CollectionView userFavs = dBUtils.getUsersFavorites(user);
544 this.assertTrue(userFavs.contains(asset1));
545 this.assertTrue(userFavs.contains(asset2));
546 this.assertFalse(userFavs.contains(asset3));
547
548 assetDB.removeAssetFromFavorites(asset1, user);
549 assetDB.removeAssetFromFavorites(asset2, user);
550 assetDB.removeAssetFromFavorites(asset3, user2);
551 assetDB.deleteAsset(asset1);
552 assetDB.deleteAsset(asset2);
553 assetDB.deleteAsset(asset3);
554 assetDB.removeAssetFromAllCollections(asset1);
555 assetDB.removeAssetFromAllCollections(asset2);
556 assetDB.removeAssetFromAllCollections(asset3);
557 }
558 catch (SQLException ex) {
559 this.fail("Unexpected SQLException caught in testGetUsersFavorites() : " + ex.getMessage());
560 }
561 }
562
563
564 }