View Javadoc
1   package org.melati.poem.test;
2   
3   import java.sql.ResultSet;
4   import java.sql.SQLException;
5   import java.util.Enumeration;
6   
7   import org.melati.poem.*;
8   import org.melati.poem.User;
9   import org.melati.poem.UserTable;
10  import org.melati.poem.dbms.Dbms;
11  
12  /**
13   * Test the features of all Poem databases.
14   * 
15   * @author timp
16   */
17  public class PoemDatabaseTest extends PoemTestCase {
18  
19    public PoemDatabaseTest(String arg0) {
20      super(arg0);
21    }
22  
23    protected void setUp() throws Exception {
24      super.setUp();
25    }
26  
27    protected void tearDown() throws Exception {
28      super.tearDown();
29      getDb().setLogCommits(false);
30      getDb().setLogSQL(false);
31    }
32  
33    /**
34     * @see org.melati.poem.generated.PoemDatabaseBase#getUserTable()
35     * @see org.melati.poem.Database#getTable(String)
36     */
37    public void testGetUserTable() {
38      UserTable<User> ut1 = getDb().getUserTable();
39      @SuppressWarnings("unchecked")
40      UserTable<User> ut2 = (UserTable<User>)getDb().getTable("user");
41      assertEquals(ut1, ut2);
42    }
43  
44    /**
45     * @see org.melati.poem.Database#transactionsMax()
46     */
47    public void testTransactionsMax() {
48      assertEquals(maxTrans, getDb().transactionsMax());
49    }
50  
51    /**
52     * @see org.melati.poem.Database#getDisplayTables()
53     */
54    public void testGetDisplayTables() {
55      final String expected = "user (from the data structure definition)"
56              + "group (from the data structure definition)"
57              + "capability (from the data structure definition)"
58              + "groupMembership (from the data structure definition)"
59              + "groupCapability (from the data structure definition)"
60              + "tableInfo (from the data structure definition)"
61              + "columnInfo (from the data structure definition)"
62              + "tableCategory (from the data structure definition)"
63              + "setting (from the data structure definition)";
64  
65      String outcome = "";
66      for (Table<?> t : getDb().getDisplayTables()) { 
67        outcome += t.toString();      
68      }
69      if (getDb().getDbms().canDropColumns()) {
70        assertEquals(expected, outcome);
71      }
72    }
73  
74    /**
75     * @see org.melati.poem.Database#sqlQuery(String)
76     */
77    public void testSqlQuery() {
78      String query = "select * from " + getDb().getUserTable().quotedName();
79      getDb().setLogSQL(true);
80      ResultSet rs = getDb().sqlQuery(query);
81      getDb().setLogSQL(false);
82      int count = 0;
83      try {
84        while (rs.next()) {
85          count++;
86        }
87      } catch (SQLException e) {
88        e.printStackTrace();
89        fail();
90      }
91      assertEquals(2, count);
92    }
93    /**
94     * @see org.melati.poem.Database#sqlQuery(String)
95     */
96    public void testSqlQueryThrows() {
97      String query = "select * from nonexistanttable" ;
98      try { 
99        getDb().sqlQuery(query);
100       fail("Should have blown up");
101     } catch (ExecutingSQLPoemException e) { 
102       e = null;
103     }
104   }
105 
106   /**
107    * @see org.melati.poem.Database#hasCapability(User, Capability)
108    */
109   public void testHasCapability() {
110     assertTrue(getDb().hasCapability(
111             getDb().getUserTable().administratorUser(),
112             getDb().getCanAdminister()));
113     assertTrue(getDb().hasCapability(getDb().getUserTable().guestUser(), null));
114 
115     getDb().setCanAdminister();
116     // This is only true for a db that that never had its administration set
117     assertFalse(getDb().hasCapability(getDb().getUserTable().guestUser(),
118             getDb().getCanAdminister()));
119     User u = (User)getDb().getUserTable().newPersistent();
120     u.setName("test");
121     u.setLogin("test");
122     u.setPassword("test");
123     u.makePersistent();
124     assertFalse(getDb().hasCapability(u, getDb().getCanAdminister()));
125     u.delete();
126   }
127 
128   /**
129    * @see org.melati.poem.Database#administerCapability()
130    */
131   public void testAdministerCapability() {
132   }
133 
134   /**
135    * @see org.melati.poem.Database#getCanAdminister()
136    */
137   public void testGetCanAdminister() {
138     // starts as null, but once set cannot be set to null again
139     //assertNull(getDb().getCanAdminister());
140   }
141 
142   /**
143    * @see org.melati.poem.UserTable#guestUser()
144    */
145   public final void testGuestUser() {
146     User u = getDb().getUserTable().guestUser();
147     assertEquals(u.getLogin(), "_guest_");
148   }
149 
150   /**
151    * @see org.melati.poem.UserTable#administratorUser()
152    */
153   public final void testAdministratorUser() {
154     User u = getDb().getUserTable().administratorUser();
155     assertEquals(u.getPassword(), "FIXME");
156   }
157 
158   /**
159    * @see org.melati.poem.Database#referencesTo(Table)
160    */
161   public void testReferencesToTable() {
162     String expected = "groupMembership.user: reference to user "
163             + "(INT (org.melati.poem.ReferencePoemType)) "
164             + "(from the data structure definition)";
165     String outcome = "";
166     Enumeration<Column<?>> en = getDb().referencesTo(getDb().getUserTable());
167     while (en.hasMoreElements())
168       outcome += en.nextElement();
169     assertEquals(expected, outcome);
170   }
171 
172   /**
173    * @see org.melati.poem.Database#getDbms()
174    */
175   public void testGetDbms() {
176     Dbms dbms = getDb().getDbms();
177     System.err.println(dbms);
178   }
179 
180   /**
181    * @see org.melati.poem.Database#toString()
182    */
183   public void testToString() {
184     String name = getDb().toString();
185     assertTrue(name.endsWith(getDatabaseName()));
186   }
187 
188   /**
189    * @see org.melati.poem.Database#logSQL()
190    */
191   public void testLogSQL() {
192     assertFalse(getDb().logSQL());
193   }
194 
195   /**
196    * @see org.melati.poem.Database#setLogSQL(boolean)
197    */
198   public void testSetLogSQL() {
199     assertFalse(getDb().logSQL());
200     getDb().setLogSQL(true);
201     assertTrue(getDb().logSQL());
202     getDb().setLogSQL(false);
203     assertFalse(getDb().logSQL());
204   }
205 
206   /**
207    * @see org.melati.poem.test.DatabaseTest#testConnect()
208    */
209   public void testConnect() {
210 
211   }
212 
213   /**
214    * @see org.melati.poem.Database#disconnect()
215    */
216   public void testDisconnect() {
217     // getDb().disconnect();
218   }
219 
220   /**
221    * @see Database#disconnect()
222    */
223   public void testShutdown() {
224     // getDb().shutdown();
225   }
226 
227   /**
228    * Note this is here so that we have the expected number of tables.
229    * 
230    * @see org.melati.poem.Database#tables()
231    */
232   public void testTables() {
233     // tested in PoemTestCase
234   }
235 
236   /**
237    * Note this is here so that we have the expected number of columns.
238    * 
239    * @see org.melati.poem.Database#columns()
240    */
241   public void testColumns() {
242     // tested in PoemTestCase
243   }
244 
245   /**
246    * @see DynamicTableTest
247    * @see org.melati.poem.Database#addTableAndCommit(TableInfo, String)
248    */
249 
250   /**
251    * @see org.melati.poem.Database#addConstraints()
252    * @see org.melati.poem.test.DatabaseTest#testAddConstraints()
253    */
254   public void testAddConstraints() {
255   }
256 
257   /**
258    * @see org.melati.poem.Database#setTransactionsMax(int)
259    */
260   public void testSetTransactionsMax() {
261     int current = 0;
262     current = getDb().transactionsMax();
263     assertEquals(maxTrans, current);
264     getDb().setTransactionsMax(12);
265     assertTrue(getDb().transactionsMax() == 12);
266     getDb().setTransactionsMax(current);
267   }
268 
269   /**
270    * @see org.melati.poem.Database#getTransactionsCount()
271    */
272   public void testGetTransactionsCount() {
273     assertEquals(maxTrans, getDb().getTransactionsCount());
274   }
275 
276   /**
277    * @see org.melati.poem.Database#getFreeTransactionsCount()
278    */
279   public void testGetFreeTransactionsCount() {
280     assertEquals(maxTrans -1, getDb().getFreeTransactionsCount());
281   }
282 
283   /**
284    * @see org.melati.poem.Database#poemTransaction(int)
285    */
286   public void testPoemTransaction() {
287     assertEquals(getDatabaseName() +"/transaction0", getDb().poemTransaction(0).toString());
288   }
289 
290   /**
291    * @see org.melati.poem.Database#transaction(int)
292    */
293   public void testTransaction() {
294     assertEquals(getDatabaseName() +"/transaction0", getDb().transaction(0).toString());
295   }
296 
297   /**
298    * @see org.melati.poem.Database#isFree(PoemTransaction)
299    */
300   public void testIsFree() {
301     for (int i = 0; i < maxTrans-1; i++)
302       assertTrue(getDb().isFree(getDb().poemTransaction(i)));
303     assertFalse(getDb().isFree(getDb().poemTransaction(maxTrans-1)));
304     
305     try {
306       System.err.println(getDb().isFree(getDb().poemTransaction(maxTrans)));
307       fail("Should have bombed.");
308     } catch (ArrayIndexOutOfBoundsException e) {
309       e = null;
310     }
311   }
312 
313   /**
314    * @see org.melati.poem.Database#beginExclusiveLock()
315    */
316   public void testBeginExclusiveLock() {
317 
318   }
319 
320   /**
321    * @see org.melati.poem.Database#endExclusiveLock()
322    */
323   public void testEndExclusiveLock() {
324 
325   }
326 
327   /**
328    * @see org.melati.poem.Database#inSession(AccessToken, PoemTask)
329    */
330   public void testInSession() {
331 
332   }
333 
334   /**
335    * @see org.melati.poem.Database#beginSession(AccessToken)
336    */
337   public void testBeginSession() {
338 
339   }
340 
341   /**
342    * @see org.melati.poem.Database#endSession()
343    */
344   public void testEndSession() {
345 
346   }
347 
348   /**
349    * @see org.melati.poem.Database#getTable(String)
350    */
351   public void testGetTable() {
352     assertEquals(getDb().getUserTable(), getDb().getTable("user"));
353   }
354 
355   /**
356    * @see org.melati.poem.Database#getTableInfoTable()
357    */
358   public void testGetTableInfoTable() {
359     assertEquals(getDb().getTableInfoTable(), getDb().getTable("tableinfo"));
360   }
361 
362   /**
363    * @see org.melati.poem.Database#getTableCategoryTable()
364    */
365   public void testGetTableCategoryTable() {
366     assertEquals(getDb().getTableCategoryTable(), getDb().getTable(
367             "tablecategory"));
368   }
369 
370   /**
371    * @see org.melati.poem.Database#getColumnInfoTable()
372    */
373   public void testGetColumnInfoTable() {
374     assertEquals(getDb().getColumnInfoTable(), getDb().getTable("columninfo"));
375   }
376 
377   /**
378    * @see org.melati.poem.Database#getCapabilityTable()
379    */
380   public void testGetCapabilityTable() {
381     assertEquals(getDb().getCapabilityTable(), getDb().getTable("capability"));
382   }
383 
384   /**
385    * @see org.melati.poem.Database#getGroupTable()
386    */
387   public void testGetGroupTable() {
388     assertEquals(getDb().getGroupTable(), getDb().getTable("group"));
389   }
390 
391   /**
392    * @see org.melati.poem.Database#getGroupMembershipTable()
393    */
394   public void testGetGroupMembershipTable() {
395     assertEquals(getDb().getGroupMembershipTable(), getDb().getTable(
396             "groupmembership"));
397   }
398 
399   /**
400    * @see org.melati.poem.Database#getGroupCapabilityTable()
401    */
402   public void testGetGroupCapabilityTable() {
403     assertEquals(getDb().getGroupCapabilityTable(), getDb().getTable(
404             "groupcapability"));
405   }
406 
407   /**
408    * @see org.melati.poem.Database#getSettingTable()
409    */
410   public void testGetSettingTable() {
411     assertEquals(getDb().getSettingTable(), getDb().getTable("setting"));
412   }
413 
414   /**
415    * Need to be in separate transactions on postgresql. 
416    * @see org.melati.poem.Database#sqlUpdate(String)
417    */
418   public void testSqlUpdate() {
419     try {
420       getDb().sqlUpdate("insert");
421       fail("should have blown up");
422     } catch (ExecutingSQLPoemException e) {
423       e = null;
424       // All ok
425     }
426   }
427   /**
428    * Need to be in separate transactions on postgresql. 
429    * @see org.melati.poem.Database#sqlUpdate(String)
430    */
431   public void testSqlUpdate1() {
432     try {
433       getDb()
434               .sqlUpdate(
435                       "INSERT INTO \"COLUMNINFO\" VALUES('Name','A human-readable name for the group',TRUE,-7,FALSE,60,20,1,22,2,NULL,NULL,NULL,15,1,'name',1,TRUE,0,0,0,FALSE,FALSE,TRUE,2)");
436       fail("should have blown up");
437     } catch (ExecutingSQLPoemException e) {
438       e = null;
439       // All ok
440     }
441   }
442   /**
443    * Need to be in separate transactions on postgresql. 
444    * @see org.melati.poem.Database#sqlUpdate(String)
445    */
446   public void testSqlUpdate2() {
447     getDb().setLogSQL(true);
448     getDb().sqlUpdate("CREATE TABLE RAWSQL (ID INT)");
449     getDb().sqlUpdate("DROP TABLE RAWSQL");
450     getDb().setLogSQL(false);
451   }
452 
453   /**
454    * @see org.melati.poem.Database#givesCapabilitySQL(User, Capability)
455    */
456   public void testGivesCapabilitySQL() {
457     assertTrue(getDb().givesCapabilitySQL((User)getDb().guestAccessToken(),
458             getDb().administerCapability()).indexOf("SELECT") == 0);
459   }
460 
461   /**
462    * @see org.melati.poem.Database#guestAccessToken()
463    */
464   public void testGuestAccessToken() {
465     AccessToken guest = getDb().guestAccessToken();
466     User guestUser = getDb().getUserTable().guestUser();
467     assertEquals(guest, guestUser);
468   }
469 
470   /**
471    * @see org.melati.poem.Database#setCanAdminister()
472    * @see org.melati.poem.Database#setCanAdminister(String)
473    */
474   public void testSetCanAdminister() {
475     // There is no way to set it back to null so do not check
476     //assertNull(getDb().getCanAdminister());
477     getDb().setCanAdminister();
478     assertEquals(getDb().getCapabilityTable().get("_administer_"), getDb()
479             .getCanAdminister());
480     getDb().setCanAdminister("testing");
481     assertEquals(getDb().getCapabilityTable().get("testing"), getDb()
482             .getCanAdminister());
483     getDb().setCanAdminister();
484     getDb().getCapabilityTable().getNameColumn().firstWhereEq("testing")
485             .delete();
486 
487   }
488 
489   /**
490    * @see org.melati.poem.Database#trimCache(int)
491    */
492   public void testTrimCache() {
493     getDb().trimCache(12);
494   }
495 
496   /**
497    * @see org.melati.poem.Database#uncache()
498    */
499   public void testUncacheContents() {
500     getDb().uncache();
501   }
502 
503   /**
504    * @see org.melati.poem.Database#referencesTo(Persistent)
505    */
506   public void testReferencesToPersistent() {
507     Enumeration<Persistent> en = getDb().referencesTo(
508         getDb().getUserTable().administratorUser());
509     int count = 0;
510     while (en.hasMoreElements()) {
511       en.nextElement();
512       count++;
513     }
514     System.err.println(count);
515     assertTrue(count == 1);
516 
517   }
518   /**
519    * Test method for {@link org.melati.poem.Database#getReferencesTo(org.melati.poem.Persistent)}.
520    */
521   public void testGetReferencesToPersistent() {
522    assertEquals(1, getDb().getReferencesTo(
523        getDb().getUserTable().administratorUser()).size());
524   }
525 
526   /**
527    * @see org.melati.poem.Database#dumpCacheAnalysis()
528    */
529   public void testDumpCacheAnalysis() {
530     getDb().dumpCacheAnalysis();
531   }
532 
533   /**
534    * @see org.melati.poem.Database#dump()
535    */
536   public void testDump() {
537     getDb().dump();
538   }
539 
540   /**
541    * @see org.melati.poem.Database#quotedName(String)
542    */
543   public void testQuotedName() {
544     assertEquals(getDb().getDbms().getQuotedName("user"), getDb().quotedName("user"));
545   }
546 
547   /**
548    * @see org.melati.poem.Database#getCommittedConnection()
549    */
550   public void testGetCommittedConnection() {
551 
552   }
553 
554   /**
555    * @see org.melati.poem.Database#logCommits()
556    */
557   public void testLogCommits() {
558     assertFalse(getDb().logCommits());
559   }
560 
561   /**
562    * @see org.melati.poem.Database#setLogCommits(boolean)
563    */
564   public void testSetLogCommits() {
565     assertFalse(getDb().logCommits());
566     getDb().setLogCommits(true);
567     assertTrue(getDb().logCommits());
568     getDb().setLogCommits(false);
569     assertFalse(getDb().logCommits());
570 
571   }
572 
573 }