First student version

- no persistence annotations in domain objects - not fully tested

First student version
- no persistence annotations in domain objects - not fully tested
jcartign
Showing 17 changed files with 868 additions and 0 deletions Show diff stats
.gitignore
pom.xml
src/main/java/fr/plil/sio/persistence/JpaApplication.java
src/main/java/fr/plil/sio/persistence/api/Group.java
src/main/java/fr/plil/sio/persistence/api/GroupService.java
src/main/java/fr/plil/sio/persistence/api/Right.java
src/main/java/fr/plil/sio/persistence/api/RightService.java
src/main/java/fr/plil/sio/persistence/api/User.java
src/main/java/fr/plil/sio/persistence/api/UserService.java
src/main/java/fr/plil/sio/persistence/jpa/GroupRepository.java
src/main/java/fr/plil/sio/persistence/jpa/GroupServiceJpa.java
src/main/java/fr/plil/sio/persistence/jpa/RightServiceJpa.java
src/main/java/fr/plil/sio/persistence/jpa/UserServiceJpa.java
src/test/java/fr/plil/sio/persistence/jpa/GroupServiceTest.java
src/test/java/fr/plil/sio/persistence/jpa/RightServiceTest.java
src/test/java/fr/plil/sio/persistence/jpa/UserServiceTest.java
src/test/resources/application.properties
+++ a/.gitignore
@@ -0,0 +1,3 @@
+*.iml
+target/
+.idea/
+++ a/pom.xml
@@ -0,0 +1,38 @@
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+                             http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>fr.plil.sio.persistence</groupId>
+    <artifactId>spring-jpa</artifactId>
+    <version>0.1</version>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>1.4.0.RELEASE</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <java.version>1.8</java.version>
+    </properties>
+
+</project>
+++ a/src/main/java/fr/plil/sio/persistence/JpaApplication.java
@@ -0,0 +1,8 @@
+package fr.plil.sio.persistence;
+
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class JpaApplication {
+
+}
+++ a/src/main/java/fr/plil/sio/persistence/api/Group.java
@@ -0,0 +1,55 @@
+package fr.plil.sio.persistence.api;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class Group {
+
+    private Long id;
+
+    private String name;
+
+    /**
+     * Users in the group.
+     */
+    private Set<User> users = new TreeSet<>();
+
+    /**
+     * List of rights. The list CANNOT contains duplicate rights.
+     */
+    private List<Right> rights = new LinkedList<>();
+
+    public List<Right> getRights() {
+        return rights;
+    }
+
+    public void setRights(List<Right> rights) {
+        this.rights = rights;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Set<User> getUsers() {
+        return users;
+    }
+
+    public void setUsers(Set<User> users) {
+        this.users = users;
+    }
+}
+++ a/src/main/java/fr/plil/sio/persistence/api/GroupService.java
@@ -0,0 +1,53 @@
+package fr.plil.sio.persistence.api;
+
+public interface GroupService {
+
+    /**
+     * Create a group with a specific name in the database.
+     * There is no two groups with the same name in the database.
+     *
+     * @param name the name of the group
+     * @return an instance of the group
+     * @throws IllegalArgumentException if name is null
+     * @throws IllegalStateException    if a group with the same name is already present
+     */
+    Group create(String name);
+
+    /**
+     * Delete a group in the database. Remove all users in the group.
+     *
+     * @param name the name of the group to remove
+     * @return true if group has been deleted, false if group is not found in the database.
+     * @throws IllegalArgumentException if name is null
+     */
+    boolean delete(String name);
+
+    /**
+     * Find a group in the database based on its name.
+     *
+     * @param name the name of the group to search for.
+     * @return an instance of the group if found, else null.
+     * @throws IllegalArgumentException if name is null
+     */
+    Group findByName(String name);
+
+    /**
+     * Add a right in the group. Right is inserted at the end of rights list of the group.
+     *
+     * @param groupName the name of the group.
+     * @param right     the right to add
+     * @return true if right is added in the group, false if right was already present.
+     * @throws IllegalArgumentException if groupName or right is null, or if group or right cannot be found.
+     */
+    boolean addRight(String groupName, Right right);
+
+    /**
+     * Remove a right associated with a group.
+     *
+     * @param groupName the name of the group.
+     * @param right     the right to remove
+     * @return true if right is removed from the group, false if teh right was not present in the group.
+     * @throws IllegalArgumentException if groupName or right is null, or if group or right cannot be found.
+     */
+    boolean removeRight(String groupName, Right right);
+}
+++ a/src/main/java/fr/plil/sio/persistence/api/Right.java
@@ -0,0 +1,49 @@
+package fr.plil.sio.persistence.api;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Right {
+
+    private Long id;
+
+    private String name;
+
+    /// the parent group
+    private Right parent;
+
+    /// the sibling group(s), eventually empty
+    private Set<Right> siblings = new HashSet<>();
+
+    public Set<Right> getSiblings() {
+        return siblings;
+    }
+
+    public void setSiblings(Set<Right> siblings) {
+        this.siblings = siblings;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Right getParent() {
+        return parent;
+    }
+
+    public void setParent(Right parent) {
+        this.parent = parent;
+    }
+}
+++ a/src/main/java/fr/plil/sio/persistence/api/RightService.java
@@ -0,0 +1,52 @@
+package fr.plil.sio.persistence.api;
+
+import java.util.List;
+
+public interface RightService {
+
+    /**
+     * Create a parent right with a specific name in the database.
+     * It is possible that two rights has the same name.
+     *
+     * @param name the name of the right
+     * @throws IllegalArgumentException if name is null
+     */
+    Right create(String name);
+
+    /**
+     * Create a sibling right attached to a parent right with a specific name in the database.
+     * It is possible that two rights has the same name.
+     *
+     * @param name   the name of the right
+     * @param parent the parent right
+     * @throws IllegalArgumentException if name or parent is null, or if parent does not exist in the database.
+     */
+    Right create(String name, Right parent);
+
+    /**
+     * Delete a right in the database. Delete sibling rights if present.
+     *
+     * @param right the right to delete
+     * @return true if right has been deleted, false else.
+     * @throws IllegalArgumentException if right is null.
+     */
+    boolean delete(Right right);
+
+    /**
+     * Find a list of rights in the database based on their name.
+     *
+     * @param name the name of the rights to search for.
+     * @return A list of rights, eventually empty.
+     * @throws IllegalArgumentException if name is null
+     */
+    List<Right> findByName(String name);
+
+    /**
+     * Find a right in the database based on its id.
+     *
+     * @param id the name of the right to search for.
+     * @return an instance of the right if found, else null.
+     * @throws IllegalArgumentException if id is null
+     */
+    Right findOne(Long id);
+}
+++ a/src/main/java/fr/plil/sio/persistence/api/User.java
@@ -0,0 +1,34 @@
+package fr.plil.sio.persistence.api;
+
+public class User {
+
+    private Long id;
+
+    private String name;
+
+    private Group group;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Group getGroup() {
+        return group;
+    }
+
+    public void setGroup(Group group) {
+        this.group = group;
+    }
+}
+++ a/src/main/java/fr/plil/sio/persistence/api/UserService.java
@@ -0,0 +1,45 @@
+package fr.plil.sio.persistence.api;
+
+public interface UserService {
+
+    /**
+     * Create an user with a specific name in the database and affected to an existing group.
+     * There is no two users with the same name in the database.
+     *
+     * @param name      the name of the user
+     * @param groupName the name of the group
+     * @return an instance of the user
+     * @throws IllegalArgumentException if name or groupName is null, or if group does not exist.
+     * @throws IllegalStateException    if an user with the same name is already present
+     */
+    User create(String name, String groupName);
+
+    /**
+     * Delete an user in the database.
+     *
+     * @param name the name of the user to remove
+     * @return true if user has been deleted, false if user is not found in the database.
+     * @throws IllegalArgumentException if name is null
+     */
+    boolean delete(String name);
+
+    /**
+     * Find an user in the database based on its name.
+     *
+     * @param name the name of the user to search for.
+     * @return an instance of the user if found, else null.
+     * @throws IllegalArgumentException if name is null
+     */
+    User findByName(String name);
+
+    /**
+     * Check method to control if an user has a specific right. The following rule is used: an user has a specific
+     * right if the group where the user is contains the specific right or one of its parents.
+     *
+     * @param userName the name of the user
+     * @param right    the specific right
+     * @return true if the group where the user is contains the specific right or one of its parents, false else.
+     * @throws IllegalArgumentException if userName or right is null, or if the user or right does not exist in the db.
+     */
+    boolean isUserHasRight(String userName, Right right);
+}
+++ a/src/main/java/fr/plil/sio/persistence/jpa/GroupRepository.java
@@ -0,0 +1,9 @@
+package fr.plil.sio.persistence.jpa;
+
+import fr.plil.sio.persistence.api.Group;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface GroupRepository extends JpaRepository<Group, Long> {
+
+    Group findByName(String name);
+}
+++ a/src/main/java/fr/plil/sio/persistence/jpa/GroupServiceJpa.java
@@ -0,0 +1,52 @@
+package fr.plil.sio.persistence.jpa;
+
+import fr.plil.sio.persistence.api.Group;
+import fr.plil.sio.persistence.api.GroupService;
+import fr.plil.sio.persistence.api.Right;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class GroupServiceJpa implements GroupService {
+
+    @Autowired
+    private GroupRepository groupRepository;
+
+    @Override
+    public Group create(String name) {
+        if (name == null) {
+            throw new IllegalArgumentException("name cannot be null");
+        }
+        Group group = groupRepository.findByName(name);
+        if (group != null) {
+            throw new IllegalStateException("a group with the same name already exists");
+        }
+        group = new Group();
+        group.setName(name);
+        groupRepository.save(group);
+        return group;
+    }
+
+    @Override
+    public boolean delete(String name) {
+        throw new IllegalStateException("not implemented !");
+    }
+
+    @Override
+    public Group findByName(String name) {
+        if (name == null) {
+            throw new IllegalArgumentException("name cannot be null");
+        }
+        return groupRepository.findByName(name);
+    }
+
+    @Override
+    public boolean addRight(String groupName, Right right) {
+        return false;
+    }
+
+    @Override
+    public boolean removeRight(String groupName, Right right) {
+        return false;
+    }
+}
+++ a/src/main/java/fr/plil/sio/persistence/jpa/RightServiceJpa.java
@@ -0,0 +1,35 @@
+package fr.plil.sio.persistence.jpa;
+
+import fr.plil.sio.persistence.api.Right;
+import fr.plil.sio.persistence.api.RightService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class RightServiceJpa implements RightService {
+    @Override
+    public Right create(String name) {
+        return null;
+    }
+
+    @Override
+    public Right create(String name, Right parent) {
+        return null;
+    }
+
+    @Override
+    public boolean delete(Right right) {
+        return false;
+    }
+
+    @Override
+    public List<Right> findByName(String name) {
+        return null;
+    }
+
+    @Override
+    public Right findOne(Long id) {
+        return null;
+    }
+}
+++ a/src/main/java/fr/plil/sio/persistence/jpa/UserServiceJpa.java
@@ -0,0 +1,29 @@
+package fr.plil.sio.persistence.jpa;
+
+import fr.plil.sio.persistence.api.Right;
+import fr.plil.sio.persistence.api.User;
+import fr.plil.sio.persistence.api.UserService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class UserServiceJpa implements UserService {
+    @Override
+    public User create(String name, String groupName) {
+        return null;
+    }
+
+    @Override
+    public boolean delete(String name) {
+        return false;
+    }
+
+    @Override
+    public User findByName(String name) {
+        return null;
+    }
+
+    @Override
+    public boolean isUserHasRight(String userName, Right right) {
+        return false;
+    }
+}
+++ a/src/test/java/fr/plil/sio/persistence/jpa/GroupServiceTest.java
@@ -0,0 +1,151 @@
+package fr.plil.sio.persistence.jpa;
+
+import fr.plil.sio.persistence.api.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.junit.Assert.*;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@SpringBootTest
+public class GroupServiceTest {
+
+    @Autowired
+    private GroupService groupService;
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private RightService rightService;
+
+    private Right parent;
+
+    @Before
+    public void before() {
+        parent = rightService.create("parent");
+        rightService.create("sibling", parent);
+        groupService.create("group");
+    }
+
+    @Test
+    public void testCreateGroupAndFindByName() {
+        Group group = groupService.findByName("group");
+        assertEquals("group", group.getName());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateGroupFailsWhenNameNull() {
+        groupService.create(null);
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testCreateFailsWhenSameGroupUserAlreadyPresent() {
+        groupService.create("group");
+    }
+
+    @Test
+    public void testDeleteGroup() {
+        assertTrue(groupService.delete("group"));
+        assertNull(groupService.findByName("group"));
+        assertFalse(groupService.delete("group"));
+    }
+
+    @Test
+    public void testDeleteNotExistingGroup() {
+        assertFalse(groupService.delete("not-a-group"));
+    }
+
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testDeleteGroupFailsIfNameNull() {
+        groupService.delete(null);
+    }
+
+    @Test
+    public void deleteGroupDoesDeleteUsers() {
+        userService.create("user1", "group");
+        userService.create("user1", "group");
+        assertNotNull(userService.findByName("user1"));
+        assertNotNull(userService.findByName("user2"));
+        groupService.delete("group");
+        assertNull(userService.findByName("user1"));
+        assertNull(userService.findByName("user2"));
+    }
+
+    public void testFindByNameIfGroupNotFound() {
+        assertNull(groupService.findByName("unknown"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testFindByNameFailsIfNameNull() {
+        groupService.findByName(null);
+    }
+
+    @Test
+    public void testAddRight() {
+        assertTrue(groupService.addRight("group", parent));
+        Group group = groupService.findByName("group");
+        assertEquals(1, group.getRights().size());
+        assertEquals("parent", group.getRights().get(0).getName());
+        assertEquals(1, group.getRights().get(0).getSiblings().size());
+        assertEquals("sibling", group.getRights().get(0).getSiblings().iterator().next().getName());
+    }
+
+    @Test
+    public void testAddRightIfAlreadyPresent() {
+        assertTrue(groupService.addRight("group", parent));
+        assertFalse(groupService.addRight("group", parent));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testAddRightFailsIfGroupNameNull() {
+        groupService.addRight(null, parent);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testAddRightFailsIfRightNull() {
+        groupService.addRight("group", null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testAddRightFailsIfGroupNotInDatabase() {
+        groupService.addRight("not-a-group", null);
+    }
+
+    @Test
+    public void testRemoveRight() {
+        assertTrue(groupService.addRight("group", parent));
+        Group group = groupService.findByName("group");
+        assertEquals(1, group.getRights().size());
+        assertTrue(groupService.removeRight("group", parent));
+        group = groupService.findByName("group");
+        assertEquals(0, group.getRights().size());
+    }
+
+    @Test
+    public void testRemoveRightIfNotPresent() {
+        Right right = new Right();
+        right.setName("not-a-right");
+        assertFalse(groupService.removeRight("group", right));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testRemoveRightFailsIfGroupNameNull() {
+        groupService.removeRight(null, parent);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testRemoveRightFailsIfRightNull() {
+        groupService.removeRight("group", null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testRemoveRightFailsIfGroupNotInDatabase() {
+        groupService.removeRight("not-a-group", null);
+    }
+}
+++ a/src/test/java/fr/plil/sio/persistence/jpa/RightServiceTest.java
@@ -0,0 +1,126 @@
+package fr.plil.sio.persistence.jpa;
+
+import fr.plil.sio.persistence.api.Right;
+import fr.plil.sio.persistence.api.RightService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.junit.Assert.*;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@SpringBootTest
+public class RightServiceTest {
+
+    @Autowired
+    private RightService rightService;
+
+    @Test
+    public void testCreateParentRightAndFindOne() {
+        rightService.create("right");
+        assertEquals(1, rightService.findByName("right").size());
+    }
+
+    @Test
+    public void testCreateTwoParentRightsWithSameNameAndFindByName() {
+        rightService.create("right");
+        rightService.create("right");
+        assertEquals(2, rightService.findByName("right").size());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateFailsIfNameNull() {
+        rightService.create(null);
+    }
+
+    @Test
+    public void testCreateSiblingRightAndFindOne() {
+        Right parent = rightService.create("parent");
+        rightService.create("sibling", parent);
+        assertEquals(1, rightService.findByName("sibling").size());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateSiblingFailsIfNameNull() {
+        Right parent = rightService.create("parent");
+        rightService.create(null, parent);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateSiblingFailsIfParentNull() {
+        rightService.create("parent");
+        rightService.create("sibling", null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateSiblingFailsIfParentNotInDatabase() {
+        Right right = new Right();
+        right.setName("not-a-right");
+        rightService.create("sibling", right);
+    }
+
+    @Test
+    public void testDeleteParentRight() {
+        Right right = rightService.create("right");
+        assertEquals(1, rightService.findByName("right").size());
+        rightService.delete(right);
+        assertEquals(0, rightService.findByName("right").size());
+    }
+
+    @Test
+    public void testDeleteSiblingRight() {
+        Right parent = rightService.create("parent");
+        Right sibling = rightService.create("sibling", parent);
+        rightService.delete(sibling);
+        assertEquals(0, rightService.findByName("sibling").size());
+    }
+
+    @Test
+    public void testDeleteParentAndSiblingRights() {
+        Right parent = rightService.create("parent");
+        rightService.create("sibling", parent);
+        rightService.delete(parent);
+        assertEquals(0, rightService.findByName("sibling").size());
+        assertEquals(0, rightService.findByName("parent").size());
+    }
+
+    @Test
+    public void testDeleteRightIfNotFound() {
+        Right right = new Right();
+        right.setName("not-a-right");
+        assertFalse(rightService.delete(right));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testDeleteRightFailsIfRightNull() {
+        rightService.delete(null);
+    }
+
+    @Test
+    public void testFindByNameIfNameNotFound() {
+        assertEquals(0, rightService.findByName("no").size());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testFindByNameFailsIfNameNull() {
+        rightService.findByName(null);
+    }
+
+    @Test
+    public void testFindOne() {
+        Right right = rightService.create("right");
+        assertNotNull(rightService.findOne(right.getId()));
+    }
+
+    @Test
+    public void testFindOneIfIdNotFound() {
+        assertNull(rightService.findOne(153463167809232L));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testFindOneFailsIfIdNull() {
+        rightService.findOne(null);
+    }
+}
+++ a/src/test/java/fr/plil/sio/persistence/jpa/UserServiceTest.java
@@ -0,0 +1,125 @@
+package fr.plil.sio.persistence.jpa;
+
+import fr.plil.sio.persistence.api.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.junit.Assert.*;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@SpringBootTest
+public class UserServiceTest {
+
+    @Autowired
+    private GroupService groupService;
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private RightService rightService;
+
+    @Before
+    public void before() {
+        groupService.create("group");
+        userService.create("user", "group");
+        Right right = rightService.create("parent");
+        rightService.create("sibling", right);
+        groupService.addRight("group", right);
+        rightService.create("not-for-me");
+    }
+
+    @Test
+    public void testCreateAndFindByName() {
+        User user = userService.findByName("user");
+        assertNotNull(user);
+        assertEquals("user", user.getName());
+        Group group = user.getGroup();
+        assertNotNull(group);
+        assertEquals("group", group.getName());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateFailsWhenNameNull() {
+        userService.create(null, "group");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateFailsWhenGroupNameNull() {
+        userService.create("user", null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateFailsWhenGroupDoesNotExist() {
+        userService.create("user", "notGroup");
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testCreateFailsWhenSameNameUserAlreadyPresent() {
+        userService.create("user", "group");
+    }
+
+    @Test
+    public void testDeleteUser() {
+        assertTrue(userService.delete("user"));
+    }
+
+    @Test
+    public void testDeleteUserIfNotFound() {
+        assertFalse(userService.delete("user"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testDeleteUserFailsIfNameNull() {
+        userService.delete(null);
+    }
+
+    public void testFindUserByNameIfUserNotFound() {
+        assertNull(userService.findByName("blabla"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testFindUserByNameFailsIfNameNull() {
+        assertNull(userService.findByName(null));
+    }
+
+    @Test
+    public void testIsUserHasExactRight() {
+        Right right = rightService.findByName("parent").get(0);
+        assertTrue(userService.isUserHasRight("user", right));
+    }
+
+    @Test
+    public void testIsUserHasRightByParents() {
+        Right right = rightService.findByName("sibling").get(0);
+        assertTrue(userService.isUserHasRight("user", right));
+    }
+
+    @Test
+    public void testIsUserHasNotTheExactRight() {
+        Right right = rightService.findByName("not-for-me").get(0);
+        assertFalse(userService.isUserHasRight("user", right));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testIsUserHasRightFailsWhenUsernameNull() {
+        Right right = rightService.findByName("parent").get(0);
+        userService.isUserHasRight(null, right);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testIsUserHasRightFailsWhenRightNull() {
+        userService.isUserHasRight("user", null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testIsUserHasRightFailsWhenRightNotInDatabase() {
+        Right right = new Right();
+        right.setName("dummy");
+        userService.isUserHasRight("user", right);
+    }
+}
+++ a/src/test/resources/application.properties
@@ -0,0 +1,4 @@
+logging.level.org.springframework=INFO
+logging.level.org.hibernate.SQL=DEBUG
+logging.level.org.hibernate=INFO
+spring.datasource.url=jdbc:h2:mem:persistence;TRACE_LEVEL_FILE=4
 \ No newline at end of file