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. }