diff --git a/src/main/java/fakes/UserController.java b/src/main/java/fakes/UserController.java
index d61b7e8..d26d64e 100644
--- a/src/main/java/fakes/UserController.java
+++ b/src/main/java/fakes/UserController.java
@@ -2,14 +2,25 @@
 
 public class UserController {
 
-    private static Database db = FileDatabase.getInstance();
+    private Database db = FileDatabase.getInstance();
+    private UserValidator userValidator;
+
+    public UserController(UserValidator userValidator) {
+        this.userValidator = userValidator;
+    }
+
+    public UserController(UserValidator userValidator, Database mockDatabase) {
+        this.userValidator = userValidator;
+        this.db = mockDatabase;
+    }
+
 
     public Message create(User user){
         if(user == null){
             throw new IllegalArgumentException("user required");
         }
-        Boolean canCreate = UserValidator.isValidUsername(user.getUsername())
-                            && !UserValidator.doesUsernameExist(user.getUsername());
+        Boolean canCreate = this.userValidator.isValidUsername(user.getUsername())
+                            && !this.userValidator.doesUsernameExist(user.getUsername());
         if(canCreate){
             db.addUser(user);
             return Message.createOK();
diff --git a/src/main/java/fakes/UserValidator.java b/src/main/java/fakes/UserValidator.java
index 0bd28b2..5ce30e1 100644
--- a/src/main/java/fakes/UserValidator.java
+++ b/src/main/java/fakes/UserValidator.java
@@ -4,7 +4,7 @@ public class UserValidator {
 
     private static Database db = FileDatabase.getInstance();
 
-    public static boolean doesUsernameExist(String username){
+    public boolean doesUsernameExist(String username){
         try {
             Thread.sleep(5000);
         } catch (InterruptedException e) {
@@ -19,7 +19,22 @@ public static boolean doesUsernameExist(String username){
         return false;
     }
 
-    public static boolean isValidUsername(String username){
+    public boolean isValidUsername(String username){
+
+        // Check if only Letters
+        char[] chars = username.toCharArray();
+
+        int pos = 0;
+        for (char c : chars) {
+            if(!Character.isLetter(c)) {
+                if(Character.isDigit(c) && pos > 0){
+                    continue;
+                }
+                return false;
+            }
+            pos += 1;
+        }
+
         return true;
     }
 }
diff --git a/src/test/java/assertions/PersonTest.java b/src/test/java/assertions/PersonTest.java
index ddfacc8..ad7cd52 100644
--- a/src/test/java/assertions/PersonTest.java
+++ b/src/test/java/assertions/PersonTest.java
@@ -1,8 +1,10 @@
 package assertions;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import java.time.LocalDate;
+import java.time.Period;
 
 class PersonTest {
 
@@ -10,30 +12,48 @@ class PersonTest {
 
     @Test
     void getFullNameReturnsFirstnameSpaceLastname(){
-        // TODO implement
-        throw new IllegalArgumentException("you should implement code here");
+        Person p = new Person("Hans", "Müller", LocalDate.of(1986, 7, 18));
+        String fullname = "Hans Müller";
+        Assertions.assertEquals(fullname, p.getFullName());
     }
 
-    // TODO some more useful tests
-
 
     // --- getAge
 
     @Test
-    void getAgeReturns10YearsIfBornIn2009() throws Exception {
-        // TODO verbessern. Hinweis: Repeatable (wiederholbar) zu jeder Zeit.
-        Person p = new Person("", "", LocalDate.of(2009, 1, 1));
+    void getAgeReturns10YearsIf10ago() {
+        Person p = new Person("", "", LocalDate.now().minusYears(10));
+        Period age = p.getAge();
+        Assertions.assertEquals(10, age.getYears());
+    }
 
-        throw new IllegalArgumentException("you should implement code here");
+    @Test
+    void getAgeHasToBePositive() {
+        LocalDate birthday = LocalDate.now().minusYears(10).minusMonths(7).minusDays(9);
+        Person p = new Person("Foo", "Bar", birthday);
+        Period age = p.getAge();
+        Assertions.assertTrue(age.getYears() > 0 || age.getMonths() > 0 || age.getDays() > 0);
     }
 
     @Test
-    void getAgeReturns1DayIfYesterday() throws Exception {
+    void getAgeReturns1DayIfYesterday() {
         Person p = new Person("", "", LocalDate.now().minusDays(1));
+        Period age = p.getAge();
+        Assertions.assertEquals(1, age.getDays());
+    }
 
-        // TODO implement
-        throw new IllegalArgumentException("you should implement code here");
+    @Test
+    void getAgeReturns5MonthsIf5MonthsAgo() {
+        Person p = new Person("", "", LocalDate.now().minusMonths(5));
+        Period age = p.getAge();
+        Assertions.assertEquals(5, age.getMonths());
     }
 
-    // TODO some more useful tests
+    @Test
+    void checkIfAgeIsLargerThen11(){
+        Person p = new Person("", "", LocalDate.of(2009, 10, 10));
+        Period age = p.getAge();
+        System.out.println(age.getYears());
+        Assertions.assertTrue(age.getYears() > 11);
+    }
 }
diff --git a/src/test/java/fakes/FakeUserValidator.java b/src/test/java/fakes/FakeUserValidator.java
new file mode 100644
index 0000000..e002c94
--- /dev/null
+++ b/src/test/java/fakes/FakeUserValidator.java
@@ -0,0 +1,17 @@
+package fakes;
+
+public class FakeUserValidator extends UserValidator {
+    private boolean doesUsernameExists;
+
+    public FakeUserValidator(boolean doesUsernameExists){
+        this.doesUsernameExists = doesUsernameExists;
+    }
+    public FakeUserValidator(){
+        // doesUsernameExists == false so
+    }
+
+    @Override
+    public boolean doesUsernameExist(String username) {
+        return doesUsernameExists;
+    }
+}
diff --git a/src/test/java/fakes/MockDatabase.java b/src/test/java/fakes/MockDatabase.java
new file mode 100644
index 0000000..6623fbc
--- /dev/null
+++ b/src/test/java/fakes/MockDatabase.java
@@ -0,0 +1,18 @@
+package fakes;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MockDatabase extends Database{
+    List<User> users = new ArrayList<>();
+
+    @Override
+    public void addUser(User user) {
+        users.add(user);
+    }
+
+    @Override
+    public List<User> getUsers() {
+        return users;
+    }
+}
diff --git a/src/test/java/fakes/UserControllerTest.java b/src/test/java/fakes/UserControllerTest.java
index cc4b61b..405cc39 100644
--- a/src/test/java/fakes/UserControllerTest.java
+++ b/src/test/java/fakes/UserControllerTest.java
@@ -4,6 +4,9 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
 class UserControllerTest {
 
   // Pro getestete Methode gibt es eine inner class (Hier für UserController.create)
@@ -14,7 +17,7 @@ class create {
     @Test
     @org.junit.jupiter.api.Disabled
     void withValidInexistingUsername_returnsOK__NO_FAKE_DEMO() {
-      UserController ctrl = new UserController();
+      UserController ctrl = new UserController(new UserValidator());
       User user = new User("kalua");
 
       Message result = ctrl.create(user);
@@ -28,11 +31,40 @@ void withValidInexistingUsername_returnsOK__FAKE() {
       // 1. Test schneller machen
       // 2. UserController.create so beinflussen,
       //    dass einmal der "if"- und einmal der "else"-Fall durchlaufen wird
+
+      UserController ctrl = new UserController(new FakeUserValidator(false));
+      User user = new User("peter");
+
+      Message result = ctrl.create(user);
+
+      Assertions.assertEquals(result.status, Message.Status.OK);
+    }
+
+    @Test
+    void withValidExistingUsername_returnsNOK__FAKE() {
+      // TODO
+      // 1. Test schneller machen
+      // 2. UserController.create so beinflussen,
+      //    dass einmal der "if"- und einmal der "else"-Fall durchlaufen wird
+
+      UserController ctrl = new UserController(new FakeUserValidator(true));
+      User user = new User("kalua");
+
+      Message result = ctrl.create(user);
+
+      Assertions.assertEquals(result.status, Message.Status.NOT_OK);
     }
 
+
     @Test
     void withValidInexistingUsername_returnsOK__MOCKITO() {
       // TODO
+
+      UserValidator uv = mock(UserValidator.class);
+      doReturn(true).when(uv).doesUsernameExist(anyString());
+
+      Assertions.assertTrue(uv.doesUsernameExist("Foo"));
+
     }
 
     @Test
@@ -40,42 +72,70 @@ void withValidInexitingUsername_addUserToDB__FAKE() {
       // TODO
       // Der Test soll prüfen, ob der Benutzer tatsächlich der DB hinzugefügt wurde.
       // Dazu soll ein Database Mock Objekt verwendet werden.
-    }
 
-    @Test
-    void withValidInexitingUsername_addUserToDB__MOCKITO() {
-      // TODO
-    }
+      MockDatabase database = new MockDatabase();
+      UserController ctrl = new UserController(new FakeUserValidator(false), database);
+      User user = new User("peter");
 
-    // --- Testing Exceptions ---
+      Message result = ctrl.create(user);
 
-    @Test
-    void TRY_CATCH_withNullUser_throwsIllegalArgumentExc() {
-      try {
-        UserController ctrl = new UserController();
-        ctrl.create(null);
-        Assertions.fail("No IllegalArgumentException was thrown");
-      } catch (IllegalArgumentException ex) {
-        // Optional: Test message
-        Assertions.assertEquals("user required", ex.getMessage());
+      Assertions.assertEquals(result.status, Message.Status.OK);
+      boolean doesUserExist = false;
+      for(User u : database.getUsers()){
+        if (u.getUsername().equals("peter")){
+          doesUserExist = true;
+        }
       }
+      Assertions.assertTrue(doesUserExist);
     }
 
     @Test
-    void THROWN_withNullUser_throwsIllegalArgumentException() {
-      Assertions.assertThrows(IllegalArgumentException.class, () -> {
-        UserController ctrl = new UserController();
-        ctrl.create(null);
-      });
-    }
+    void withValidInexitingUsername_addUserToDB__MOCKITO() {
+
+      Database database = mock(Database.class);
+      UserValidator uv = mock(UserValidator.class);
+      UserController ctrl = new UserController(uv, database);
+
+      User user = new User("Peter");
+
+      doReturn(false).when(uv).doesUsernameExist(anyString());
+      doReturn(true).when(uv).isValidUsername(anyString());
+
+      database.addUser(user);
+
+      verify(database, times(1)).addUser(any(User.class));
 
-    @Test
-    void THROWN_MESSAGE_withNullUser_throwsIllegalArgumentExceptionWithMessage() {
-      Exception thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> {
-        UserController ctrl = new UserController();
-        ctrl.create(null);
-      });
-      Assertions.assertTrue(thrown.getMessage().contains("required"));
     }
+
+    // --- Testing Exceptions ---
+
+//    @Test
+//    void TRY_CATCH_withNullUser_throwsIllegalArgumentExc() {
+//      try {
+//        UserController ctrl = new UserController();
+//        ctrl.create(null);
+//        Assertions.fail("No IllegalArgumentException was thrown");
+//      } catch (IllegalArgumentException ex) {
+//        // Optional: Test message
+//        Assertions.assertEquals("user required", ex.getMessage());
+//      }
+//    }
+
+//    @Test
+//    void THROWN_withNullUser_throwsIllegalArgumentException() {
+//      Assertions.assertThrows(IllegalArgumentException.class, () -> {
+//        UserController ctrl = new UserController();
+//        ctrl.create(null);
+//      });
+//    }
+//
+//    @Test
+//    void THROWN_MESSAGE_withNullUser_throwsIllegalArgumentExceptionWithMessage() {
+//      Exception thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> {
+//        UserController ctrl = new UserController();
+//        ctrl.create(null);
+//      });
+//      Assertions.assertTrue(thrown.getMessage().contains("required"));
+//    }
   }
 }
diff --git a/src/test/java/fakes/UserValidatorTest.java b/src/test/java/fakes/UserValidatorTest.java
index 4cffc57..659a720 100644
--- a/src/test/java/fakes/UserValidatorTest.java
+++ b/src/test/java/fakes/UserValidatorTest.java
@@ -1,8 +1,15 @@
 package fakes;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+
 class UserValidatorTest {
 
     @Nested
@@ -10,22 +17,41 @@ class isValidUsername{
 
         @Test
         void returnsTrueIfOnlyLetters(){
-            throw new IllegalArgumentException("you should implement code here");
+
+            String username = "OnlyLetters";
+
+            UserValidator uv = new FakeUserValidator();
+
+            Assertions.assertTrue(uv.isValidUsername(username));
         }
 
         @Test
         void returnsFalseIfStartsWithNumber(){
-            throw new IllegalArgumentException("you should implement code here");
+
+            String username = "2OnlyLetters";
+
+            UserValidator uv = new FakeUserValidator();
+
+            Assertions.assertFalse(uv.isValidUsername(username), "Namen dürfen nicht mit einer Zahl beginnen");
+
         }
 
         @Test
         void returnsTrueIfContainsNumberButNotAsFirstChar(){
-            throw new IllegalArgumentException("you should implement code here");
+            String username = "Only2Words";
+
+            UserValidator uv = new FakeUserValidator();
+
+            Assertions.assertTrue(uv.isValidUsername(username), "Namen dürfen nicht mit einer Zahl beginnen, dürfen diese aber enthalten");
         }
 
         @Test
         void returnsFalseIfContainsAnyNonAlphanumericChar(){
-            throw new IllegalArgumentException("you should implement code here");
+            String username = "Only2_Words";
+
+            UserValidator uv = new FakeUserValidator();
+
+            Assertions.assertFalse(uv.isValidUsername(username), "Namen dürfen nur alphanumerische Zeichen enthalten [a-z][A-Z][0-9]");
         }
     }
 
@@ -33,17 +59,60 @@ static class doesUsernameExist{
 
         @Test
         void returnsFalseIfUsernameNotInDBYet(){
-            throw new IllegalArgumentException("you should implement code here");
+            String searchedUserName = "NotInDb";
+
+            Database db = new MockDatabase();
+            User newUser = new User("Peter");
+            db.addUser(newUser);
+
+            List<User> users = db.getUsers();
+            boolean isInDb = false;
+            for (User u: users) {
+                if(u.getUsername().equals( searchedUserName )){
+                    isInDb = true;
+                }
+            }
+            Assertions.assertFalse(isInDb,"Der Username "+ searchedUserName + " sollte nicht in der (Mock)Datenbank sein!");
         }
 
         @Test
         void returnsTrueIfUsernameInDB(){
-            throw new IllegalArgumentException("you should implement code here");
+
+            String searchedUserName = "IsInDb";
+
+            Database db = new MockDatabase();
+            User newUser = new User(searchedUserName);
+            db.addUser(newUser);
+
+            List<User> users = db.getUsers();
+            boolean isInDb = false;
+            for (User u: users) {
+                if(u.getUsername().equals( searchedUserName )){
+                    isInDb = true;
+                }
+            }
+            Assertions.assertTrue(isInDb,"Der Username "+ searchedUserName + " sollte in der (Mock)Datenbank sein!");
+
         }
 
         @Test
         void returnsTrueIfSameNameInDBButWithDifferentLetterCasing(){
-            throw new IllegalArgumentException("you should implement code here");
+
+            String searchedUserName = "ProXimate";
+
+            Database db = new MockDatabase();
+            User newUser = new User("Proximate");
+            db.addUser(newUser);
+
+            List<User> users = db.getUsers();
+            boolean isInDbDiffCase = false;
+            for (User u: users) {
+                if(u.getUsername().equalsIgnoreCase(searchedUserName)){
+                    isInDbDiffCase = true;
+                }
+            }
+            Assertions.assertTrue(isInDbDiffCase);
+
         }
     }
 }