Version où les tests ne passent pas pour des raisons incompréhensibles.(Fichiers de test)

msahmane
1 parent 31bdbe1b
Showing 2 changed files with 44 additions and 0 deletions Show diff stats
src/test/java/fr/plil/sio/persistence/jdbc/AbstractServiceSupport.java
src/test/java/fr/plil/sio/persistence/jdbc/GroupServiceTest.java
@@ -8,13 +8,27 @@ import javax.sql.DataSource;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.sql.Statement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
  
 public abstract class AbstractServiceSupport {
  
+    private static final Logger logger = LoggerFactory.getLogger(AbstractServiceSupport.class);
+    
     private static final String create_table_group = "CREATE TABLE GROUP_T (GROUP_ID INT NOT NULL AUTO_INCREMENT, " +
             "NAME_C VARCHAR(50) UNIQUE NOT NULL, PRIMARY KEY(GROUP_ID))";
  
+    private static final String create_table_right = "CREATE TABLE RIGHT_T (RIGHT_ID INT NOT NULL AUTO_INCREMENT, "+ 
+            "NAME_R VARCHAR(50) UNIQUE NOT NULL, PRIMARY KEY(RIGHT_ID), PARENT INT, FOREIGN KEY(PARENT) REFERENCES RIGHT_T(RIGHT_ID))";
+    
+    private static final String create_table_user = "CREATE TABLE USER_T (USER_ID INT NOT NULL AUTO_INCREMENT, "+
+            "NAME_U VARCHAR(50) UNIQUE NOT NULL, PRIMARY KEY(USER_ID), GROUP_U INT, FOREIGN KEY(GROUP_U) REFERENCES GROUP_T(GROUP_ID)) ";        
+    
     private static final String drop_table_group = "DROP TABLE GROUP_T";
+    
+    private static final String drop_table_right = "DROP TABLE RIGHT_T";
+    
+    private static final String drop_table_user = "DROP TABLE USER_T";
  
     @Autowired
     private DataSource dataSource;
@@ -25,15 +39,21 @@ public abstract class AbstractServiceSupport {
  
     @Before
     public void createTables() throws SQLException {
+        logger.debug("createTables");
         openConnection();
         stmt.executeUpdate(create_table_group);
+        stmt.executeUpdate(create_table_right);
+        stmt.executeUpdate(create_table_user);
         closeConnection();
     }
  
     @After
     public void cleanupDatabase() throws SQLException {
+        logger.debug("cleanupDatabase");        
         openConnection();
         stmt.executeUpdate(drop_table_group);
+        stmt.executeUpdate(drop_table_right);
+        stmt.executeUpdate(drop_table_user);
         closeConnection();
     }
  
@@ -9,11 +9,15 @@ import org.springframework.boot.test.SpringApplicationConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  
 import static org.junit.Assert.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
  
 @RunWith(SpringJUnit4ClassRunner.class)
 @SpringApplicationConfiguration(classes = JdbcApplication.class)
 public class GroupServiceTest extends AbstractServiceSupport {
  
+    private static final Logger logger = LoggerFactory.getLogger(GroupServiceTest.class);
+    
     @Autowired
     private GroupService groupService;
  
@@ -27,6 +31,7 @@ public class GroupServiceTest extends AbstractServiceSupport {
  
     @Before
     public void before() {
+        logger.info("before");
         parent = rightService.create("parent");
         rightService.create("sibling", parent);
         groupService.create("group");
@@ -34,38 +39,45 @@ public class GroupServiceTest extends AbstractServiceSupport {
  
     @Test
     public void testCreateGroupAndFindByName() {
+        logger.info("testCreateGroupAndFindByName");        
         Group group = groupService.findByName("group");
         assertEquals("group", group.getName());
     }
  
     @Test(expected = IllegalArgumentException.class)
     public void testCreateGroupFailsWhenNameNull() {
+        logger.info("testCreateGroupFailsWhenNameNull");                
         groupService.create(null);
     }
  
     @Test(expected = IllegalStateException.class)
     public void testCreateFailsWhenSameGroupUserAlreadyPresent() {
+        logger.info("testCreateFailsWhenSameGroupUserAlreadyPresent");                
         groupService.create("group");
     }
  
     public void testDeleteGroup() {
+        logger.info("testDeleteGroup");                
         assertTrue(groupService.delete("group"));
         assertNull(groupService.findByName("group"));
         assertFalse(groupService.delete("group"));
     }
  
     public void testDeleteNotExistingGroup() {
+        logger.info("testDeleteNotExistingGroup");
         assertFalse(groupService.delete("not-a-group"));
     }
  
  
     @Test(expected = IllegalArgumentException.class)
     public void testDeleteGroupFailsIfNameNull() {
+        logger.info("testDeleteGroupFailsIfNameNull");
         groupService.delete(null);
     }
  
     @Test
     public void deleteGroupDoesDeleteUsers() {
+        logger.info("deleteGroupDoesDeleteUsers");
         userService.create("user1", "group");
         userService.create("user1", "group");
         assertNotNull(userService.findByName("user1"));
@@ -76,16 +88,19 @@ public class GroupServiceTest extends AbstractServiceSupport {
     }
  
     public void testFindByNameIfGroupNotFound() {
+        logger.info("testFindByNameIfGroupNotFound");
         assertNull(groupService.findByName("unknown"));
     }
  
     @Test(expected = IllegalArgumentException.class)
     public void testFindByNameFailsIfNameNull() {
+        logger.info("testFindByNameFailsIfNameNull");
         groupService.findByName(null);
     }
  
     @Test
     public void testAddRight() {
+        logger.info("testAddRight");
         assertTrue(groupService.addRight("group", parent));
         Group group = groupService.findByName("group");
         assertEquals(1, group.getRights().size());
@@ -96,27 +111,32 @@ public class GroupServiceTest extends AbstractServiceSupport {
  
     @Test
     public void testAddRightIfAlreadyPresent() {
+        logger.info("testAddRightIfAlreadyPresent");
         assertTrue(groupService.addRight("group", parent));
         assertFalse(groupService.addRight("group", parent));
     }
  
     @Test(expected = IllegalArgumentException.class)
     public void testAddRightFailsIfGroupNameNull() {
+        logger.info("testAddRightFailsIfGroupNameNull");
         groupService.addRight(null, parent);
     }
  
     @Test(expected = IllegalArgumentException.class)
     public void testAddRightFailsIfRightNull() {
+        logger.info("testAddRightFailsIfRightNull");
         groupService.addRight("group", null);
     }
  
     @Test(expected = IllegalArgumentException.class)
     public void testAddRightFailsIfGroupNotInDatabase() {
+        logger.info("testAddRightFailsIfGroupNotInDatabase");
         groupService.addRight("not-a-group", null);
     }
  
     @Test
     public void testRemoveRight() {
+        logger.info("testRemoveRight");
         assertTrue(groupService.addRight("group", parent));
         Group group = groupService.findByName("group");
         assertEquals(1, group.getRights().size());
@@ -127,6 +147,7 @@ public class GroupServiceTest extends AbstractServiceSupport {
  
     @Test
     public void testRemoveRightIfNotPresent() {
+        logger.info("testRemoveRightIfNotPresent");
         Right right = new Right();
         right.setName("not-a-right");
         assertFalse(groupService.removeRight("group", right));
@@ -134,16 +155,19 @@ public class GroupServiceTest extends AbstractServiceSupport {
  
     @Test(expected = IllegalArgumentException.class)
     public void testRemoveRightFailsIfGroupNameNull() {
+        logger.info("testRemoveRightFailsIfGroupNameNull");
         groupService.removeRight(null, parent);
     }
  
     @Test(expected = IllegalArgumentException.class)
     public void testRemoveRightFailsIfRightNull() {
+        logger.info("testRemoveRightFailsIfRightNull");
         groupService.removeRight("group", null);
     }
  
     @Test(expected = IllegalArgumentException.class)
     public void testRemoveRightFailsIfGroupNotInDatabase() {
+        logger.info("testRemoveRightFailsIfGroupNotInDatabase");
         groupService.removeRight("not-a-group", null);
     }
 }