|
1
21 package net.sf.hajdbc.sql;
22
23 import java.sql.DatabaseMetaData  ;
24 import java.sql.ResultSet ;
25 import java.sql.SQLException ;
26 import java.sql.SQLWarning ;
27 import java.util.Collections ;
28 import java.util.List ;
29 import java.util.Map ;
30 import java.util.concurrent.ExecutorService ;
31 import java.util.concurrent.Executors ;
32 import java.util.concurrent.locks.Lock ;
33
34 import net.sf.hajdbc.Balancer;
35 import net.sf.hajdbc.Database;
36 import net.sf.hajdbc.DatabaseCluster;
37 import net.sf.hajdbc.Dialect;
38 import net.sf.hajdbc.MockDatabase;
39 import net.sf.hajdbc.Operation;
40
41 import org.easymock.EasyMock;
42 import org.easymock.IMocksControl;
43 import org.testng.annotations.AfterMethod;
44 import org.testng.annotations.BeforeClass;
45 import org.testng.annotations.Test;
46
47
52 @Test
53 public class TestStatement
54 {
55 protected IMocksControl control = EasyMock.createStrictControl();
56
57 protected DatabaseCluster databaseCluster = this.control.createMock(DatabaseCluster.class);
58
59 protected java.sql.Connection sqlConnection = this.control.createMock(java.sql.Connection .class);
60
61 protected java.sql.Statement sqlStatement = this.control.createMock(this.getStatementClass());
62
63 protected Database database = new MockDatabase();
64
65 protected Balancer balancer = this.control.createMock(Balancer.class);
66
67 protected FileSupport fileSupport = this.control.createMock(FileSupport.class);
68
69 protected Lock lock = this.control.createMock(Lock .class);
70
71 protected Dialect dialect = this.control.createMock(Dialect.class);
72
73 protected Connection connection;
74 protected Statement statement;
75 protected List <Database> databaseList = Collections.singletonList(this.database);
76 protected ExecutorService executor = Executors.newSingleThreadExecutor();
77
78 protected Class <? extends java.sql.Statement > getStatementClass()
79 {
80 return java.sql.Statement .class;
81 }
82
83 @BeforeClass
84 protected void setUp() throws Exception
85 {
86 Map map = Collections.singletonMap(this.database, new Object ());
87
88 EasyMock.expect(this.databaseCluster.getConnectionFactoryMap()).andReturn(map);
89
90 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
91 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
92 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
93
94 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
95 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
96 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
97
98 this.control.replay();
99
100 ConnectionFactory<Object > connectionFactory = new ConnectionFactory<Object >(this.databaseCluster, Object .class);
101
102 Operation<Object , java.sql.Connection > operation = new Operation<Object , java.sql.Connection >()
103 {
104 public java.sql.Connection execute(Database database, Object object) throws SQLException
105 {
106 return TestStatement.this.sqlConnection;
107 }
108 };
109
110 this.connection = new Connection(connectionFactory, operation, this.fileSupport);
111
112 this.statement = this.createStatement(this.connection);
113
114 this.control.verify();
115 this.control.reset();
116 }
117
118 @AfterMethod
119 public void reset()
120 {
121 this.control.reset();
122 }
123
124 protected Statement createStatement(Connection connection) throws SQLException
125 {
126 Operation<java.sql.Connection , java.sql.Statement > operation = new Operation<java.sql.Connection , java.sql.Statement >()
127 {
128 public java.sql.Statement execute(Database database, java.sql.Connection connection) throws SQLException
129 {
130 return TestStatement.this.sqlStatement;
131 }
132 };
133
134 return new Statement(connection, operation);
135 }
136
137
140 public void testGetObject()
141 {
142 this.control.replay();
143
144 Object statement = this.statement.getObject(this.database);
145
146 this.control.verify();
147
148 assert this.sqlStatement == statement;
149 }
150
151
154 public void testGetDatabaseCluster()
155 {
156 this.control.replay();
157
158 DatabaseCluster databaseCluster = this.statement.getDatabaseCluster();
159
160 this.control.verify();
161
162 assert this.databaseCluster == databaseCluster;
163 }
164
165
168 public void testHandleException()
169 {
170 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
171 EasyMock.expect(this.balancer.first()).andReturn(this.database);
172
173 try
174 {
175 EasyMock.expect(this.sqlConnection.getAutoCommit()).andReturn(true);
176
177 EasyMock.expect(this.databaseCluster.deactivate(this.database)).andReturn(false);
178
179 this.control.replay();
180
181 this.statement.handleExceptions(Collections.singletonMap(this.database, new SQLException ()));
182
183 this.control.verify();
184 }
185 catch (SQLException e)
186 {
187 assert false : e;
188 }
189 }
190
191
194 public void testAutoCommitOffHandleException()
195 {
196 SQLException exception = new SQLException ();
197
198 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
199 EasyMock.expect(this.balancer.first()).andReturn(this.database);
200
201 try
202 {
203 EasyMock.expect(this.sqlConnection.getAutoCommit()).andReturn(false);
204
205 this.databaseCluster.handleFailure(this.database, exception);
206
207 this.control.replay();
208
209 this.statement.handleExceptions(Collections.singletonMap(this.database, exception));
210
211 this.control.verify();
212 }
213 catch (SQLException e)
214 {
215 assert false : e;
216 }
217 }
218
219
222 public void testAddBatch()
223 {
224 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
225
226 this.lock.lock();
227
228 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
229 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
230
231 try
232 {
233 this.sqlStatement.addBatch("test");
234
235 this.lock.unlock();
236
237 this.control.replay();
238
239 this.statement.addBatch("test");
240
241 this.control.verify();
242 }
243 catch (SQLException e)
244 {
245 assert false : e;
246 }
247 }
248
249
252 public void testCancel()
253 {
254 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
255
256 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
257 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
258
259 try
260 {
261 this.sqlStatement.cancel();
262
263 this.control.replay();
264
265 this.statement.cancel();
266
267 this.control.verify();
268 }
269 catch (SQLException e)
270 {
271 assert false : e;
272 }
273 }
274
275
278 public void testClearBatch()
279 {
280 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
281
282 this.lock.lock();
283
284 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
285 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
286
287 try
288 {
289 this.sqlStatement.clearBatch();
290
291 this.lock.unlock();
292
293 this.control.replay();
294
295 this.statement.clearBatch();
296
297 this.control.verify();
298 }
299 catch (SQLException e)
300 {
301 assert false : e;
302 }
303 }
304
305
308 public void testClearWarnings()
309 {
310 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
311
312 this.lock.lock();
313
314 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
315 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
316
317 try
318 {
319 this.sqlStatement.clearWarnings();
320
321 this.lock.unlock();
322
323 this.control.replay();
324
325 this.statement.clearWarnings();
326
327 this.control.verify();
328 }
329 catch (SQLException e)
330 {
331 assert false : e;
332 }
333 }
334
335
338 public void testClose()
339 {
340 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
341
342 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
343 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
344
345 try
346 {
347 this.sqlStatement.close();
348
349 this.control.replay();
350
351 this.statement.close();
352
353 this.control.verify();
354 }
355 catch (SQLException e)
356 {
357 assert false : e;
358 }
359 }
360
361
364 public void testExecuteString()
365 {
366 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
367 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
368
369 this.lock.lock();
370
371 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
372 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
373
374 try
375 {
376 EasyMock.expect(this.sqlStatement.execute("test")).andReturn(true);
377
378 this.lock.unlock();
379
380 this.control.replay();
381
382 boolean results = this.statement.execute("test");
383
384 this.control.verify();
385
386 assert results;
387 }
388 catch (SQLException e)
389 {
390 assert false : e;
391 }
392 }
393
394
397 public void testExecuteStringInt()
398 {
399 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
400 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
401
402 this.lock.lock();
403
404 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
405 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
406
407 try
408 {
409 EasyMock.expect(this.sqlStatement.execute("SELECT ME", 1)).andReturn(true);
410
411 this.lock.unlock();
412
413 this.control.replay();
414
415 boolean results = this.statement.execute("SELECT ME", 1);
416
417 this.control.verify();
418
419 assert results;
420 }
421 catch (SQLException e)
422 {
423 assert false : e;
424 }
425 }
426
427
430 public void testExecuteStringIntArray()
431 {
432 int[] columns = new int[] { 0 };
433
434 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
435 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
436
437 this.lock.lock();
438
439 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
440 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
441
442 try
443 {
444 EasyMock.expect(this.sqlStatement.execute("SELECT ME", columns)).andReturn(true);
445
446 this.lock.unlock();
447
448 this.control.replay();
449
450 boolean results = this.statement.execute("SELECT ME", columns);
451
452 this.control.verify();
453
454 assert results;
455 }
456 catch (SQLException e)
457 {
458 e.printStackTrace();
459 assert false : e;
460 }
461 }
462
463
466 public void testExecuteStringStringArray()
467 {
468 String [] columns = new String [] { "column" };
469
470 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
471 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
472
473 this.lock.lock();
474
475 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
476 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
477
478 try
479 {
480 EasyMock.expect(this.sqlStatement.execute("SELECT ME", columns)).andReturn(true);
481
482 this.lock.unlock();
483
484 this.control.replay();
485
486 boolean results = this.statement.execute("SELECT ME", columns);
487
488 this.control.verify();
489
490 assert results;
491 }
492 catch (SQLException e)
493 {
494 assert false : e;
495 }
496 }
497
498
501 public void testExecuteBatch()
502 {
503 int[] rows = new int[] { 100 };
504
505 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
506 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
507
508 this.lock.lock();
509
510 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
511 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
512
513 try
514 {
515 EasyMock.expect(this.sqlStatement.executeBatch()).andReturn(rows);
516
517 this.lock.unlock();
518
519 this.control.replay();
520
521 int[] results = this.statement.executeBatch();
522
523 this.control.verify();
524
525 assert rows == results;
526 }
527 catch (SQLException e)
528 {
529 assert false : e;
530 }
531 }
532
533
536 public void testExecuteQuery()
537 {
538 ResultSet resultSet = EasyMock.createMock(ResultSet.class);
539 DatabaseMetaData metaData = EasyMock.createMock(DatabaseMetaData .class);
540
541 String sql = "SELECT ME";
542
543 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
544 EasyMock.expect(this.balancer.first()).andReturn(this.database);
545
546 try
547 {
548 EasyMock.expect(this.sqlStatement.getResultSetConcurrency()).andReturn(ResultSet.CONCUR_READ_ONLY);
549
550 EasyMock.expect(this.databaseCluster.getDialect()).andReturn(this.dialect);
551 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
552 EasyMock.expect(this.balancer.next()).andReturn(this.database);
553
554 this.balancer.beforeOperation(this.database);
555
556 EasyMock.expect(this.sqlConnection.getMetaData()).andReturn(metaData);
557
558 this.balancer.afterOperation(this.database);
559
560 EasyMock.expect(this.dialect.isSelectForUpdate(metaData, sql)).andReturn(false);
561
562 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
563 EasyMock.expect(this.balancer.next()).andReturn(this.database);
564
565 this.balancer.beforeOperation(this.database);
566
567 EasyMock.expect(this.sqlStatement.executeQuery(sql)).andReturn(resultSet);
568
569 this.balancer.afterOperation(this.database);
570
571 this.control.replay();
572
573 ResultSet rs = this.statement.executeQuery(sql);
574
575 this.control.verify();
576
577 assert resultSet == rs;
578 }
579 catch (SQLException e)
580 {
581 assert false : e;
582 }
583 }
584
585
588 public void testUpdatableExecuteQuery()
589 {
590 ResultSet resultSet = EasyMock.createMock(ResultSet.class);
591
592 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
593 EasyMock.expect(this.balancer.first()).andReturn(this.database);
594
595 try
596 {
597 EasyMock.expect(this.sqlStatement.getResultSetConcurrency()).andReturn(ResultSet.CONCUR_UPDATABLE);
598
599 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
600 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
601
602 this.lock.lock();
603
604 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
605 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
606
607 EasyMock.expect(this.sqlStatement.executeQuery("SELECT ME")).andReturn(resultSet);
608
609 this.lock.unlock();
610
611 this.control.replay();
612
613 ResultSet rs = this.statement.executeQuery("SELECT ME");
614
615 this.control.verify();
616
617 assert net.sf.hajdbc.sql.ResultSet.class.cast(rs).getObject(this.database) == resultSet;
618 }
619 catch (SQLException e)
620 {
621 assert false : e;
622 }
623 }
624
625
628 public void testSelectForUpdateExecuteQuery()
629 {
630 ResultSet resultSet = EasyMock.createMock(ResultSet.class);
631 DatabaseMetaData metaData = EasyMock.createMock(DatabaseMetaData .class);
632
633 String sql = "SELECT ME FOR UPDATE";
634
635 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
636 EasyMock.expect(this.balancer.first()).andReturn(this.database);
637
638 try
639 {
640 EasyMock.expect(this.sqlStatement.getResultSetConcurrency()).andReturn(ResultSet.CONCUR_READ_ONLY);
641
642 EasyMock.expect(this.databaseCluster.getDialect()).andReturn(this.dialect);
643 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
644 EasyMock.expect(this.balancer.next()).andReturn(this.database);
645
646 this.balancer.beforeOperation(this.database);
647
648 EasyMock.expect(this.sqlConnection.getMetaData()).andReturn(metaData);
649
650 this.balancer.afterOperation(this.database);
651
652 EasyMock.expect(this.dialect.isSelectForUpdate(metaData, sql)).andReturn(true);
653
654 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
655 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
656
657 this.lock.lock();
658
659 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
660 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
661
662 EasyMock.expect(this.sqlStatement.executeQuery(sql)).andReturn(resultSet);
663
664 this.lock.unlock();
665
666 this.control.replay();
667
668 ResultSet rs = this.statement.executeQuery(sql);
669
670 this.control.verify();
671
672 assert net.sf.hajdbc.sql.ResultSet.class.cast(rs).getObject(this.database) == resultSet;
673 }
674 catch (SQLException e)
675 {
676 assert false : e;
677 }
678 }
679
680
683 public void testExecuteUpdateString()
684 {
685 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
686 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
687
688 this.lock.lock();
689
690 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
691 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
692
693 try
694 {
695 EasyMock.expect(this.sqlStatement.executeUpdate("INSERT ME")).andReturn(1);
696
697 this.lock.unlock();
698
699 this.control.replay();
700
701 int result = this.statement.executeUpdate("INSERT ME");
702
703 this.control.verify();
704
705 assert result == 1 : result;
706 }
707 catch (SQLException e)
708 {
709 assert false : e;
710 }
711 }
712
713
716 public void testExecuteUpdateStringInt()
717 {
718 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
719 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
720
721 this.lock.lock();
722
723 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
724 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
725
726 try
727 {
728 EasyMock.expect(this.sqlStatement.executeUpdate("INSERT INTO my_table (my_col) VALUES (}my_value})", 1)).andReturn(1);
729
730 this.lock.unlock();
731
732 this.control.replay();
733
734 int result = this.statement.executeUpdate("INSERT INTO my_table (my_col) VALUES (}my_value})", 1);
735
736 this.control.verify();
737
738 assert result == 1 : result;
739 }
740 catch (SQLException e)
741 {
742 assert false : e;
743 }
744 }
745
746
749 public void testExecuteUpdateStringIntArray()
750 {
751 int[] columns = new int[] { 0 };
752
753 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
754 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
755
756 this.lock.lock();
757
758 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
759 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
760
761 try
762 {
763 EasyMock.expect(this.sqlStatement.executeUpdate("INSERT INTO my_table (my_col) VALUES (}my_value})", columns)).andReturn(1);
764
765 this.lock.unlock();
766
767 this.control.replay();
768
769 int result = this.statement.executeUpdate("INSERT INTO my_table (my_col) VALUES (}my_value})", columns);
770
771 this.control.verify();
772
773 assert result == 1 : result;
774 }
775 catch (SQLException e)
776 {
777 assert false : e;
778 }
779 }
780
781
784 public void testExecuteUpdateStringStringArray()
785 {
786 String [] columns = new String [] { "column" };
787
788 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
789 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
790
791 this.lock.lock();
792
793 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
794 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
795
796 try
797 {
798 EasyMock.expect(this.sqlStatement.executeUpdate("INSERT INTO my_table (my_col) VALUES (}my_value})", columns)).andReturn(1);
799
800 this.lock.unlock();
801
802 this.control.replay();
803
804 int result = this.statement.executeUpdate("INSERT INTO my_table (my_col) VALUES (}my_value})", columns);
805
806 this.control.verify();
807
808 assert result == 1 : result;
809 }
810 catch (SQLException e)
811 {
812 assert false : e;
813 }
814 }
815
816
819 public void testGetConnection()
820 {
821 java.sql.Connection connection = this.statement.getConnection();
822
823 assert this.connection == connection;
824 }
825
826
829 public void testGetFetchDirection()
830 {
831 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
832 EasyMock.expect(this.balancer.first()).andReturn(this.database);
833
834 try
835 {
836 EasyMock.expect(this.sqlStatement.getFetchDirection()).andReturn(ResultSet.FETCH_REVERSE);
837
838 this.control.replay();
839
840 int direction = this.statement.getFetchDirection();
841
842 this.control.verify();
843
844 assert direction == ResultSet.FETCH_REVERSE : direction;
845 }
846 catch (SQLException e)
847 {
848 assert false : e;
849 }
850 }
851
852
855 public void testGetFetchSize()
856 {
857 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
858 EasyMock.expect(this.balancer.first()).andReturn(this.database);
859
860 try
861 {
862 EasyMock.expect(this.sqlStatement.getFetchSize()).andReturn(100);
863
864 this.control.replay();
865
866 int size = this.statement.getFetchSize();
867
868 this.control.verify();
869
870 assert size == 100 : size;
871 }
872 catch (SQLException e)
873 {
874 assert false : e;
875 }
876 }
877
878
881 public void testGetGeneratedKeys()
882 {
883 ResultSet resultSet = EasyMock.createMock(ResultSet.class);
884
885 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
886 EasyMock.expect(this.balancer.first()).andReturn(this.database);
887
888 try
889 {
890 EasyMock.expect(this.sqlStatement.getGeneratedKeys()).andReturn(resultSet);
891
892 this.control.replay();
893
894 ResultSet rs = this.statement.getGeneratedKeys();
895
896 this.control.verify();
897
898 assert rs == resultSet;
899 }
900 catch (SQLException e)
901 {
902 assert false : e;
903 }
904 }
905
906
909 public void testGetMaxFieldSize()
910 {
911 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
912 EasyMock.expect(this.balancer.first()).andReturn(this.database);
913
914 try
915 {
916 EasyMock.expect(this.sqlStatement.getMaxFieldSize()).andReturn(100);
917
918 this.control.replay();
919
920 int size = this.statement.getMaxFieldSize();
921
922 this.control.verify();
923
924 assert size == 100 : size;
925 }
926 catch (SQLException e)
927 {
928 assert false : e;
929 }
930 }
931
932
935 public void testGetMaxRows()
936 {
937 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
938 EasyMock.expect(this.balancer.first()).andReturn(this.database);
939
940 try
941 {
942 EasyMock.expect(this.sqlStatement.getMaxRows()).andReturn(100);
943
944 this.control.replay();
945
946 int size = this.statement.getMaxRows();
947
948 this.control.verify();
949
950 assert size == 100 : size;
951 }
952 catch (SQLException e)
953 {
954 assert false : e;
955 }
956 }
957
958
961 public void testGetMoreResults()
962 {
963 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
964
965 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
966 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
967
968 try
969 {
970 EasyMock.expect(this.sqlStatement.getMoreResults()).andReturn(true);
971
972 this.control.replay();
973
974 boolean more = this.statement.getMoreResults();
975
976 this.control.verify();
977
978 assert more;
979 }
980 catch (SQLException e)
981 {
982 assert false : e;
983 }
984 }
985
986
989 public void testGetMoreResultsInt()
990 {
991 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
992
993 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
994 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
995
996 try
997 {
998 EasyMock.expect(this.sqlStatement.getMoreResults(Statement.CLOSE_CURRENT_RESULT)).andReturn(true);
999
1000 this.control.replay();
1001
1002 boolean more = this.statement.getMoreResults(Statement.CLOSE_CURRENT_RESULT);
1003
1004 this.control.verify();
1005
1006 assert more;
1007 }
1008 catch (SQLException e)
1009 {
1010 assert false : e;
1011 }
1012 }
1013
1014
1017 public void testKeepOpenGetMoreResultsInt()
1018 {
1019 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1020
1021 this.lock.lock();
1022
1023 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1024 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1025
1026 try
1027 {
1028 EasyMock.expect(this.sqlStatement.getMoreResults(Statement.KEEP_CURRENT_RESULT)).andReturn(true);
1029
1030 this.lock.unlock();
1031
1032 this.control.replay();
1033
1034 boolean more = this.statement.getMoreResults(Statement.KEEP_CURRENT_RESULT);
1035
1036 this.control.verify();
1037
1038 assert more;
1039 }
1040 catch (SQLException e)
1041 {
1042 assert false : e;
1043 }
1044 }
1045
1046
1049 public void testGetQueryTimeout()
1050 {
1051 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1052 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1053
1054 try
1055 {
1056 EasyMock.expect(this.sqlStatement.getQueryTimeout()).andReturn(100);
1057
1058 this.control.replay();
1059
1060 int timeout = this.statement.getQueryTimeout();
1061
1062 this.control.verify();
1063
1064 assert timeout == 100 : timeout;
1065 }
1066 catch (SQLException e)
1067 {
1068 assert false : e;
1069 }
1070 }
1071
1072
1075 public void testGetResultSet()
1076 {
1077 ResultSet resultSet = EasyMock.createMock(ResultSet.class);
1078
1079 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1080 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1081
1082 try
1083 {
1084 EasyMock.expect(this.sqlStatement.getGeneratedKeys()).andReturn(resultSet);
1085
1086 this.control.replay();
1087
1088 ResultSet rs = this.statement.getGeneratedKeys();
1089
1090 this.control.verify();
1091
1092 assert rs == resultSet;
1093 }
1094 catch (SQLException e)
1095 {
1096 assert false : e;
1097 }
1098 }
1099
1100
1103 public void testGetResultSetConcurrency()
1104 {
1105 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1106 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1107
1108 try
1109 {
1110 EasyMock.expect(this.sqlStatement.getResultSetConcurrency()).andReturn(ResultSet.CONCUR_UPDATABLE);
1111
1112 this.control.replay();
1113
1114 int concurrency = this.statement.getResultSetConcurrency();
1115
1116 this.control.verify();
1117
1118 assert concurrency == ResultSet.CONCUR_UPDATABLE : concurrency;
1119 }
1120 catch (SQLException e)
1121 {
1122 assert false : e;
1123 }
1124 }
1125
1126
1129 public void testGetResultSetHoldability()
1130 {
1131 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1132 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1133
1134 try
1135 {
1136 EasyMock.expect(this.sqlStatement.getResultSetConcurrency()).andReturn(ResultSet.HOLD_CURSORS_OVER_COMMIT);
1137
1138 this.control.replay();
1139
1140 int holdability = this.statement.getResultSetConcurrency();
1141
1142 this.control.verify();
1143
1144 assert holdability == ResultSet.HOLD_CURSORS_OVER_COMMIT : holdability;
1145 }
1146 catch (SQLException e)
1147 {
1148 assert false : e;
1149 }
1150 }
1151
1152
1155 public void testGetResultSetType()
1156 {
1157 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1158 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1159
1160 try
1161 {
1162 EasyMock.expect(this.sqlStatement.getResultSetType()).andReturn(ResultSet.TYPE_SCROLL_SENSITIVE);
1163
1164 this.control.replay();
1165
1166 int type = this.statement.getResultSetType();
1167
1168 this.control.verify();
1169
1170 assert type == ResultSet.TYPE_SCROLL_SENSITIVE : type;
1171 }
1172 catch (SQLException e)
1173 {
1174 assert false : e;
1175 }
1176 }
1177
1178
1181 public void testGetUpdateCount()
1182 {
1183 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1184 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1185
1186 try
1187 {
1188 EasyMock.expect(this.sqlStatement.getUpdateCount()).andReturn(100);
1189
1190 this.control.replay();
1191
1192 int count = this.statement.getUpdateCount();
1193
1194 this.control.verify();
1195
1196 assert count == 100;
1197 }
1198 catch (SQLException e)
1199 {
1200 assert false : e;
1201 }
1202 }
1203
1204
1207 public void testGetWarnings()
1208 {
1209 SQLWarning warnings = new SQLWarning ();
1210
1211 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1212 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1213
1214 try
1215 {
1216 EasyMock.expect(this.sqlStatement.getWarnings()).andReturn(warnings);
1217
1218 this.control.replay();
1219
1220 SQLWarning warn = this.statement.getWarnings();
1221
1222 this.control.verify();
1223
1224 assert warn == warnings;
1225 }
1226 catch (SQLException e)
1227 {
1228 assert false : e;
1229 }
1230 }
1231
1232
1235 public void testSetCursorName()
1236 {
1237 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
1238
1239 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1240 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1241
1242 try
1243 {
1244 this.sqlStatement.setCursorName("test");
1245
1246 this.control.replay();
1247
1248 this.statement.setCursorName("test");
1249
1250 this.control.verify();
1251 }
1252 catch (SQLException e)
1253 {
1254 assert false : e;
1255 }
1256 }
1257
1258
1261 public void testSetEscapeProcessing()
1262 {
1263 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1264
1265 this.lock.lock();
1266
1267 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1268 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1269
1270 try
1271 {
1272 this.sqlStatement.setEscapeProcessing(true);
1273
1274 this.lock.unlock();
1275
1276 this.control.replay();
1277
1278 this.statement.setEscapeProcessing(true);
1279
1280 this.control.verify();
1281 }
1282 catch (SQLException e)
1283 {
1284 assert false : e;
1285 }
1286 }
1287
1288
1291 public void testSetFetchDirection()
1292 {
1293 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1294
1295 this.lock.lock();
1296
1297 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1298 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1299
1300 try
1301 {
1302 this.sqlStatement.setFetchDirection(ResultSet.FETCH_REVERSE);
1303
1304 this.lock.unlock();
1305
1306 this.control.replay();
1307
1308 this.statement.setFetchDirection(ResultSet.FETCH_REVERSE);
1309
1310 this.control.verify();
1311 }
1312 catch (SQLException e)
1313 {
1314 assert false : e;
1315 }
1316 }
1317
1318
1321 public void testSetFetchSize()
1322 {
1323 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1324
1325 this.lock.lock();
1326
1327 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1328 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1329
1330 try
1331 {
1332 this.sqlStatement.setFetchSize(100);
1333
1334 this.lock.unlock();
1335
1336 this.control.replay();
1337
1338 this.statement.setFetchSize(100);
1339
1340 this.control.verify();
1341 }
1342 catch (SQLException e)
1343 {
1344 assert false : e;
1345 }
1346 }
1347
1348
1351 public void testSetMaxFieldSize()
1352 {
1353 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1354
1355 this.lock.lock();
1356
1357 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1358 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1359
1360 try
1361 {
1362 this.sqlStatement.setMaxFieldSize(100);
1363
1364 this.lock.unlock();
1365
1366 this.control.replay();
1367
1368 this.statement.setMaxFieldSize(100);
1369
1370 this.control.verify();
1371 }
1372 catch (SQLException e)
1373 {
1374 assert false : e;
1375 }
1376 }
1377
1378
1381 public void testSetMaxRows()
1382 {
1383 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
1384
1385 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1386 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1387
1388 try
1389 {
1390 this.sqlStatement.setMaxRows(100);
1391
1392 this.control.replay();
1393
1394 this.statement.setMaxRows(100);
1395
1396 this.control.verify();
1397 }
1398 catch (SQLException e)
1399 {
1400 assert false : e;
1401 }
1402 }
1403
1404
1407 public void testSetQueryTimeout()
1408 {
1409 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1410
1411 this.lock.lock();
1412
1413 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1414 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1415
1416 try
1417 {
1418 this.sqlStatement.setQueryTimeout(100);
1419
1420 this.lock.unlock();
1421
1422 this.control.replay();
1423
1424 this.statement.setQueryTimeout(100);
1425
1426 this.control.verify();
1427 }
1428 catch (SQLException e)
1429 {
1430 assert false : e;
1431 }
1432 }
1433}
1434 |
Popular Tags |
Java API By Example, From Geeks To Geeks.