KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > opensubsystems > core > persist > db > DatabaseSchemaClassFactoryTest


1 /*
2  * Copyright (c) 2003 - 2007 OpenSubsystems s.r.o. Slovak Republic. All rights reserved.
3  *
4  * Project: OpenSubsystems
5  *
6  * $Id: DatabaseSchemaClassFactoryTest.java,v 1.11 2007/01/07 06:14:20 bastafidli Exp $
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; version 2 of the License.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  */
21
22 package org.opensubsystems.core.persist.db;
23
24 import java.util.Properties JavaDoc;
25
26 import junit.framework.TestCase;
27
28 import org.opensubsystems.core.error.OSSDynamicClassException;
29 import org.opensubsystems.core.persist.db.driver.DatabaseTestSchema;
30 import org.opensubsystems.core.persist.db.driver.db2.DB2DatabaseTestSchema;
31 import org.opensubsystems.core.persist.db.driver.hsqldb.HsqlDBDatabaseTestSchema;
32 import org.opensubsystems.core.persist.db.driver.maxdb.MaxDBDatabaseTestSchema;
33 import org.opensubsystems.core.persist.db.driver.mssql.MSSQLDatabaseTestSchema;
34 import org.opensubsystems.core.persist.db.driver.mysql.MySQLDatabaseTestSchema;
35 import org.opensubsystems.core.persist.db.driver.oracle.OracleDatabaseTestSchema;
36 import org.opensubsystems.core.persist.db.driver.postgresql.PostgreSQLDatabaseTestSchema;
37 import org.opensubsystems.core.persist.db.driver.sapdb.SapDBDatabaseTestSchema;
38 import org.opensubsystems.core.persist.db.driver.sybase.SybaseDatabaseTestSchema;
39 import org.opensubsystems.core.util.ClassFactory;
40 import org.opensubsystems.core.util.Config;
41
42 /**
43  * Tests for factory which can create database schema classes based on other
44  * classes based on name modification.
45  *
46  * @version $Id: DatabaseSchemaClassFactoryTest.java,v 1.11 2007/01/07 06:14:20 bastafidli Exp $
47  * @author Miro Halas
48  * @code.reviewer Miro Halas
49  * @code.reviewed Initial revision
50  */
51 public class DatabaseSchemaClassFactoryTest extends TestCase
52 {
53    // Tests ////////////////////////////////////////////////////////////////////
54
55    /**
56     * Constructor for DatabaseSchemaClassFactoryTest.
57     * @param arg0 - name of the test
58     */
59    public DatabaseSchemaClassFactoryTest(
60       String JavaDoc arg0
61    )
62    {
63       super(arg0);
64    }
65
66    /**
67     * Set up environment for the test case.
68     *
69     * @throws Exception - an error has occured during setting up test
70     */
71    protected void setUp(
72    ) throws Exception JavaDoc
73    {
74       super.setUp();
75    }
76
77    /**
78     * Restore original environment after the test case.
79     *
80     * @throws Exception - an error has occured during tearing down up test
81     */
82    protected void tearDown() throws Exception JavaDoc
83    {
84       super.tearDown();
85    }
86
87    /**
88     * Test createNewInstance method with Class parameter
89     *
90     * @throws Exception - and error has occured
91     */
92    public void testCreateInstanceWithClass(
93    ) throws Exception JavaDoc
94    {
95       Config originalInstance;
96       
97       originalInstance = Config.getInstance();
98       try
99       {
100          Object JavaDoc test;
101          ClassFactory factory = new DatabaseSchemaClassFactory();
102          
103          // First instantiate class which is not database schema
104 try
105          {
106             test = factory.createInstance(String JavaDoc.class);
107             fail("Shouldn't be able to instantiate String class using" +
108                  " DatabaseSchema class factory");
109          }
110          catch (OSSDynamicClassException dceExc)
111          {
112             // This is expected exception, don't do anything
113 }
114
115          // Now try to instantiate test database schema to see what we get
116 test = factory.createInstance(DatabaseTestSchema.class);
117          assertNotNull("Cannot instantiate class", test);
118          assertTrue("Must be instance of DatabaseSchema",
119                     test instanceof DatabaseSchema);
120          assertTrue("Must be instance of DatabaseTestSchema",
121                     test instanceof DatabaseTestSchema);
122          switch (DatabaseImpl.getInstance().getDatabaseType())
123          {
124             case (Database.HSQLDB_DATABASE_TYPE) :
125             {
126                assertTrue("Must be instance of HsqlDBDatabaseTestSchema",
127                           test instanceof HsqlDBDatabaseTestSchema);
128                break;
129             }
130             case (Database.SAPDB_DATABASE_TYPE) :
131             {
132                assertTrue("Must be instance of SapDBDatabaseTestSchema",
133                           test instanceof SapDBDatabaseTestSchema);
134                break;
135             }
136             case (Database.MAXDB_DATABASE_TYPE) :
137             {
138                assertTrue("Must be instance of MaxDBDatabaseTestSchema",
139                           test instanceof MaxDBDatabaseTestSchema);
140                break;
141             }
142             case (Database.POSTGRESQL_DATABASE_TYPE) :
143             {
144                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema",
145                           test instanceof PostgreSQLDatabaseTestSchema);
146                break;
147             }
148             case (Database.MYSQL_DATABASE_TYPE) :
149             {
150                assertTrue("Must be instance of MySQLDatabaseTestSchema",
151                           test instanceof MySQLDatabaseTestSchema);
152                break;
153             }
154             case (Database.MSSQL_DATABASE_TYPE) :
155             {
156                assertTrue("Must be instance of MSSQLDatabaseTestSchema",
157                           test instanceof MSSQLDatabaseTestSchema);
158                break;
159             }
160             case (Database.DB2_DATABASE_TYPE) :
161             {
162                assertTrue("Must be instance of DB2DatabaseTestSchema",
163                           test instanceof DB2DatabaseTestSchema);
164                break;
165             }
166             case (Database.SYBASE_DATABASE_TYPE) :
167             {
168                assertTrue("Must be instance of SybaseDatabaseTestSchema",
169                           test instanceof SybaseDatabaseTestSchema);
170                break;
171             }
172             case (Database.ORACLE_DATABASE_TYPE) :
173             {
174                assertTrue("Must be instance of OracleDatabaseTestSchema",
175                           test instanceof OracleDatabaseTestSchema);
176                break;
177             }
178             default:
179             {
180                fail("Unknown database type");
181             }
182          }
183          
184          // Now create new configuration file which will instruct the class
185 // factory to create completely different class when asked for the
186 // default class. THis allows us configurable overriding
187 Properties JavaDoc predefinedProperties = new Properties JavaDoc();
188          switch (DatabaseImpl.getInstance().getDatabaseType())
189          {
190             case (Database.HSQLDB_DATABASE_TYPE) :
191             {
192                // Put some other database schema to test this still override
193 // whatever the environment says
194 predefinedProperties.put(DatabaseTestSchema.class.getName(),
195                                         SapDBDatabaseTestSchema.class.getName());
196                break;
197             }
198             case (Database.SAPDB_DATABASE_TYPE) :
199             {
200                // Put some other database schema to test this still override
201 // whatever the environment says
202 predefinedProperties.put(DatabaseTestSchema.class.getName(),
203                                         MaxDBDatabaseTestSchema.class.getName());
204                break;
205             }
206             case (Database.MAXDB_DATABASE_TYPE) :
207             {
208                // Put some other database schema to test this still override
209 // whatever the environment says
210 predefinedProperties.put(DatabaseTestSchema.class.getName(),
211                                         PostgreSQLDatabaseTestSchema.class.getName());
212                break;
213             }
214             case (Database.POSTGRESQL_DATABASE_TYPE) :
215             {
216                // Put some other database schema to test this still override
217 // whatever the environment says
218 predefinedProperties.put(DatabaseTestSchema.class.getName(),
219                                         MySQLDatabaseTestSchema.class.getName());
220                break;
221             }
222             case (Database.MYSQL_DATABASE_TYPE) :
223             {
224                // Put some other database schema to test this still override
225 // whatever the environment says
226 predefinedProperties.put(DatabaseTestSchema.class.getName(),
227                                         MSSQLDatabaseTestSchema.class.getName());
228                break;
229             }
230             case (Database.MSSQL_DATABASE_TYPE) :
231             {
232                // Put some other database schema to test this still override
233 // whatever the environment says
234 predefinedProperties.put(DatabaseTestSchema.class.getName(),
235                                         DB2DatabaseTestSchema.class.getName());
236                break;
237             }
238             case (Database.DB2_DATABASE_TYPE) :
239             {
240                // Put some other database schema to test this still override
241 // whatever the environment says
242 predefinedProperties.put(DatabaseTestSchema.class.getName(),
243                                         SybaseDatabaseTestSchema.class.getName());
244                break;
245             }
246             case (Database.SYBASE_DATABASE_TYPE) :
247             {
248                // Put some other database schema to test this still override
249 // whatever the environment says
250 predefinedProperties.put(DatabaseTestSchema.class.getName(),
251                                         OracleDatabaseTestSchema.class.getName());
252                break;
253             }
254             case (Database.ORACLE_DATABASE_TYPE) :
255             {
256                // Put some other database schema to test this still override
257 // whatever the environment says
258 predefinedProperties.put(DatabaseTestSchema.class.getName(),
259                                         HsqlDBDatabaseTestSchema.class.getName());
260                break;
261             }
262             default:
263             {
264                fail("Unknown database type");
265             }
266          }
267          // Now reset the default configuration file to use our properties
268 Config.setInstance(new Config(predefinedProperties));
269       
270          // And now ask for the class and we should get the misconfigured class
271 test = factory.createInstance(DatabaseTestSchema.class);
272          assertNotNull("Cannot instantiate class", test);
273          assertTrue("Must be instance of DatabaseSchema",
274                     test instanceof DatabaseSchema);
275          assertTrue("Must be instance of DatabaseTestSchema",
276                     test instanceof DatabaseTestSchema);
277          switch (DatabaseImpl.getInstance().getDatabaseType())
278          {
279             case (Database.HSQLDB_DATABASE_TYPE) :
280             {
281                assertTrue("Must be instance of SapDBDatabaseTestSchema",
282                           test instanceof SapDBDatabaseTestSchema);
283                break;
284             }
285             case (Database.SAPDB_DATABASE_TYPE) :
286             {
287                assertTrue("Must be instance of SapDBDatabaseTestSchema",
288                           test instanceof SapDBDatabaseTestSchema);
289                break;
290             }
291             case (Database.MAXDB_DATABASE_TYPE) :
292             {
293                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema",
294                           test instanceof PostgreSQLDatabaseTestSchema);
295                break;
296             }
297             case (Database.POSTGRESQL_DATABASE_TYPE) :
298             {
299                assertTrue("Must be instance of MySQLDatabaseTestSchema",
300                           test instanceof MySQLDatabaseTestSchema);
301                break;
302             }
303             case (Database.MYSQL_DATABASE_TYPE) :
304             {
305                assertTrue("Must be instance of MSSQLDatabaseTestSchema",
306                           test instanceof MSSQLDatabaseTestSchema);
307                break;
308             }
309             case (Database.MSSQL_DATABASE_TYPE) :
310             {
311                assertTrue("Must be instance of DB2DatabaseTestSchema",
312                           test instanceof DB2DatabaseTestSchema);
313                break;
314             }
315             case (Database.DB2_DATABASE_TYPE) :
316             {
317                assertTrue("Must be instance of SybaseDatabaseTestSchema",
318                           test instanceof SybaseDatabaseTestSchema);
319                break;
320             }
321             case (Database.SYBASE_DATABASE_TYPE) :
322             {
323                assertTrue("Must be instance of OracleDatabaseTestSchema",
324                           test instanceof OracleDatabaseTestSchema);
325                break;
326             }
327             case (Database.ORACLE_DATABASE_TYPE) :
328             {
329                assertTrue("Must be instance of HsqlDBDatabaseTestSchema",
330                           test instanceof HsqlDBDatabaseTestSchema);
331                break;
332             }
333             default:
334             {
335                fail("Unknown database type");
336             }
337          }
338       }
339       finally
340       {
341          // Reset the default config instance since other tests may depend on it
342 Config.setInstance(originalInstance);
343       }
344    }
345
346    /**
347     * Test createNewInstance method with Class parameter and default class
348     *
349     * @throws Exception - and error has occured
350     */
351    public void testCreateInstanceWithClassAndDefault(
352    ) throws Exception JavaDoc
353    {
354       Config originalInstance;
355       
356       originalInstance = Config.getInstance();
357       try
358       {
359          Object JavaDoc test;
360          ClassFactory factory = new DatabaseSchemaClassFactory();
361          
362          // First instantiate class which is not database schema
363 try
364          {
365             test = factory.createInstance(String JavaDoc.class);
366             fail("Shouldn't be able to instantiate String class using" +
367                  " DatabaseSchema class factory");
368          }
369          catch (OSSDynamicClassException dceExc)
370          {
371             // This is expected exception, don't do anything
372 }
373
374          // Now try to instantiate test database schema to see what we get
375 test = factory.createInstance(DatabaseTestSchema.class);
376          assertNotNull("Cannot instantiate class", test);
377          assertTrue("Must be instance of DatabaseSchema",
378                     test instanceof DatabaseSchema);
379          assertTrue("Must be instance of DatabaseTestSchema",
380                     test instanceof DatabaseTestSchema);
381          switch (DatabaseImpl.getInstance().getDatabaseType())
382          {
383             case (Database.HSQLDB_DATABASE_TYPE) :
384             {
385                assertTrue("Must be instance of HsqlDBDatabaseTestSchema",
386                           test instanceof HsqlDBDatabaseTestSchema);
387                break;
388             }
389             case (Database.SAPDB_DATABASE_TYPE) :
390             {
391                assertTrue("Must be instance of SapDBDatabaseTestSchema",
392                           test instanceof SapDBDatabaseTestSchema);
393                break;
394             }
395             case (Database.MAXDB_DATABASE_TYPE) :
396             {
397                assertTrue("Must be instance of MaxDBDatabaseTestSchema",
398                           test instanceof MaxDBDatabaseTestSchema);
399                break;
400             }
401             case (Database.POSTGRESQL_DATABASE_TYPE) :
402             {
403                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema",
404                           test instanceof PostgreSQLDatabaseTestSchema);
405                break;
406             }
407             case (Database.MYSQL_DATABASE_TYPE) :
408             {
409                assertTrue("Must be instance of MySQLDatabaseTestSchema",
410                           test instanceof MySQLDatabaseTestSchema);
411                break;
412             }
413             case (Database.MSSQL_DATABASE_TYPE) :
414             {
415                assertTrue("Must be instance of MSSQLDatabaseTestSchema",
416                           test instanceof MSSQLDatabaseTestSchema);
417                break;
418             }
419             case (Database.DB2_DATABASE_TYPE) :
420             {
421                assertTrue("Must be instance of DB2DatabaseTestSchema",
422                           test instanceof DB2DatabaseTestSchema);
423                break;
424             }
425             case (Database.SYBASE_DATABASE_TYPE) :
426             {
427                assertTrue("Must be instance of SybaseDatabaseTestSchema",
428                           test instanceof SybaseDatabaseTestSchema);
429                break;
430             }
431             case (Database.ORACLE_DATABASE_TYPE) :
432             {
433                assertTrue("Must be instance of OracleDatabaseTestSchema",
434                           test instanceof OracleDatabaseTestSchema);
435                break;
436             }
437             default:
438             {
439                fail("Unknown database type");
440             }
441          }
442          
443          // Now create new configuration file which will instruct the class
444 // factory to create completely different class when asked for the
445 // default class. THis allows us configurable overriding
446 Properties JavaDoc predefinedProperties = new Properties JavaDoc();
447          switch (DatabaseImpl.getInstance().getDatabaseType())
448          {
449             case (Database.HSQLDB_DATABASE_TYPE) :
450             {
451                // Put some other database schema to test this still override
452 // whatever the environment says
453 predefinedProperties.put(DatabaseTestSchema.class.getName(),
454                                         SapDBDatabaseTestSchema.class.getName());
455                break;
456             }
457             case (Database.SAPDB_DATABASE_TYPE) :
458             {
459                // Put some other database schema to test this still override
460 // whatever the environment says
461 predefinedProperties.put(DatabaseTestSchema.class.getName(),
462                                         MaxDBDatabaseTestSchema.class.getName());
463                break;
464             }
465             case (Database.MAXDB_DATABASE_TYPE) :
466             {
467                // Put some other database schema to test this still override
468 // whatever the environment says
469 predefinedProperties.put(DatabaseTestSchema.class.getName(),
470                                         PostgreSQLDatabaseTestSchema.class.getName());
471                break;
472             }
473             case (Database.POSTGRESQL_DATABASE_TYPE) :
474             {
475                // Put some other database schema to test this still override
476 // whatever the environment says
477 predefinedProperties.put(DatabaseTestSchema.class.getName(),
478                                         MySQLDatabaseTestSchema.class.getName());
479                break;
480             }
481             case (Database.MYSQL_DATABASE_TYPE) :
482             {
483                // Put some other database schema to test this still override
484 // whatever the environment says
485 predefinedProperties.put(DatabaseTestSchema.class.getName(),
486                                         MSSQLDatabaseTestSchema.class.getName());
487                break;
488             }
489             case (Database.MSSQL_DATABASE_TYPE) :
490             {
491                // Put some other database schema to test this still override
492 // whatever the environment says
493 predefinedProperties.put(DatabaseTestSchema.class.getName(),
494                                         DB2DatabaseTestSchema.class.getName());
495                break;
496             }
497             case (Database.DB2_DATABASE_TYPE) :
498             {
499                // Put some other database schema to test this still override
500 // whatever the environment says
501 predefinedProperties.put(DatabaseTestSchema.class.getName(),
502                                         SybaseDatabaseTestSchema.class.getName());
503                break;
504             }
505             case (Database.SYBASE_DATABASE_TYPE) :
506             {
507                // Put some other database schema to test this still override
508 // whatever the environment says
509 predefinedProperties.put(DatabaseTestSchema.class.getName(),
510                                         OracleDatabaseTestSchema.class.getName());
511                break;
512             }
513             case (Database.ORACLE_DATABASE_TYPE) :
514             {
515                // Put some other database schema to test this still override
516 // whatever the environment says
517 predefinedProperties.put(DatabaseTestSchema.class.getName(),
518                                         HsqlDBDatabaseTestSchema.class.getName());
519                break;
520             }
521             default:
522             {
523                fail("Unknown database type");
524             }
525          }
526          // Now reset the default configuration file to use our properties
527 Config.setInstance(new Config(predefinedProperties));
528       
529          // And now ask for the class and we should get the misconfigured class
530 test = factory.createInstance(DatabaseTestSchema.class);
531          assertNotNull("Cannot instantiate class", test);
532          assertTrue("Must be instance of DatabaseSchema",
533                     test instanceof DatabaseSchema);
534          assertTrue("Must be instance of DatabaseTestSchema",
535                     test instanceof DatabaseTestSchema);
536          switch (DatabaseImpl.getInstance().getDatabaseType())
537          {
538             case (Database.HSQLDB_DATABASE_TYPE) :
539             {
540                assertTrue("Must be instance of SapDBDatabaseTestSchema",
541                           test instanceof SapDBDatabaseTestSchema);
542                break;
543             }
544             case (Database.SAPDB_DATABASE_TYPE) :
545             {
546                assertTrue("Must be instance of MaxDBDatabaseTestSchema",
547                           test instanceof MaxDBDatabaseTestSchema);
548                break;
549             }
550             case (Database.MAXDB_DATABASE_TYPE) :
551             {
552                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema",
553                           test instanceof PostgreSQLDatabaseTestSchema);
554                break;
555             }
556             case (Database.POSTGRESQL_DATABASE_TYPE) :
557             {
558                assertTrue("Must be instance of MySQLDatabaseTestSchema",
559                           test instanceof MySQLDatabaseTestSchema);
560                break;
561             }
562             case (Database.MYSQL_DATABASE_TYPE) :
563             {
564                assertTrue("Must be instance of MSSQLDatabaseTestSchema",
565                           test instanceof MSSQLDatabaseTestSchema);
566                break;
567             }
568             case (Database.MSSQL_DATABASE_TYPE) :
569             {
570                assertTrue("Must be instance of DB2DatabaseTestSchema",
571                           test instanceof DB2DatabaseTestSchema);
572                break;
573             }
574             case (Database.DB2_DATABASE_TYPE) :
575             {
576                assertTrue("Must be instance of SybaseDatabaseTestSchema",
577                           test instanceof SybaseDatabaseTestSchema);
578                break;
579             }
580             case (Database.SYBASE_DATABASE_TYPE) :
581             {
582                assertTrue("Must be instance of OracleDatabaseTestSchema",
583                           test instanceof OracleDatabaseTestSchema);
584                break;
585             }
586             case (Database.ORACLE_DATABASE_TYPE) :
587             {
588                assertTrue("Must be instance of HsqlDBDatabaseTestSchema",
589                           test instanceof HsqlDBDatabaseTestSchema);
590                break;
591             }
592             default:
593             {
594                fail("Unknown database type");
595             }
596          }
597           
598          // The only way how to test the creation of default parameter is to
599 // setup property which instruct to load some bogus class when some
600 // other class is requested
601 predefinedProperties = new Properties JavaDoc();
602          predefinedProperties.put(DatabaseTestSchema.class.getName(),
603                                   "random.text");
604          // Now reset the default configuration file to use our properties
605 Config.setInstance(new Config(predefinedProperties));
606           
607          try
608          {
609             test = factory.createInstance(DatabaseTestSchema.class,
610                                           String JavaDoc.class);
611             fail("Shouldn't be able to instantiate String class even as a default"
612                  + " class using DatabaseSchema class factory");
613          }
614          catch (OSSDynamicClassException dceExc)
615          {
616            // This is expected exception, don't do anything
617 }
618
619          // But we should be able to instantiate valid default class
620 test = factory.createInstance(DatabaseTestSchema.class,
621                                        HsqlDBDatabaseTestSchema.class);
622          assertTrue("Must be instance of DatabaseSchema",
623                     test instanceof HsqlDBDatabaseTestSchema);
624       }
625       finally
626       {
627          // Reset the default config instance since other tests may depend on it
628 Config.setInstance(originalInstance);
629       }
630    }
631
632    /**
633     * Test createNewInstance method with Strig parameter
634     *
635     * @throws Exception - and error has occured
636     */
637    public void testCreateInstanceWithString(
638    ) throws Exception JavaDoc
639    {
640       Config originalInstance;
641       
642       originalInstance = Config.getInstance();
643       try
644       {
645          Object JavaDoc test;
646          ClassFactory factory = new DatabaseSchemaClassFactory();
647          
648          // First instantiate class which is not database schema
649 try
650          {
651             test = factory.createInstance(String JavaDoc.class.getName());
652             fail("Shouldn't be able to instantiate String class using" +
653                  " DatabaseSchema class factory");
654          }
655          catch (OSSDynamicClassException dceExc)
656          {
657             // This is expected exception, don't do anything
658 }
659
660          // Now try to instantiate test database schema to see what we get
661 test = factory.createInstance(DatabaseTestSchema.class.getName());
662          assertNotNull("Cannot instantiate class", test);
663          assertTrue("Must be instance of DatabaseSchema",
664                     test instanceof DatabaseSchema);
665          assertTrue("Must be instance of DatabaseTestSchema",
666                     test instanceof DatabaseTestSchema);
667          switch (DatabaseImpl.getInstance().getDatabaseType())
668          {
669             case (Database.HSQLDB_DATABASE_TYPE) :
670             {
671                assertTrue("Must be instance of HsqlDBDatabaseTestSchema",
672                           test instanceof HsqlDBDatabaseTestSchema);
673                break;
674             }
675             case (Database.SAPDB_DATABASE_TYPE) :
676             {
677                assertTrue("Must be instance of SapDBDatabaseTestSchema",
678                           test instanceof SapDBDatabaseTestSchema);
679                break;
680             }
681             case (Database.MAXDB_DATABASE_TYPE) :
682             {
683                assertTrue("Must be instance of MaxDBDatabaseTestSchema",
684                           test instanceof MaxDBDatabaseTestSchema);
685                break;
686             }
687             case (Database.POSTGRESQL_DATABASE_TYPE) :
688             {
689                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema",
690                           test instanceof PostgreSQLDatabaseTestSchema);
691                break;
692             }
693             case (Database.MYSQL_DATABASE_TYPE) :
694             {
695                assertTrue("Must be instance of MySQLDatabaseTestSchema",
696                           test instanceof MySQLDatabaseTestSchema);
697                break;
698             }
699             case (Database.MSSQL_DATABASE_TYPE) :
700             {
701                assertTrue("Must be instance of MSSQLDatabaseTestSchema",
702                           test instanceof MSSQLDatabaseTestSchema);
703                break;
704             }
705             case (Database.DB2_DATABASE_TYPE) :
706             {
707                assertTrue("Must be instance of DB2DatabaseTestSchema",
708                           test instanceof DB2DatabaseTestSchema);
709                break;
710             }
711             case (Database.SYBASE_DATABASE_TYPE) :
712             {
713                assertTrue("Must be instance of SybaseDatabaseTestSchema",
714                           test instanceof SybaseDatabaseTestSchema);
715                break;
716             }
717             case (Database.ORACLE_DATABASE_TYPE) :
718             {
719                assertTrue("Must be instance of OracleDatabaseTestSchema",
720                           test instanceof OracleDatabaseTestSchema);
721                break;
722             }
723             default:
724             {
725                fail("Unknown database type");
726             }
727          }
728          
729          // Now create new configuration file which will instruct the class
730 // factory to create completely different class when asked for the
731 // default class. THis allows us configurable overriding
732 Properties JavaDoc predefinedProperties = new Properties JavaDoc();
733          switch (DatabaseImpl.getInstance().getDatabaseType())
734          {
735             case (Database.HSQLDB_DATABASE_TYPE) :
736             {
737                // Put some other database schema to test this still override
738 // whatever the environment says
739 predefinedProperties.put(DatabaseTestSchema.class.getName(),
740                                         SapDBDatabaseTestSchema.class.getName());
741                break;
742             }
743             case (Database.SAPDB_DATABASE_TYPE) :
744             {
745                // Put some other database schema to test this still override
746 // whatever the environment says
747 predefinedProperties.put(DatabaseTestSchema.class.getName(),
748                                         MaxDBDatabaseTestSchema.class.getName());
749                break;
750             }
751             case (Database.MAXDB_DATABASE_TYPE) :
752             {
753                // Put some other database schema to test this still override
754 // whatever the environment says
755 predefinedProperties.put(DatabaseTestSchema.class.getName(),
756                                         PostgreSQLDatabaseTestSchema.class.getName());
757                break;
758             }
759             case (Database.POSTGRESQL_DATABASE_TYPE) :
760             {
761                // Put some other database schema to test this still override
762 // whatever the environment says
763 predefinedProperties.put(DatabaseTestSchema.class.getName(),
764                                         MySQLDatabaseTestSchema.class.getName());
765                break;
766             }
767             case (Database.MYSQL_DATABASE_TYPE) :
768             {
769                // Put some other database schema to test this still override
770 // whatever the environment says
771 predefinedProperties.put(DatabaseTestSchema.class.getName(),
772                                         MSSQLDatabaseTestSchema.class.getName());
773                break;
774             }
775             case (Database.MSSQL_DATABASE_TYPE) :
776             {
777                // Put some other database schema to test this still override
778 // whatever the environment says
779 predefinedProperties.put(DatabaseTestSchema.class.getName(),
780                                         DB2DatabaseTestSchema.class.getName());
781                break;
782             }
783             case (Database.DB2_DATABASE_TYPE) :
784             {
785                // Put some other database schema to test this still override
786 // whatever the environment says
787 predefinedProperties.put(DatabaseTestSchema.class.getName(),
788                                         SybaseDatabaseTestSchema.class.getName());
789                break;
790             }
791             case (Database.SYBASE_DATABASE_TYPE) :
792             {
793                // Put some other database schema to test this still override
794 // whatever the environment says
795 predefinedProperties.put(DatabaseTestSchema.class.getName(),
796                                         OracleDatabaseTestSchema.class.getName());
797                break;
798             }
799             case (Database.ORACLE_DATABASE_TYPE) :
800             {
801                // Put some other database schema to test this still override
802 // whatever the environment says
803 predefinedProperties.put(DatabaseTestSchema.class.getName(),
804                                         HsqlDBDatabaseTestSchema.class.getName());
805                break;
806             }
807             default:
808             {
809                fail("Unknown database type");
810             }
811          }
812          // Just to demonstrate that the DatabaseSchemaClassFactory can still
813 // use the first argument just as an identifier and not as a name,
814 // configure another random property to point to base class
815 predefinedProperties.put("random.text",
816                                   HsqlDBDatabaseTestSchema.class.getName());
817          predefinedProperties.put("random.text2", String JavaDoc.class.getName());
818          // Now reset the default configuration file to use our properties
819 Config.setInstance(new Config(predefinedProperties));
820       
821          // And now ask for the class and we should get the misconfigured class
822 test = factory.createInstance(DatabaseTestSchema.class.getName());
823          assertNotNull("Cannot instantiate class", test);
824          assertTrue("Must be instance of DatabaseSchema",
825                     test instanceof DatabaseSchema);
826          assertTrue("Must be instance of DatabaseTestSchema",
827                     test instanceof DatabaseTestSchema);
828          switch (DatabaseImpl.getInstance().getDatabaseType())
829          {
830             case (Database.HSQLDB_DATABASE_TYPE) :
831             {
832                assertTrue("Must be instance of SapDBDatabaseTestSchema",
833                           test instanceof SapDBDatabaseTestSchema);
834                break;
835             }
836             case (Database.SAPDB_DATABASE_TYPE) :
837             {
838                assertTrue("Must be instance of MaxDBDatabaseTestSchema",
839                           test instanceof MaxDBDatabaseTestSchema);
840                break;
841             }
842             case (Database.MAXDB_DATABASE_TYPE) :
843             {
844                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema",
845                           test instanceof PostgreSQLDatabaseTestSchema);
846                break;
847             }
848             case (Database.POSTGRESQL_DATABASE_TYPE) :
849             {
850                assertTrue("Must be instance of MySQLDatabaseTestSchema",
851                           test instanceof MySQLDatabaseTestSchema);
852                break;
853             }
854             case (Database.MYSQL_DATABASE_TYPE) :
855             {
856                assertTrue("Must be instance of MSSQLDatabaseTestSchema",
857                           test instanceof MSSQLDatabaseTestSchema);
858                break;
859             }
860             case (Database.MSSQL_DATABASE_TYPE) :
861             {
862                assertTrue("Must be instance of DB2DatabaseTestSchema",
863                           test instanceof DB2DatabaseTestSchema);
864                break;
865             }
866             case (Database.DB2_DATABASE_TYPE) :
867             {
868                assertTrue("Must be instance of SybaseDatabaseTestSchema",
869                           test instanceof SybaseDatabaseTestSchema);
870                break;
871             }
872             case (Database.SYBASE_DATABASE_TYPE) :
873             {
874                assertTrue("Must be instance of OracleDatabaseTestSchema",
875                           test instanceof OracleDatabaseTestSchema);
876                break;
877             }
878             case (Database.ORACLE_DATABASE_TYPE) :
879             {
880                assertTrue("Must be instance of HsqlDBDatabaseTestSchema",
881                           test instanceof HsqlDBDatabaseTestSchema);
882                break;
883             }
884             default:
885             {
886                fail("Unknown database type");
887             }
888          }
889
890          // Now ask for the text and we should still get our schema
891 test = factory.createInstance("random.text");
892          assertNotNull("Cannot instantiate class", test);
893          assertTrue("Must be instance of base class",
894                     test instanceof HsqlDBDatabaseTestSchema);
895          
896          try
897          {
898             test = factory.createInstance("random.text2");
899             fail("Shouldn't be able to instantiate String class even though it"
900                  + " is valid class using DatabaseSchema class factory");
901          }
902          catch (OSSDynamicClassException dceExc)
903          {
904            // This is expected exception, don't do anything
905 }
906       }
907       finally
908       {
909          // Reset the default config instance since other tests may depend on it
910 Config.setInstance(originalInstance);
911       }
912    }
913
914    /**
915     * Test createNewInstance method with String parameter and default class
916     *
917     * @throws Exception - and error has occured
918     */
919    public void testCreateInstanceWithStringAndDefault(
920    ) throws Exception JavaDoc
921    {
922       Config originalInstance;
923       
924       originalInstance = Config.getInstance();
925       try
926       {
927          Object JavaDoc test;
928          ClassFactory factory = new DatabaseSchemaClassFactory();
929          
930          // First instantiate class which is not database schema
931 try
932          {
933             test = factory.createInstance(String JavaDoc.class.getName());
934             fail("Shouldn't be able to instantiate String class using" +
935                  " DatabaseSchema class factory");
936          }
937          catch (OSSDynamicClassException dceExc)
938          {
939             // This is expected exception, don't do anything
940 }
941
942          // Now try to instantiate test database schema to see what we get
943 test = factory.createInstance(DatabaseTestSchema.class.getName());
944          assertNotNull("Cannot instantiate class", test);
945          assertTrue("Must be instance of DatabaseSchema",
946                     test instanceof DatabaseSchema);
947          assertTrue("Must be instance of DatabaseTestSchema",
948                     test instanceof DatabaseTestSchema);
949          switch (DatabaseImpl.getInstance().getDatabaseType())
950          {
951             case (Database.HSQLDB_DATABASE_TYPE) :
952             {
953                assertTrue("Must be instance of HsqlDBDatabaseTestSchema",
954                           test instanceof HsqlDBDatabaseTestSchema);
955                break;
956             }
957             case (Database.SAPDB_DATABASE_TYPE) :
958             {
959                assertTrue("Must be instance of SapDBDatabaseTestSchema",
960                           test instanceof SapDBDatabaseTestSchema);
961                break;
962             }
963             case (Database.MAXDB_DATABASE_TYPE) :
964             {
965                assertTrue("Must be instance of MaxDBDatabaseTestSchema",
966                           test instanceof MaxDBDatabaseTestSchema);
967                break;
968             }
969             case (Database.POSTGRESQL_DATABASE_TYPE) :
970             {
971                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema",
972                           test instanceof PostgreSQLDatabaseTestSchema);
973                break;
974             }
975             case (Database.MYSQL_DATABASE_TYPE) :
976             {
977                assertTrue("Must be instance of MySQLDatabaseTestSchema",
978                           test instanceof MySQLDatabaseTestSchema);
979                break;
980             }
981             case (Database.MSSQL_DATABASE_TYPE) :
982             {
983                assertTrue("Must be instance of MSSQLDatabaseTestSchema",
984                           test instanceof MSSQLDatabaseTestSchema);
985                break;
986             }
987             case (Database.DB2_DATABASE_TYPE) :
988             {
989                assertTrue("Must be instance of DB2DatabaseTestSchema",
990                           test instanceof DB2DatabaseTestSchema);
991                break;
992             }
993             case (Database.SYBASE_DATABASE_TYPE) :
994             {
995                assertTrue("Must be instance of SybaseDatabaseTestSchema",
996                           test instanceof SybaseDatabaseTestSchema);
997                break;
998             }
999             case (Database.ORACLE_DATABASE_TYPE) :
1000            {
1001               assertTrue("Must be instance of OracleDatabaseTestSchema",
1002                          test instanceof OracleDatabaseTestSchema);
1003               break;
1004            }
1005            default:
1006            {
1007               fail("Unknown database type");
1008            }
1009         }
1010         
1011         // Now create new configuration file which will instruct the class
1012 // factory to create completely different class when asked for the
1013 // default class. THis allows us configurable overriding
1014 Properties JavaDoc predefinedProperties = new Properties JavaDoc();
1015         switch (DatabaseImpl.getInstance().getDatabaseType())
1016         {
1017            case (Database.HSQLDB_DATABASE_TYPE) :
1018            {
1019               // Put some other database schema to test this still override
1020 // whatever the environment says
1021 predefinedProperties.put(DatabaseTestSchema.class.getName(),
1022                                        SapDBDatabaseTestSchema.class.getName());
1023               break;
1024            }
1025            case (Database.SAPDB_DATABASE_TYPE) :
1026            {
1027               // Put some other database schema to test this still override
1028 // whatever the environment says
1029 predefinedProperties.put(DatabaseTestSchema.class.getName(),
1030                                        MaxDBDatabaseTestSchema.class.getName());
1031               break;
1032            }
1033            case (Database.MAXDB_DATABASE_TYPE) :
1034            {
1035               // Put some other database schema to test this still override
1036 // whatever the environment says
1037 predefinedProperties.put(DatabaseTestSchema.class.getName(),
1038                                        PostgreSQLDatabaseTestSchema.class.getName());
1039               break;
1040            }
1041            case (Database.POSTGRESQL_DATABASE_TYPE) :
1042            {
1043               // Put some other database schema to test this still override
1044 // whatever the environment says
1045 predefinedProperties.put(DatabaseTestSchema.class.getName(),
1046                                        MySQLDatabaseTestSchema.class.getName());
1047               break;
1048            }
1049            case (Database.MYSQL_DATABASE_TYPE) :
1050            {
1051               // Put some other database schema to test this still override
1052 // whatever the environment says
1053 predefinedProperties.put(DatabaseTestSchema.class.getName(),
1054                                        MSSQLDatabaseTestSchema.class.getName());
1055               break;
1056            }
1057            case (Database.MSSQL_DATABASE_TYPE) :
1058            {
1059               // Put some other database schema to test this still override
1060 // whatever the environment says
1061 predefinedProperties.put(DatabaseTestSchema.class.getName(),
1062                                        DB2DatabaseTestSchema.class.getName());
1063               break;
1064            }
1065            case (Database.DB2_DATABASE_TYPE) :
1066            {
1067               // Put some other database schema to test this still override
1068 // whatever the environment says
1069 predefinedProperties.put(DatabaseTestSchema.class.getName(),
1070                                        SybaseDatabaseTestSchema.class.getName());
1071               break;
1072            }
1073            case (Database.SYBASE_DATABASE_TYPE) :
1074            {
1075               // Put some other database schema to test this still override
1076 // whatever the environment says
1077 predefinedProperties.put(DatabaseTestSchema.class.getName(),
1078                                        OracleDatabaseTestSchema.class.getName());
1079               break;
1080            }
1081            case (Database.ORACLE_DATABASE_TYPE) :
1082            {
1083               // Put some other database schema to test this still override
1084 // whatever the environment says
1085 predefinedProperties.put(DatabaseTestSchema.class.getName(),
1086                                        HsqlDBDatabaseTestSchema.class.getName());
1087               break;
1088            }
1089            default:
1090            {
1091               fail("Unknown database type");
1092            }
1093         }
1094         // Just to demonstrate that the DatabaseSchemaClassFactory can still
1095 // use the first argument just as an identifier and not as a name,
1096 // configure another random property to point to base class
1097 predefinedProperties.put("random.text",
1098                                  HsqlDBDatabaseTestSchema.class.getName());
1099         predefinedProperties.put("random.text2", String JavaDoc.class.getName());
1100         // Now reset the default configuration file to use our properties
1101 Config.setInstance(new Config(predefinedProperties));
1102      
1103         // And now ask for the class and we should get the misconfigured class
1104 test = factory.createInstance(DatabaseTestSchema.class.getName());
1105         assertNotNull("Cannot instantiate class", test);
1106         assertTrue("Must be instance of DatabaseSchema",
1107                    test instanceof DatabaseSchema);
1108         assertTrue("Must be instance of DatabaseTestSchema",
1109                    test instanceof DatabaseTestSchema);
1110         switch (DatabaseImpl.getInstance().getDatabaseType())
1111         {
1112            case (Database.HSQLDB_DATABASE_TYPE) :
1113            {
1114               assertTrue("Must be instance of SapDBDatabaseTestSchema",
1115                          test instanceof SapDBDatabaseTestSchema);
1116               break;
1117            }
1118            case (Database.SAPDB_DATABASE_TYPE) :
1119            {
1120               assertTrue("Must be instance of MaxDBDatabaseTestSchema",
1121                          test instanceof MaxDBDatabaseTestSchema);
1122               break;
1123            }
1124            case (Database.MAXDB_DATABASE_TYPE) :
1125            {
1126               assertTrue("Must be instance of PostgreSQLDatabaseTestSchema",
1127                          test instanceof PostgreSQLDatabaseTestSchema);
1128               break;
1129            }
1130            case (Database.POSTGRESQL_DATABASE_TYPE) :
1131            {
1132               assertTrue("Must be instance of MySQLDatabaseTestSchema",
1133                          test instanceof MySQLDatabaseTestSchema);
1134               break;
1135            }
1136            case (Database.MYSQL_DATABASE_TYPE) :
1137            {
1138               assertTrue("Must be instance of MSSQLDatabaseTestSchema",
1139                          test instanceof MSSQLDatabaseTestSchema);
1140               break;
1141            }
1142            case (Database.MSSQL_DATABASE_TYPE) :
1143            {
1144               assertTrue("Must be instance of DB2DatabaseTestSchema",
1145                          test instanceof DB2DatabaseTestSchema);
1146               break;
1147            }
1148            case (Database.DB2_DATABASE_TYPE) :
1149            {
1150               assertTrue("Must be instance of SybaseDatabaseTestSchema",
1151                          test instanceof SybaseDatabaseTestSchema);
1152               break;
1153            }
1154            case (Database.SYBASE_DATABASE_TYPE) :
1155            {
1156               assertTrue("Must be instance of OracleDatabaseTestSchema",
1157                          test instanceof OracleDatabaseTestSchema);
1158               break;
1159            }
1160            case (Database.ORACLE_DATABASE_TYPE) :
1161            {
1162               assertTrue("Must be instance of HsqlDBDatabaseTestSchema",
1163                          test instanceof HsqlDBDatabaseTestSchema);
1164               break;
1165            }
1166            default:
1167            {
1168               fail("Unknown database type");
1169            }
1170         }
1171
1172         // Now ask for the text and we should still get our schema
1173 test = factory.createInstance("random.text");
1174         assertNotNull("Cannot instantiate class", test);
1175         assertTrue("Must be instance of base class",
1176                    test instanceof HsqlDBDatabaseTestSchema);
1177         
1178         try
1179         {
1180            test = factory.createInstance("random.text2");
1181            fail("Shouldn't be able to instantiate String class even though it"
1182                 + " is valid class using DatabaseSchema class factory");
1183         }
1184         catch (OSSDynamicClassException dceExc)
1185         {
1186           // This is expected exception, don't do anything
1187 }
1188
1189         // The only way how to test the creation of default parameter is to
1190 // setup property which instruct to load some bogus class when some
1191 // other class is requested
1192 predefinedProperties = new Properties JavaDoc();
1193         predefinedProperties.put(DatabaseTestSchema.class.getName(),
1194                                  "random.text");
1195         // Now reset the default configuration file to use our properties
1196 Config.setInstance(new Config(predefinedProperties));
1197          
1198         try
1199         {
1200            test = factory.createInstance(DatabaseTestSchema.class.getName(),
1201                                          String JavaDoc.class);
1202            fail("Shouldn't be able to instantiate String class even as a default"
1203                 + " class using DatabaseSchema class factory");
1204         }
1205         catch (OSSDynamicClassException dceExc)
1206         {
1207           // This is expected exception, don't do anything
1208 }
1209
1210         // But we should be able to instantiate valid default class
1211 test = factory.createInstance(DatabaseTestSchema.class.getName(),
1212                                       HsqlDBDatabaseTestSchema.class);
1213         assertTrue("Must be instance of DatabaseSchema",
1214                    test instanceof HsqlDBDatabaseTestSchema);
1215      }
1216      finally
1217      {
1218         // Reset the default config instance since other tests may depend on it
1219 Config.setInstance(originalInstance);
1220      }
1221   }
1222}
1223
Popular Tags