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 */
23package test.rowset.spi;
24
25import com.sun.rowset.providers.RIOptimisticProvider;
26import java.util.ArrayList;
27import java.util.Arrays;
28import java.util.Enumeration;
29import java.util.List;
30import java.util.logging.Level;
31import java.util.logging.Logger;
32import javax.naming.Context;
33import javax.sql.rowset.spi.SyncFactory;
34import javax.sql.rowset.spi.SyncFactoryException;
35import javax.sql.rowset.spi.SyncProvider;
36import static org.testng.Assert.*;
37import org.testng.annotations.BeforeMethod;
38import org.testng.annotations.Test;
39import util.PropertyStubProvider;
40import util.StubSyncProvider;
41import util.StubContext;
42
43//com.sun.jndi.ldap.LdapCtxFactory
44public 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}
221