KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > net > sf > hajdbc > sql > TestDriverDatabase


1 /*
2  * HA-JDBC: High-Availability JDBC
3  * Copyright (c) 2004-2006 Paul Ferraro
4  *
5  * This library is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU Lesser General Public License as published by the
7  * Free Software Foundation; either version 2.1 of the License, or (at your
8  * option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
13  * for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with this library; if not, write to the Free Software Foundation,
17  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  *
19  * Contact: ferraro@users.sourceforge.net
20  */

21 package net.sf.hajdbc.sql;
22
23 import java.sql.Connection JavaDoc;
24 import java.sql.Driver JavaDoc;
25 import java.sql.DriverManager JavaDoc;
26 import java.sql.SQLException JavaDoc;
27 import java.util.Properties JavaDoc;
28
29 import net.sf.hajdbc.Database;
30
31 import org.easymock.EasyMock;
32 import org.testng.annotations.BeforeClass;
33 import org.testng.annotations.Test;
34
35
36 /**
37  * Unit test for {@link DriverDatabase}
38  * @author Paul Ferraro
39  * @since 1.0
40  */

41 @Test
42 public class TestDriverDatabase extends AbstractTestDatabase
43 {
44     private Driver driver = this.control.createMock(Driver.class);
45     
46     @BeforeClass
47     protected void setup()
48     {
49         try
50         {
51             DriverManager.registerDriver(this.driver);
52         }
53         catch (SQLException JavaDoc e)
54         {
55             assert false : e;;
56         }
57     }
58     
59     protected Database createDatabase(String JavaDoc id)
60     {
61         DriverDatabase database = new DriverDatabase();
62         
63         database.setId(id);
64         
65         return database;
66     }
67     
68     private void setUrl(DriverDatabase database, String JavaDoc url, boolean accepted)
69     {
70         try
71         {
72             EasyMock.expect(this.driver.acceptsURL(url)).andReturn(accepted);
73             
74             this.control.replay();
75             
76             database.setUrl(url);
77
78             this.control.verify();
79         }
80         catch (SQLException JavaDoc e)
81         {
82             assert false : e;
83         }
84         finally
85         {
86             this.control.reset();
87         }
88     }
89     
90     private void setUrl(DriverDatabase database, String JavaDoc url)
91     {
92         this.setUrl(database, url, true);
93     }
94     
95     /**
96      * Test method for {@link DriverDatabase#connect(Driver)}
97      */

98     public void testConnect()
99     {
100         Connection connection = EasyMock.createMock(Connection.class);
101
102         DriverDatabase database = new DriverDatabase();
103         String JavaDoc url = "jdbc:test";
104         
105         this.setUrl(database, url);
106         
107         try
108         {
109             EasyMock.expect(this.driver.connect(url, new Properties JavaDoc())).andReturn(connection);
110             
111             this.control.replay();
112             
113             Connection conn = database.connect(this.driver);
114             
115             this.control.verify();
116             
117             assert connection == conn;
118         }
119         catch (SQLException JavaDoc e)
120         {
121             assert false : e;
122         }
123     }
124     
125     /**
126      * Test method for {@link DriverDatabase#connect(Driver)}
127      */

128     public void testConnectWithAuthentication()
129     {
130         Connection connection = EasyMock.createMock(Connection.class);
131
132         DriverDatabase database = new DriverDatabase();
133         String JavaDoc url = "jdbc:test";
134         
135         this.setUrl(database, url);
136         
137         database.setUser("user");
138         database.setPassword("password");
139         
140         Properties JavaDoc properties = new Properties JavaDoc();
141         properties.setProperty("user", database.getUser());
142         properties.setProperty("password", database.getPassword());
143
144         try
145         {
146             EasyMock.expect(this.driver.connect(url, properties)).andReturn(connection);
147             
148             this.control.replay();
149             
150             Connection conn = database.connect(this.driver);
151             
152             this.control.verify();
153             
154             assert connection == conn;
155         }
156         catch (SQLException JavaDoc e)
157         {
158             assert false : e;
159         }
160     }
161
162     /**
163      * Test method for {@link DriverDatabase#connect(Driver)}
164      */

165     public void testUnacceptedConnect()
166     {
167         DriverDatabase database = new DriverDatabase();
168         String JavaDoc url = "jdbc:test";
169         
170         this.setUrl(database, url);
171         
172         try
173         {
174             EasyMock.expect(this.driver.connect(url, new Properties JavaDoc())).andReturn(null);
175             
176             this.control.replay();
177             
178             Connection connection = database.connect(this.driver);
179             
180             this.control.verify();
181             
182             assert connection == null;
183         }
184         catch (SQLException JavaDoc e)
185         {
186             assert false : e;
187         }
188     }
189     
190     /**
191      * Test method for {@link DriverDatabase#createConnectionFactory()}
192      */

193     public void testCreateConnectionFactory()
194     {
195         DriverDatabase database = new DriverDatabase();
196         String JavaDoc url = "jdbc:test";
197         
198         this.setUrl(database, url);
199         
200         try
201         {
202             EasyMock.expect(this.driver.acceptsURL(url)).andReturn(true);
203             
204             this.control.replay();
205             
206             Driver driver = database.createConnectionFactory();
207             
208             this.control.verify();
209             
210             assert this.driver == driver;
211         }
212         catch (SQLException JavaDoc e)
213         {
214             assert false : e;
215         }
216     }
217     
218     /**
219      * Test method for {@link DriverDatabase#setUrl(String)}
220      */

221     public void testSetUrl()
222     {
223         DriverDatabase database = new DriverDatabase();
224         
225         assert !database.isDirty();
226
227         try
228         {
229             this.setUrl(database, "bad", false);
230             
231             assert false;
232         }
233         catch (IllegalArgumentException JavaDoc e)
234         {
235             assert true;
236         }
237         
238         assert !database.isDirty();
239         
240         this.setUrl(database, "good");
241         
242         assert database.isDirty();
243
244         this.setUrl(database, "test");
245         
246         assert database.isDirty();
247
248         database.clean();
249         
250         assert !database.isDirty();
251         
252         this.setUrl(database, "different");
253         
254         assert database.isDirty();
255     }
256     
257     /**
258      * Test method for {@link DriverDatabase#setDriver(String)}
259      */

260     public void testSetDriver()
261     {
262         DriverDatabase database = new DriverDatabase();
263         
264         assert !database.isDirty();
265         
266         database.setDriver(null);
267         
268         assert !database.isDirty();
269         
270         database.setDriver("");
271         
272         assert database.getDriver() == null : database.getDriver();
273         assert !database.isDirty();
274
275         database.setDriver("net.sf.hajdbc.sql.MockDriver");
276         
277         assert database.isDirty();
278
279         database.setDriver("net.sf.hajdbc.sql.MockDriver");
280         
281         assert database.isDirty();
282
283         database.clean();
284         
285         assert !database.isDirty();
286         
287         database.setDriver(null);
288         
289         assert database.isDirty();
290         
291         database.setDriver("net.sf.hajdbc.sql.MockDriver");
292         
293         assert database.isDirty();
294         
295         database.clean();
296         
297         assert !database.isDirty();
298         
299         database.setDriver("java.sql.Driver");
300         
301         assert database.isDirty();
302         
303         try
304         {
305             database.setDriver("java.lang.Class");
306             
307             assert false;
308         }
309         catch (IllegalArgumentException JavaDoc e)
310         {
311             assert true;
312         }
313         
314         try
315         {
316             database.setDriver("not.a.valid.Class");
317             
318             assert false;
319         }
320         catch (IllegalArgumentException JavaDoc e)
321         {
322             assert true;
323         }
324     }
325 }
326
Popular Tags