    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *     http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   */
    17
    18  package javax.jdo;
    19
    20  import java.io.File;
    21  import java.io.InputStream;
    22
    23  import java.util.HashMap;
    24  import java.util.Map;
    25  import java.util.Properties;
    26
    27  import javax.jdo.pc.PCPoint;
    28  import javax.jdo.util.AbstractTest;
    29  import javax.jdo.util.BatchTestRunner;
    30
    31  import javax.naming.Context;
    32  import javax.naming.InitialContext;
    33  import javax.naming.NamingException;
    34
    35  /**
    36   * Tests class javax.jdo.JDOHelper.
    37   * <p>
    38   * TBD: implementation of testMakeDirty,
    39   * TBD: testing interrogative methods for persistent instances
    40   * TBD: getPMF for valid PMF class
    41   */
    42  public class JDOHelperTest extends AbstractTest {
    43
    44      /** */
    45      public static void main(String args[]) {
    46          BatchTestRunner.run(JDOHelperTest.class);
    47      }
    48
    49      /** The purpose of this test is simply to call some of the
    50       * methods on a constructed instance of JDOHelper and verify that
    51       * they do not throw exceptions. It is not a functional test.
    52       * @since 2.1
    53       */
    54      public void testConstructor() {
    55          JDOHelper helper = new JDOHelper();
    56          assertNull("getObjectId(null) returned non-null",
    57                  helper.getObjectId(null));
    58          assertNull("getPersistenceManager(null) returned non-null",
    59                  helper.getPersistenceManager(null));
    60          assertNull("getTransactionalObjectId(null) returned non-null",
    61                  helper.getTransactionalObjectId(null));
    62          assertNull("getVersion(null) returned non-null",
    63                  helper.getVersion(null));
    64          assertFalse("isDeleted(null) returned non-null",
    65                  helper.isDeleted(null));
    66          assertFalse("isDetached(null) returned non-null",
    67                  helper.isDetached(null));
    68          assertFalse("isDirty(null) returned non-null",
    69                  helper.isDirty(null));
    70          assertFalse("isNew(null) returned non-null",
    71                  helper.isNew(null));
    72          assertFalse("isPersistent(null) returned non-null",
    73                  helper.isPersistent(null));
    74          assertFalse("isTransactional(null) returned non-null",
    75                  helper.isTransactional(null));
    76      }
    77
    78      /** The purpose of this test is simply to call some of the
    79       * methods on the static instance of JDOHelper and verify that
    80       * they do not throw exceptions. It is not a functional test.
    81       * @since 2.1
    82       */
    83      public void testGetInstance() {
    84          JDOHelper helper = JDOHelper.getInstance();
    85          assertNull("getObjectId(null) returned non-null",
    86                  helper.getObjectId(null));
    87          assertNull("getPersistenceManager(null) returned non-null",
    88                  helper.getPersistenceManager(null));
    89          assertNull("getTransactionalObjectId(null) returned non-null",
    90                  helper.getTransactionalObjectId(null));
    91          assertNull("getVersion(null) returned non-null",
    92                  helper.getVersion(null));
    93          assertFalse("isDeleted(null) returned non-null",
    94                  helper.isDeleted(null));
    95          assertFalse("isDetached(null) returned non-null",
    96                  helper.isDetached(null));
    97          assertFalse("isDirty(null) returned non-null",
    98                  helper.isDirty(null));
    99          assertFalse("isNew(null) returned non-null",
    100                 helper.isNew(null));
    101         assertFalse("isPersistent(null) returned non-null",
    102                 helper.isPersistent(null));
    103         assertFalse("isTransactional(null) returned non-null",
    104                 helper.isTransactional(null));
    105     }
    106
    107     /** */
    108     public void testGetPM() {
    109         PCPoint p = new PCPoint(1, new Integer(1));
    110         if (JDOHelper.getPersistenceManager(p) != null) {
    111             fail("JDOHelper.getPersistenceManager should return null pm for non-persistent instance");
    112         }
    113
    114         // TBD: test for persistent instance
    115     }
    116
    117     /** */
    118     public void testMakeDirty() {
    119         // TBD: test JDOHelper.makeDirty(pc, fieldName);
    120     }
    121
    122     /** */
    123     public void testGetObjectId() {
    124         PCPoint p = new PCPoint(1, new Integer(1));
    125         if (JDOHelper.getObjectId(p) != null) {
    126             fail("JDOHelper.getObjectId should return null ObjectId for non-persistent instance");
    127         }
    128
    129         // TBD test JDOHelper.getObjectId(pc) for persistent instance
    130     }
    131
    132     /** */
    133     public void testGetTransactionObjectId() {
    134         PCPoint p = new PCPoint(1, new Integer(1));
    135         if (JDOHelper.getObjectId(p) != null) {
    136             fail("JDOHelper.getTransactionalObjectId should return null ObjectId for non-persistent instance");
    137         }
    138
    139         // TBD test JDOHelper.getTransactionalObjectId(pc) for persistent instance
    140     }
    141
    142     /** */
    143     public void testIsDirty() {
    144         PCPoint p = new PCPoint(1, new Integer(1));
    145         if (JDOHelper.isDirty(p)) {
    146             fail("JDOHelper.isDirty should return false for non-persistent instance");
    147         }
    148
    149         // TBD test JDOHelper.isDirty(pc) for persistent instance
    150     }
    151
    152     /** */
    153     public void testIsTransactional() {
    154         PCPoint p = new PCPoint(1, new Integer(1));
    155         if (JDOHelper.isTransactional(p)) {
    156             fail("JDOHelper.isTransactional should return false for non-persistent instance");
    157         }
    158
    159         // TBD test JDOHelper.isTransactional(pc) for persistent instance
    160     }
    161
    162     /** */
    163     public void testIsPersistent() {
    164         PCPoint p = new PCPoint(1, new Integer(1));
    165         if (JDOHelper.isPersistent(p)) {
    166             fail("JDOHelper.isPersistent should return false for non-persistent instance");
    167         }
    168
    169         // TBD test JDOHelper.isPersistent(pc) for persistent instance
    170     }
    171
    172     /** */
    173     public void testIsNew() {
    174         PCPoint p = new PCPoint(1, new Integer(1));
    175         if (JDOHelper.isNew(p)) {
    176             fail("JDOHelper.isNew should return false for non-persistent instance");
    177         }
    178
    179         // TBD test JDOHelper.isNew(pc) for persistent instance
    180     }
    181
    182
    183     /** */
    184     public void testIsDeleted() {
    185         PCPoint p = new PCPoint(1, new Integer(1));
    186         if (JDOHelper.isDeleted(p)) {
    187             fail("JDOHelper.isDeleted should return false for non-persistent instance");
    188         }
    189
    190         // TBD test JDOHelper.isDeleted(pc) for persistent instance
    191     }
    192
    193     /** Test null String resource with no class loader.
    194      */
    195     public void testGetPMFNullResource() {
    196         PersistenceManagerFactory pmf = null;
    197         try {
    198             pmf = JDOHelper.getPersistenceManagerFactory((String)null);
    199             fail("Null resource name should result in JDOFatalUserException");
    200         }
    201         catch (JDOFatalUserException ex) {
    202             if (verbose)
    203                 println("Caught expected exception " + ex);
    204         }
    205     }
    206
    207     /** Test null String resource with good class loader.
    208      */
    209     public void testGetPMFNullResourceGoodClassLoader() {
    210         PersistenceManagerFactory pmf = null;
    211         try {
    212             pmf = JDOHelper.getPersistenceManagerFactory((String)null, this.getClass().getClassLoader());
    213             fail("Null resource name should result in JDOFatalUserException");
    214         }
    215         catch (JDOFatalUserException ex) {
    216             if (verbose)
    217                 println("Caught expected exception " + ex);
    218         }
    219     }
    220
    221     /** Test bad String resource with no class loader.
    222      */
    223     public void testGetPMFBadResource() {
    224         PersistenceManagerFactory pmf = null;
    225         try {
    226             pmf = JDOHelper.getPersistenceManagerFactory("Whatever");
    227             fail("Null resource name should result in JDOFatalUserException");
    228         }
    229         catch (JDOFatalUserException ex) {
    230             if (verbose)
    231                 println("Caught expected exception " + ex);
    232         }
    233     }
    234
    235     /** Test null String resource with good class loader.
    236      */
    237     public void testGetPMFBadResourceGoodClassLoader() {
    238         PersistenceManagerFactory pmf = null;
    239         try {
    240             pmf = JDOHelper.getPersistenceManagerFactory("Whatever", this.getClass().getClassLoader());
    241             fail("Null resource name should result in JDOFatalUserException");
    242         }
    243         catch (JDOFatalUserException ex) {
    244             if (verbose)
    245                 println("Caught expected exception " + ex);
    246         }
    247     }
    248
    249     /** Test null File resource with no class loader.
    250      */
    251     public void testGetPMFNullFile() {
    252         PersistenceManagerFactory pmf = null;
    253         try {
    254             pmf = JDOHelper.getPersistenceManagerFactory((File)null);
    255             fail("Null file should result in JDOFatalUserException");
    256         }
    257         catch (JDOFatalUserException ex) {
    258             if (verbose)
    259                 println("Caught expected exception " + ex);
    260         }
    261     }
    262
    263     /** Test null File resource with good class loader.
    264      */
    265     public void testGetPMFNullFileGoodClassLoader() {
    266         PersistenceManagerFactory pmf = null;
    267         try {
    268             pmf = JDOHelper.getPersistenceManagerFactory((File)null, this.getClass().getClassLoader());
    269             fail("Null file should result in JDOFatalUserException");
    270         }
    271         catch (JDOFatalUserException ex) {
    272             if (verbose)
    273                 println("Caught expected exception " + ex);
    274         }
    275     }
    276
    277     /** Test bad File resource with no class loader.
    278      */
    279     public void testGetPMFBadFile() {
    280         PersistenceManagerFactory pmf = null;
    281         try {
    282             pmf = JDOHelper.getPersistenceManagerFactory(new File("Whatever"));
    283             fail("Null file should result in JDOFatalUserException");
    284         }
    285         catch (JDOFatalUserException ex) {
    286             if (verbose)
    287                 println("Caught expected exception " + ex);
    288         }
    289     }
    290
    291     /** Test bad File resource with good class loader.
    292      */
    293     public void testGetPMFBadFileGoodClassLoader() {
    294         PersistenceManagerFactory pmf = null;
    295         try {
    296             pmf = JDOHelper.getPersistenceManagerFactory(new File("Whatever"), this.getClass().getClassLoader());
    297             fail("Null file should result in JDOFatalUserException");
    298         }
    299         catch (JDOFatalUserException ex) {
    300             if (verbose)
    301                 println("Caught expected exception " + ex);
    302         }
    303     }
    304
    305     /** Test null JNDI resource name with no class loader.
    306      */
    307     public void testGetPMFNullJNDI() {
    308         PersistenceManagerFactory pmf = null;
    309         try {
    310             pmf = JDOHelper.getPersistenceManagerFactory((String)null, getInitialContext());
    311             fail("Null JNDI resource name should result in JDOFatalUserException");
    312         }
    313         catch (JDOFatalUserException ex) {
    314             if (verbose)
    315                 println("Caught expected exception " + ex);
    316         }
    317     }
    318
    319     /** Test null JNDI resource name with good class loader.
    320      */
    321     public void testGetPMFNullJNDIGoodClassLoader() {
    322         PersistenceManagerFactory pmf = null;
    323         try {
    324             pmf = JDOHelper.getPersistenceManagerFactory((String)null, getInitialContext(), this.getClass().getClassLoader());
    325             fail("Null JNDI resource name should result in JDOFatalUserException");
    326         }
    327         catch (JDOFatalUserException ex) {
    328             if (verbose)
    329                 println("Caught expected exception " + ex);
    330         }
    331     }
    332
    333     /** Test bad JNDI resource name with no class loader.
    334      */
    335     public void testGetPMFBadJNDI() {
    336         PersistenceManagerFactory pmf = null;
    337         try {
    338             pmf = JDOHelper.getPersistenceManagerFactory("Whatever", getInitialContext());
    339             fail("Bad JNDI resource name should result in JDOFatalUserException");
    340         }
    341         catch (JDOFatalUserException ex) {
    342             if (verbose)
    343                 println("Caught expected exception " + ex);
    344         }
    345     }
    346
    347     /** Test bad JNDI resource name with good class loader.
    348      */
    349     public void testGetPMFBadJNDIGoodClassLoader() {
    350         PersistenceManagerFactory pmf = null;
    351         try {
    352             pmf = JDOHelper.getPersistenceManagerFactory("Whatever", getInitialContext(), this.getClass().getClassLoader());
    353             fail("Bad JNDI resource name should result in JDOFatalUserException");
    354         }
    355         catch (JDOFatalUserException ex) {
    356             if (verbose)
    357                 println("Caught expected exception " + ex);
    358         }
    359     }
    360
    361     /** Test null stream with no class loader.
    362      */
    363     public void testGetPMFNullStream() {
    364         PersistenceManagerFactory pmf = null;
    365         try {
    366             pmf = JDOHelper.getPersistenceManagerFactory((InputStream)null);
    367             fail("Null JNDI resource name should result in JDOFatalUserException");
    368         }
    369         catch (JDOFatalUserException ex) {
    370             if (verbose)
    371                 println("Caught expected exception " + ex);
    372         }
    373     }
    374
    375     /** Test null stream with good class loader.
    376      */
    377     public void testGetPMFNullStreamGoodClassLoader() {
    378         PersistenceManagerFactory pmf = null;
    379         try {
    380             pmf = JDOHelper.getPersistenceManagerFactory((InputStream)null, this.getClass().getClassLoader());
    381             fail("Null JNDI resource name should result in JDOFatalUserException");
    382         }
    383         catch (JDOFatalUserException ex) {
    384             if (verbose)
    385                 println("Caught expected exception " + ex);
    386         }
    387     }
    388
    389     /** Test null ClassLoader.
    390      */
    391     public void testGetPMFNullClassLoader() {
    392         PersistenceManagerFactory pmf = null;
    393         try {
    394             pmf = JDOHelper.getPersistenceManagerFactory
    395                     ("Whatever", (ClassLoader)null);
    396             fail("Null ClassLoader should result in JDOFatalUserException");
    397         }
    398         catch (JDOFatalUserException ex) {
    399             if (verbose)
    400                 println("Caught expected exception " + ex);
    401         }
    402     }
    403
    404     /** Test both null ClassLoaders.
    405      */
    406     public void testGetPMFBothNullClassLoader() {
    407         PersistenceManagerFactory pmf = null;
    408         try {
    409             pmf = JDOHelper.getPersistenceManagerFactory
    410                     ("Whatever", (ClassLoader)null, (ClassLoader)null);
    411             fail("Null ClassLoader should result in JDOFatalUserException");
    412         }
    413         catch (JDOFatalUserException ex) {
    414             if (verbose)
    415                 println("Caught expected exception " + ex);
    416         }
    417     }
    418
    419     /** Test missing property javax.jdo.PersistenceManagerFactoryClass.
    420      */
    421     public void testGetPMFNoClassNameProperty() {
    422         PersistenceManagerFactory pmf = null;
    423         try {
    424             pmf = JDOHelper.getPersistenceManagerFactory(new Properties());
    425             fail("Missing property PersistenceManagerFactoryClass should result in JDOFatalUserException ");
    426         }
    427         catch (JDOFatalUserException ex) {
    428             if (verbose)
    429                 println("Caught expected exception " + ex);
    430         }
    431     }
    432
    433     /** Test bad PMF class does not exist.
    434      */
    435     public void testBadPMFClassNotFound() {
    436         PersistenceManagerFactory pmf = null;
    437         Properties props = new Properties();
    438         props.put("javax.jdo.PersistenceManagerFactoryClass",
    439                 "ThisClassDoesNotExist");
    440         try {
    441             pmf = JDOHelper.getPersistenceManagerFactory(props);
    442             fail("Bad PersistenceManagerFactoryClass should result in JDOFatalUserException ");
    443         }
    444         catch (JDOFatalUserException ex) {
    445             if (verbose)
    446                 println("Caught expected exception " + ex);
    447         }
    448     }
    449
    450     /** Test bad PMF class no method getPersistenceManagerFactory(Properties).
    451      */
    452     public void testBadPMFNoGetPMFPropertiesMethod() {
    453         PersistenceManagerFactory pmf = null;
    454         Properties props = new Properties();
    455         props.put("javax.jdo.PersistenceManagerFactoryClass",
    456                 "javax.jdo.JDOHelperTest$BadPMFNoGetPMFMethod");
    457         try {
    458             pmf = JDOHelper.getPersistenceManagerFactory(props);
    459             fail("Bad PersistenceManagerFactory should result in JDOFatalInternalException ");
    460         }
    461         catch (JDOFatalInternalException ex) {
    462             if (ex.getCause() instanceof NoSuchMethodException) {
    463                 if (verbose)
    464                     println("Caught expected exception " + ex);
    465             } else {
    466                 fail("Bad PersistenceManagerFactory should result in " +
    467                         "JDOFatalInternalException with nested " +
    468                         "NoSuchMethodException. " +
    469                         "Actual nested exception was " + ex);
    470             }
    471         }
    472     }
    473
    474     /** Test bad PMF class no method getPersistenceManagerFactory(Map).
    475      */
    476     public void testBadPMFNoGetPMFMapMethod() {
    477         PersistenceManagerFactory pmf = null;
    478         Map<String,String> props = new HashMap<String,String>();
    479         props.put("javax.jdo.PersistenceManagerFactoryClass",
    480                 "javax.jdo.JDOHelperTest$BadPMFNoGetPMFMethod");
    481         try {
    482             pmf = JDOHelper.getPersistenceManagerFactory(props);
    483             fail("Bad PersistenceManagerFactory should result in JDOFatalInternalException ");
    484         }
    485         catch (JDOFatalInternalException ex) {
    486             if (ex.getCause() instanceof NoSuchMethodException) {
    487                 if (verbose)
    488                     println("Caught expected exception " + ex);
    489             } else {
    490                 fail("Bad PersistenceManagerFactory should result in " +
    491                         "JDOFatalInternalException with nested " +
    492                         "NoSuchMethodException. " +
    493                         "Actual nested exception was " + ex);
    494             }
    495         }
    496     }
    497
    498     /** Test bad PMF class non-static getPMF method.
    499      */
    500     public void testBadPMFNonStaticGetPMFMethod() {
    501         PersistenceManagerFactory pmf = null;
    502         Properties props = new Properties();
    503         props.put("javax.jdo.PersistenceManagerFactoryClass",
    504                 "javax.jdo.JDOHelperTest$BadPMFNonStaticGetPMFMethod");
    505         try {
    506             pmf = JDOHelper.getPersistenceManagerFactory(props);
    507             fail("Bad PersistenceManagerFactoryClass should result in JDOFatalInternalException ");
    508         }
    509         catch (JDOFatalInternalException ex) {
    510             if (verbose)
    511                 println("Caught expected exception " + ex);
    512         }
    513     }
    514
    515     /** Test bad PMF class doesn't implement PMF.
    516      */
    517     public void testBadPMFWrongReturnType() {
    518         PersistenceManagerFactory pmf = null;
    519         Properties props = new Properties();
    520         props.put("javax.jdo.PersistenceManagerFactoryClass",
    521                 "javax.jdo.JDOHelperTest$BadPMFWrongReturnType");
    522         try {
    523             pmf = JDOHelper.getPersistenceManagerFactory(props);
    524             fail("Bad PersistenceManagerFactoryClass should result in JDOFatalInternalException ");
    525         }
    526         catch (JDOFatalInternalException ex) {
    527             if (verbose)
    528                 println("Caught expected exception " + ex);
    529         }
    530     }
    531
    532     /** Test bad PMF class getPersistenceManagerFactory throws Exception.
    533      */
    534     public void testBadPMFGetPMFMethodThrowsJDOException() {
    535         PersistenceManagerFactory pmf = null;
    536         Properties props = new Properties();
    537         props.put("javax.jdo.PersistenceManagerFactoryClass",
    538                 "javax.jdo.JDOHelperTest$BadPMFGetPMFMethodThrowsJDOException");
    539         try {
    540             pmf = JDOHelper.getPersistenceManagerFactory(props);
    541             fail("BadPMFGetPMFMethodThrowsJDOException.GetPersistenceManagerFactory " +
    542                     "should result in JDOUnsupportedOptionException. " +
    543                     "No exception was thrown.");
    544         }
    545         catch (JDOUnsupportedOptionException ex) {
    546             if (verbose)
    547                 println("Caught expected exception " + ex);
    548         }
    549     }
    550
    551     /** Test bad PMF class getPersistenceManagerFactory returns null.
    552      */
    553     public void testBadPMFGetPMFMethodReturnsNull() {
    554         PersistenceManagerFactory pmf = null;
    555         Properties props = new Properties();
    556         props.put("javax.jdo.PersistenceManagerFactoryClass",
    557                 "javax.jdo.JDOHelperTest$BadPMFGetPMFMethodReturnsNull");
    558         try {
    559             pmf = JDOHelper.getPersistenceManagerFactory(props);
    560             fail("BadPMFGetPMFMethodReturnsNull.GetPersistenceManagerFactory " +
    561                     "should result in JDOFatalInternalException. " +
    562                     "No exception was thrown.");
    563         }
    564         catch (JDOFatalInternalException ex) {
    565             if (verbose)
    566                 println("Caught expected exception " + ex);
    567         }
    568     }
    569
    570     private Context getInitialContext() {
    571         try {
    572             return new InitialContext();
    573         } catch (NamingException ne) {
    574             fail("Could not get Initial Context");
    575             return null;
    576         }
    577     }
    578
    579     public static class BadPMFNoGetPMFMethod {
    580     }
    581
    582     public static class BadPMFNonStaticGetPMFMethod {
    583         public PersistenceManagerFactory
    584                 getPersistenceManagerFactory(Map props) {
    585             return null;
    586         }
    587     }
    588
    589     public static class BadPMFWrongReturnType {
    590         public static BadPMFWrongReturnType
    591                 getPersistenceManagerFactory(Map props) {
    592             return new BadPMFWrongReturnType();
    593         }
    594     }
    595
    596     public static class BadPMFGetPMFMethodThrowsJDOException {
    597         public static PersistenceManagerFactory
    598                 getPersistenceManagerFactory(Map props) {
    599             throw new JDOUnsupportedOptionException(
    600                     "GetPMF method throws JDOUnsupportedOptionException");
    601         }
    602     }
    603
    604     public static class BadPMFGetPMFMethodThrowsJDOFatalInternalException {
    605         public static PersistenceManagerFactory
    606                 getPersistenceManagerFactory(Map props) {
    607             throw new JDOFatalInternalException(
    608                     "GetPMF method throws JDOFatalInternalException");
    609         }
    610     }
    611
    612     public static class BadPMFGetPMFMethodReturnsNull {
    613         public static PersistenceManagerFactory
    614                 getPersistenceManagerFactory(Map props) {
    615             return null;
    616         }
    617     }
    618 }