用junit测试数据库

1. package com.test.db;  
2.   
3. import static org.junit.Assert.assertEquals;  
4. import static org.junit.Assert.assertNull;  
5.   
6. import java.sql.Connection;  
7. import java.sql.PreparedStatement;  
8. import java.sql.ResultSet;  
9.   
10. import org.junit.BeforeClass;  
11. import org.junit.Test;  
12.   
13. import com.test.bean.Person;  
14.   
15. public class PersonDBTest  
16. {  
17.     private static PersonDB personDB;  
18.   
19.     @BeforeClass  
20.     public static void init()  
21.     {  
22.         personDB = new PersonDB();  
23.     }  
24.   
25.     @Test  
26.     public void testInsert()  
27.     {  
28.         Person person = new Person();  
29.   
30.         person.setUsername("lisi");  
31.         person.setPassword("654321");  
32.         person.setAge(20);  
33.   
34.         personDB.insert(person);  
35.   
36.         Person person2 = this.getPersonByMaxId();  
37.   
38.         this.comparePersons(person, person2);  
39.   
40.         personDB.removeById(person2.getId());  
41.   
42.     }  
43.   
44.     @Test  
45.     public void testUpdate()  
46.     {  
47.         Person person = new Person();  
48.   
49.         person.setUsername("zhangsan");  
50.         person.setPassword("langsin");  
51.         person.setAge(40);  
52.   
53.         // 1. insert  
54.         personDB.insert(person);  
55.   
56.         // 2. get  
57.         Person person2 = this.getPersonByMaxId();  
58.   
59.         this.comparePersons(person, person2);  
60.   
61.         person2.setUsername("wangwu");  
62.         person2.setPassword("abcdefg");  
63.         person2.setAge(90);  
64.   
65.         // 3. update. what we want to test  
66.         personDB.update(person2);  
67.   
68.         // 4. get  
69.         Person person3 = this.getPersonByMaxId();  
70.   
71.         this.comparePersons(person2, person3);  
72.   
73.         personDB.removeById(person3.getId());  
74.     }  
75.   
76.     @Test  
77.     public void testGetById()  
78.     {  
79.         Person person = new Person();  
80.   
81.         person.setUsername("zhangsan");  
82.         person.setPassword("123456");  
83.         person.setAge(40);  
84.   
85.         personDB.insert(person);  
86.   
87.         int maxId = this.getMaxId();  
88.   
89.         Person person2 = personDB.getById(maxId);  
90.   
91.         this.comparePersons(person, person2);  
92.           
93.         personDB.removeById(maxId);  
94.     }  
95.       
96.     @Test  
97.     public void testRemoveById()  
98.     {  
99.         Person person = new Person();  
100.           
101.         person.setUsername("zhangsan");  
102.         person.setPassword("123456");  
103.         person.setAge(40);  
104.           
105.         personDB.insert(person);  
106.           
107.         int maxId = this.getMaxId();  
108.           
109.         personDB.removeById(maxId);  
110.           
111.         Person person2 = personDB.getById(maxId);  
112.           
113.         assertNull(person2);  
114.           
115.     }  
116.   
117.     private int getMaxId()  
118.     {  
119.         Connection conn = null;  
120.   
121.         int maxId = 0;  
122.   
123.         try  
124.         {  
125.             conn = Conn.getConnection();  
126.   
127.             String sql = "select max(id) as maxId from person";  
128.   
129.             PreparedStatement ps = conn.prepareStatement(sql);  
130.   
131.             ResultSet rs = ps.executeQuery();  
132.   
133.             if (rs.next())  
134.             {  
135.                 maxId = rs.getInt("maxId");  
136.             }  
137.   
138.         }  
139.         catch (Exception ex)  
140.         {  
141.             ex.printStackTrace();  
142.         }  
143.         finally  
144.         {  
145.             try  
146.             {  
147.                 if (null != conn)  
148.                 {  
149.                     conn.close();  
150.                 }  
151.   
152.             }  
153.             catch (Exception ex)  
154.             {  
155.                 ex.printStackTrace();  
156.             }  
157.         }  
158.   
159.         return maxId;  
160.     }  
161.   
162.     private Person getPersonByMaxId()  
163.     {  
164.         Connection conn = null;  
165.   
166.         Person person = null;  
167.   
168.         try  
169.         {  
170.             conn = Conn.getConnection();  
171.   
172.             String sql = "select max(id) as maxId from person";  
173.   
174.             PreparedStatement ps = conn.prepareStatement(sql);  
175.   
176.             ResultSet rs = ps.executeQuery();  
177.   
178.             int maxId = 0;  
179.   
180.             if (rs.next())  
181.             {  
182.                 maxId = rs.getInt("maxId");  
183.             }  
184.   
185.             String sql2 = "select * from person where id = " + maxId;  
186.   
187.             ps = conn.prepareStatement(sql2);  
188.   
189.             rs = ps.executeQuery();  
190.   
191.             if (rs.next())  
192.             {  
193.                 person = new Person();  
194.   
195.                 person.setId(maxId);  
196.                 person.setUsername(rs.getString("username"));  
197.                 person.setPassword(rs.getString("password"));  
198.                 person.setAge(rs.getInt("age"));  
199.             }  
200.   
201.         }  
202.         catch (Exception ex)  
203.         {  
204.             ex.printStackTrace();  
205.         }  
206.         finally  
207.         {  
208.             try  
209.             {  
210.                 if (null != conn)  
211.                 {  
212.                     conn.close();  
213.                 }  
214.   
215.             }  
216.             catch (Exception ex)  
217.             {  
218.                 ex.printStackTrace();  
219.             }  
220.         }  
221.   
222.         return person;  
223.     }  
224.   
225.     // helper method  
226.     private void comparePersons(Person person1, Person person2)  
227.     {  
228.         assertEquals(person1.getUsername(), person2.getUsername());  
229.         assertEquals(person1.getPassword(), person2.getPassword());  
230.         assertEquals(person1.getAge(), person2.getAge());  
231.     }  
232.   
233. }