1 /*
   2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package test.rowset.spi;
  24 
  25 import com.sun.rowset.providers.RIOptimisticProvider;
  26 import java.util.ArrayList;
  27 import java.util.Arrays;
  28 import java.util.Enumeration;
  29 import java.util.List;
  30 import java.util.logging.Level;
  31 import java.util.logging.Logger;
  32 import javax.naming.Context;
  33 import javax.sql.rowset.spi.SyncFactory;
  34 import javax.sql.rowset.spi.SyncFactoryException;
  35 import javax.sql.rowset.spi.SyncProvider;
  36 import static org.testng.Assert.*;
  37 import org.testng.annotations.BeforeMethod;
  38 import org.testng.annotations.Test;
  39 import util.PropertyStubProvider;
  40 import util.StubSyncProvider;
  41 import util.StubContext;
  42 
  43 //com.sun.jndi.ldap.LdapCtxFactory
  44 public class SyncFactoryTests {
  45     private static String origFactory;
  46 
  47     private final String stubProvider = "util.StubSyncProvider";
  48     private final String propertyStubProvider = "util.PropertyStubProvider";
  49     private final Logger alogger = Logger.getLogger(this.getClass().getName());
  50     // Initial providers including those set via a property
  51     List<String> initialProviders;
  52     // All providers including those specifically registered
  53     List<String> allProviders;
  54     private  Context ctx= null;
  55 
  56     public SyncFactoryTests() {
  57 
  58         // Add a provider via a property
  59         System.setProperty("rowset.provider.classname", propertyStubProvider);
  60         initialProviders = Arrays.asList(
  61                 "com.sun.rowset.providers.RIOptimisticProvider",
  62                 "com.sun.rowset.providers.RIXMLProvider",
  63                 propertyStubProvider);
  64         allProviders = new ArrayList<>();
  65         allProviders.addAll(initialProviders);
  66         allProviders.add(stubProvider);
  67         ctx = new StubContext();
  68     }
  69 
  70     @BeforeMethod
  71     public void setUpMethod() throws Exception {
  72         // Make sure the provider provider that is registered is removed
  73         // before each run
  74         SyncFactory.unregisterProvider(stubProvider);
  75     }
  76 
  77     /*
  78      * Validate a non-null factory is returned
  79      */
  80     @Test
  81     public void test() throws SyncFactoryException {
  82         SyncFactory syncFactory = SyncFactory.getSyncFactory();
  83         assertTrue(syncFactory != null);
  84     }
  85 
  86     /*
  87      * Check that the correct SyncProvider is returned for the specified
  88      * providerID for the provider registered via a property
  89      */
  90     @Test
  91     public void test00() throws SyncFactoryException {
  92         SyncProvider p = SyncFactory.getInstance(propertyStubProvider);
  93         assertTrue(p instanceof PropertyStubProvider);
  94     }
  95 
  96     /*
  97      * Check that the correct SyncProvider is returned for the specified
  98      * providerID
  99      */
 100     @Test
 101     public void test01() throws SyncFactoryException {
 102         SyncFactory.registerProvider(stubProvider);
 103         SyncProvider p = SyncFactory.getInstance(stubProvider);
 104         assertTrue(p instanceof StubSyncProvider);
 105     }
 106 
 107     /*
 108      * Check that the Default SyncProvider is returned if an empty String is
 109      * passed or if an invalid providerID is specified
 110      */
 111     @Test
 112     public void test02() throws SyncFactoryException {
 113         SyncProvider p = SyncFactory.getInstance("");
 114         assertTrue(p instanceof RIOptimisticProvider);
 115         // Attempt to get an invalid provider and get the default provider
 116         p = SyncFactory.getInstance("util.InvalidSyncProvider");
 117         assertTrue(p instanceof RIOptimisticProvider);
 118     }
 119 
 120     /*
 121      * Validate that a SyncFactoryException is thrown if the ProviderID is null
 122      */
 123     @Test(expectedExceptions = SyncFactoryException.class)
 124     public void test03() throws SyncFactoryException {
 125         SyncProvider p = SyncFactory.getInstance(null);
 126     }
 127 
 128     /*
 129      * Validate that a SyncFactoryException is thrown if the Logger is null
 130      */
 131     @Test(expectedExceptions = SyncFactoryException.class,enabled=true)
 132     public void test04() throws SyncFactoryException {
 133         Logger l = SyncFactory.getLogger();
 134     }
 135 
 136     /*
 137      * Validate that the correct logger is returned by getLogger
 138      */
 139     @Test
 140     public void test05() throws SyncFactoryException {
 141         SyncFactory.setLogger(alogger);
 142         Logger l = SyncFactory.getLogger();
 143         assertTrue(l.equals(alogger));
 144     }
 145 
 146     /*
 147      * Validate that the correct logger is returned by getLogger
 148      */
 149     @Test
 150     public void test06() throws SyncFactoryException {
 151         SyncFactory.setLogger(alogger, Level.INFO);
 152         Logger l = SyncFactory.getLogger();
 153         assertTrue(l.equals(alogger));
 154     }
 155 
 156     /*
 157      *  Validate that a driver that is registered is returned by
 158      * getRegisteredProviders and  if it is unregistered, that it is
 159      * not returned by getRegisteredProviders
 160      */
 161     @Test
 162     public void test07() throws SyncFactoryException {
 163 
 164         // Validate that only the default providers and any specified via
 165         // a System property are available
 166         validateProviders(initialProviders);
 167 
 168         // Register a provider and make sure it is avaiable
 169         SyncFactory.registerProvider(stubProvider);
 170         validateProviders(allProviders);
 171 
 172         // Check that if a provider is unregistered, it does not show as
 173         // registered
 174         SyncFactory.unregisterProvider(stubProvider);
 175         validateProviders(initialProviders);
 176     }
 177 
 178     /*
 179      * Validate that setJNDIContext throws a SyncFactoryException if the
 180      * context is null
 181      */
 182     @Test(expectedExceptions = SyncFactoryException.class, enabled=true)
 183     public void test08() throws Exception {
 184         SyncFactory.setJNDIContext(null);
 185     }
 186 
 187     /*
 188      * Validate that setJNDIContext succeeds
 189      */
 190     @Test(enabled=true)
 191     public void test09() throws Exception {
 192         SyncFactory.setJNDIContext(ctx);
 193     }
 194 
 195     /*
 196      * Utility method to validate the expected providers are regsitered
 197      */
 198     private void validateProviders(List<String> expectedProviders)
 199             throws SyncFactoryException {
 200         List<String> results = new ArrayList<>();
 201         Enumeration<SyncProvider> providers = SyncFactory.getRegisteredProviders();
 202 
 203         while (providers.hasMoreElements()) {
 204             SyncProvider p = providers.nextElement();
 205             results.add(p.getProviderID());
 206         }
 207         assertTrue(expectedProviders.containsAll(results)
 208                 && results.size() == expectedProviders.size());
 209     }
 210 
 211     /*
 212      * Utility method to dump out SyncProvider info for a registered provider
 213      */
 214     private void showImpl(SyncProvider impl) {
 215         System.out.println("Provider implementation:"
 216                 + "\nVendor: " + impl.getVendor()
 217                 + "\nVersion: " + impl.getVersion()
 218                 + "\nProviderID: " + impl.getProviderID());
 219     }
 220 }