Marcorensch

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();

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

src/test/java/assertions/PersonTest.java

@@ -1,39 +1,59 @@
 package assertions;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import java.time.LocalDate;
+import java.time.Period;
 
 class PersonTest {
 
     // --- getFullName
 
     @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);
+    }
 }

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;
+    }
+}

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;
+    }
+}

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,54 +31,111 @@ 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
     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"));
+//    }
   }
 }