From b5466cc6b61f29adec8576407ff35de2a21aae0e Mon Sep 17 00:00:00 2001 From: Claudia Date: Fri, 8 Oct 2021 19:47:26 +0200 Subject: [PATCH 1/5] yeah :) --- src/test/java/assertions/PersonTest.java | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/src/test/java/assertions/PersonTest.java b/src/test/java/assertions/PersonTest.java index ddfacc8..efc5e14 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 { @@ -11,7 +13,10 @@ class PersonTest { @Test void getFullNameReturnsFirstnameSpaceLastname(){ // TODO implement - throw new IllegalArgumentException("you should implement code here"); + // throw new IllegalArgumentException("you should implement code here"); + Person pers1 = new Person("Tobias", "Meier", null); + Assertions.assertEquals("Tobias Meier",pers1.getFullName()); + } // TODO some more useful tests @@ -20,11 +25,15 @@ void getFullNameReturnsFirstnameSpaceLastname(){ // --- getAge @Test - void getAgeReturns10YearsIfBornIn2009() throws Exception { + void getAgeReturns10YearsIfBornIn2011() throws Exception { // TODO verbessern. Hinweis: Repeatable (wiederholbar) zu jeder Zeit. - Person p = new Person("", "", LocalDate.of(2009, 1, 1)); + Person p = new Person("", "", LocalDate.now().minusYears(10)); - throw new IllegalArgumentException("you should implement code here"); + //throw new IllegalArgumentException("you should implement code here"); + Period age = p.getAge(); + Assertions.assertEquals(10,age.getYears()); + Assertions.assertEquals(0, age.getMonths()); + Assertions.assertEquals(0, age.getDays()); } @Test @@ -32,7 +41,11 @@ void getAgeReturns1DayIfYesterday() throws Exception { Person p = new Person("", "", LocalDate.now().minusDays(1)); // TODO implement - throw new IllegalArgumentException("you should implement code here"); + //throw new IllegalArgumentException("you should implement code here"); + Period age = p.getAge(); + Assertions.assertEquals(1,age.getDays()); + Assertions.assertEquals(0, age.getMonths()); + Assertions.assertEquals(0, age.getYears()); } // TODO some more useful tests From 6ec0d5e04311277de0ae2239a337a5ee438d34fa Mon Sep 17 00:00:00 2001 From: Claudia Date: Tue, 19 Oct 2021 15:26:19 +0200 Subject: [PATCH 2/5] =?UTF-8?q?Test=20name=20ge=C3=A4ndert?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/assertions/PersonTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/assertions/PersonTest.java b/src/test/java/assertions/PersonTest.java index efc5e14..7b69c06 100644 --- a/src/test/java/assertions/PersonTest.java +++ b/src/test/java/assertions/PersonTest.java @@ -25,7 +25,7 @@ void getFullNameReturnsFirstnameSpaceLastname(){ // --- getAge @Test - void getAgeReturns10YearsIfBornIn2011() throws Exception { + void getAgeReturns10YearsIfBorn10YearsFromToday() throws Exception { // TODO verbessern. Hinweis: Repeatable (wiederholbar) zu jeder Zeit. Person p = new Person("", "", LocalDate.now().minusYears(10)); From 08f7846593a4313383bd0f8747be52a01b4bbc32 Mon Sep 17 00:00:00 2001 From: Claudia Date: Thu, 4 Nov 2021 10:36:55 +0100 Subject: [PATCH 3/5] =?UTF-8?q?isTeen=20Method=20in=20Person.java=20erg?= =?UTF-8?q?=C3=A4nzt=20PersonTest.java=20,=20Tests=20zu=20isTeen()=20gesch?= =?UTF-8?q?rieben?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/assertions/Person.java | 11 ++++++++ src/test/java/assertions/PersonTest.java | 36 ++++++++++++++++++++++++ 2 files changed, 47 insertions(+) diff --git a/src/main/java/assertions/Person.java b/src/main/java/assertions/Person.java index ac7666b..87ba6e5 100644 --- a/src/main/java/assertions/Person.java +++ b/src/main/java/assertions/Person.java @@ -22,4 +22,15 @@ public String getFullName(){ public Period getAge(){ return Period.between(birthDate, LocalDate.now()); } + + public Boolean isTeen(int years){ + // Is teen if Age 12 <= && >=18 + Period age = getAge(); + years = age.getYears(); + if (years >= 12 && years <= 18){ + return true; + } + return false; + + } } diff --git a/src/test/java/assertions/PersonTest.java b/src/test/java/assertions/PersonTest.java index 7b69c06..1ecc385 100644 --- a/src/test/java/assertions/PersonTest.java +++ b/src/test/java/assertions/PersonTest.java @@ -20,6 +20,42 @@ void getFullNameReturnsFirstnameSpaceLastname(){ } // TODO some more useful tests + @Test + void getFullNameCheckSpaceBetween(){ + Person pers1 = new Person("Tobias", "Meier", null); + String fullName = pers1.getFullName(); + Assertions.assertTrue(fullName.contains(" "), "True if space between firstname and lastname"); + } + + @Test + void isTeenAge18_12ReturnTrue(){ + Person pers1 = new Person("", "", LocalDate.of(2003, 3,11)); + Person pers2 = new Person("", "", LocalDate.of(2009, 3, 11)); + Period age1 = pers1.getAge(); + Period age2 = pers2.getAge(); + int years1 = age1.getYears(); + int years2 = age2.getYears(); + + Assertions.assertEquals(18, age1.getYears()); + Assertions.assertEquals(12, age2.getYears()); + Assertions.assertTrue(pers1.isTeen(years1),"Is teen = true"); + Assertions.assertTrue(pers2.isTeen(years2),"Is teen = true"); + + } + @Test + void isNotTeenAge11_19ReturnFalse(){ + Person pers1 = new Person("", "", LocalDate.of(2010, 3,11)); + Person pers2 = new Person("", "", LocalDate.of(2002, 3, 11)); + Period age1 = pers1.getAge(); + Period age2 = pers2.getAge(); + int years1 = age1.getYears(); + int years2 = age2.getYears(); + + Assertions.assertEquals(11, age1.getYears()); + Assertions.assertEquals(19, age2.getYears()); + Assertions.assertFalse(pers1.isTeen(years1), "Not teen = false"); + Assertions.assertFalse(pers2.isTeen(years2), "Not teen = false"); + } // --- getAge From 02a9128d09892b52d87333a7f39ca484855f1f71 Mon Sep 17 00:00:00 2001 From: Claudia Date: Wed, 17 Nov 2021 16:06:28 +0100 Subject: [PATCH 4/5] =?UTF-8?q?=C3=9Cbungen=20Fakes=20V2.0=20UserValidator?= =?UTF-8?q?Test=20+=20UserControllerTest=202.=20Version?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/fakes/User.java | 4 +- src/main/java/fakes/UserController.java | 25 +- src/main/java/fakes/UserValidator.java | 43 ++- src/test/java/fakes/FakeUserValidator.java | 23 ++ src/test/java/fakes/MockDatabase.java | 20 ++ src/test/java/fakes/UserControllerTest.java | 319 ++++++++++++++------ src/test/java/fakes/UserValidatorTest.java | 67 +++- 7 files changed, 390 insertions(+), 111 deletions(-) create mode 100644 src/test/java/fakes/FakeUserValidator.java create mode 100644 src/test/java/fakes/MockDatabase.java diff --git a/src/main/java/fakes/User.java b/src/main/java/fakes/User.java index 69c0db5..4cd136b 100644 --- a/src/main/java/fakes/User.java +++ b/src/main/java/fakes/User.java @@ -1,11 +1,13 @@ package fakes; +import java.util.Locale; + public class User { private String username; public User(String username){ - this.username = username; + this.username = username.toLowerCase(Locale.ROOT); } public String getUsername() { diff --git a/src/main/java/fakes/UserController.java b/src/main/java/fakes/UserController.java index d61b7e8..bfb80d2 100644 --- a/src/main/java/fakes/UserController.java +++ b/src/main/java/fakes/UserController.java @@ -1,15 +1,34 @@ package fakes; +import java.util.List; + public class UserController { - private static Database db = FileDatabase.getInstance(); + + + private Database db = FileDatabase.getInstance(); + + + private UserValidator userValidator = new UserValidator(); + + public UserController(){} + + //übergabe von erzeugtem FakeUserValidator (Constructor injection) + public UserController(UserValidator userValidator) { + this.userValidator = userValidator; + } + + public UserController(Database db, UserValidator userValidator) { + this.db = db; + this.userValidator = userValidator; + } 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..9dd6ac7 100644 --- a/src/main/java/fakes/UserValidator.java +++ b/src/main/java/fakes/UserValidator.java @@ -1,25 +1,48 @@ package fakes; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; + public class UserValidator { - private static Database db = FileDatabase.getInstance(); + private Database db = FileDatabase.getInstance(); - public static boolean doesUsernameExist(String username){ - try { - Thread.sleep(5000); - } catch (InterruptedException e) { - e.printStackTrace(); - } + public UserValidator() { + } - for(User user : db.getUsers()){ - if (user.getUsername().equals(username)){ + public UserValidator(Database db) { + this.db = db; + } + + public boolean doesUsernameExist(String username) { + for (User user : this.db.getUsers()) { + if (user.getUsername().equals(username.toLowerCase(Locale.ROOT))) { return true; } } return false; } - public static boolean isValidUsername(String username){ + public boolean isValidUsername(String username) { + List chars = new ArrayList<>(); + int position = 0; + + for (char ch : username.toCharArray()) { + chars.add(ch); + if (!Character.isAlphabetic(ch) ||!Character.isLetter(ch) ) { + if (Character.isDigit(ch) && position > 0 ) { + continue; + + } + return false; + } + position+=1; + + + + } return true; } + } diff --git a/src/test/java/fakes/FakeUserValidator.java b/src/test/java/fakes/FakeUserValidator.java new file mode 100644 index 0000000..44d9f1d --- /dev/null +++ b/src/test/java/fakes/FakeUserValidator.java @@ -0,0 +1,23 @@ +package fakes; + +public class FakeUserValidator extends UserValidator { + + private boolean usernameExist; + private boolean validUsername; + + public FakeUserValidator(boolean usernameExist, boolean validUsername) { + this.usernameExist = usernameExist; + this.validUsername = validUsername; + } + + + @Override + public boolean doesUsernameExist(String username) { + return this.usernameExist; + } + + @Override + public boolean isValidUsername(String username) { + return this.validUsername; + } +} diff --git a/src/test/java/fakes/MockDatabase.java b/src/test/java/fakes/MockDatabase.java new file mode 100644 index 0000000..033885e --- /dev/null +++ b/src/test/java/fakes/MockDatabase.java @@ -0,0 +1,20 @@ +package fakes; + +import java.util.ArrayList; +import java.util.List; + +public class MockDatabase extends Database { + + List users = new ArrayList<>(); + + @Override + public void addUser(User user) { + users.add(user); + + } + + @Override + public List getUsers() { + return users; + } +} diff --git a/src/test/java/fakes/UserControllerTest.java b/src/test/java/fakes/UserControllerTest.java index 4c943af..4fb1dda 100644 --- a/src/test/java/fakes/UserControllerTest.java +++ b/src/test/java/fakes/UserControllerTest.java @@ -4,99 +4,242 @@ import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; -class UserControllerTest { - - // Pro getestete Methode gibt es eine inner class (Hier für UserController.create) - @Nested - class create { - - // --- Testing with Fakes --- - - @Test - @org.junit.jupiter.api.Disabled - void withValidInexistingUsername_returnsOK__NO_FAKE_DEMO() { - // Arrange - UserController ctrl = new UserController(); - User user = new User("kalua"); - - // Act - Message result = ctrl.create(user); - - // Assert - Assertions.assertEquals(result.status, Message.Status.OK); - } - - @Test - void withValidInexistentUsername_returnsOK__FAKE() { - // 1. Test schneller machen - // 2. UserController.create so beeinflussen, - // dass einmal der "if"- und einmal der "else"-Fall durchlaufen wird - - // Tipp: Welche Methode sorgt dafür, dass canCreate im UserController true bzw. false ist? - // Kannst du deren Rückgabetyp beeinflussen? - - // Die Schritte die du ausprogrammieren musst: - // 1. Arrange: UserController mit allen Abhängigkeiten initialisieren - // 2. Act: UserController.create Methode aufrufen - // 3. Assert: Rückgabewert von UserController.create prüfen +import java.util.List; - // TODO implement test - } - - @Test - void withValidInexistentUsername_returnsOK__MOCKITO() { - // TODO implement test - } - - @Test - void withValidInexistentUsername_shouldAddUserToDB__FAKE() { - // Der Test soll prüfen, ob der Benutzer tatsächlich der DB hinzugefügt wurde. - // Dazu soll ein Mock-Objekt für die Database Klasse verwendet werden. - - // TODO implement test - // Tipp: Wie kann dein Test feststellen, ob der UserController der Datenbank einen Benutzer hinzugefügt hat? - // Welche Art von Fake (Stub oder Mock) kann dir weiterhelfen? - } +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.*; - @Test - void withValidInexistentUsername_shouldAddUserToDB__MOCKITO() { - // Der Test soll prüfen, ob der Benutzer tatsächlich der DB hinzugefügt wurde. - // Dazu soll ein Mock-Objekt für die Database Klasse verwendet werden. +class UserControllerTest { - // Tipp: Du kannst prüfen, ob der User hinzugefügt wurde, - // indem du prüfst wie of die Methode Database.addUser aufgerufen wurde. - // TODO implement test - } + // Pro getestete Methode gibt es eine inner class (Hier für UserController.create) + @Nested + class create { - // --- Testing Exceptions --- - - @Test - void withNullUser_throwsIllegalArgumentExc__TRY_CATCH() { - 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()); - } - } + // --- Testing with Fakes --- - @Test - void withNullUser_throwsIllegalArgumentException__THROWN() { - Assertions.assertThrows(IllegalArgumentException.class, () -> { - UserController ctrl = new UserController(); - ctrl.create(null); - }); - } + @Test + @org.junit.jupiter.api.Disabled + void withValidInexistingUsername_returnsOK__NO_FAKE_DEMO() { + // Arrange + UserController ctrl = new UserController(); + User user = new User("kalua"); + + // Act + Message result = ctrl.create(user); + + // Assert + Assertions.assertEquals(result.status, Message.Status.OK); + } + + @Test + void withValidInexistentUsername_returnsOK__FAKE() { + // 1. Test schneller machen + // 2. UserController.create so beeinflussen, + // dass einmal der "if"- und einmal der "else"-Fall durchlaufen wird - @Test - void withNullUser_throwsIllegalArgumentExceptionWithMessage__THROWN_MESSAGE() { - Exception thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - UserController ctrl = new UserController(); - ctrl.create(null); - }); - Assertions.assertTrue(thrown.getMessage().contains("required")); + // Tipp: Welche Methode sorgt dafür, dass canCreate im UserController true bzw. false ist? + // Kannst du deren Rückgabetyp beeinflussen? + + // Die Schritte die du ausprogrammieren musst: + // 1. Arrange: UserController mit allen Abhängigkeiten initialisieren + // 2. Act: UserController.create Methode aufrufen + // 3. Assert: Rückgabewert von UserController.create prüfen + + // TODO implement test + // Arrange + UserController ctrl = new UserController(new FakeUserValidator(false, true)); + User user = new User("Maxi"); + + //act + Message result = ctrl.create(user); + + //Assert + Assertions.assertEquals(result.status, Message.Status.OK); + + } + + @Test + void withValidInexistentUsername_returnsNOT_OK__FAKE() { + + + // TODO implement test + // Arrange + UserController ctrl = new UserController(new FakeUserValidator(true, true)); + User user = new User("Maxi"); + + //act + Message result = ctrl.create(user); + + //Assert + Assertions.assertEquals(result.status, Message.Status.NOT_OK); + + } + + @Test + void withValidInexistentUsername_returnsOK__MOCKITO() { + // TODO implement test + //Arrange Mockito erstellen + UserValidator mockitoUv = mock(UserValidator.class); + UserController ctrl = new UserController(mockitoUv); + User user = new User("Martin"); + doReturn(false).when(mockitoUv).doesUsernameExist("Martin"); + doReturn(true).when(mockitoUv).isValidUsername("Martin"); + + //Act + Message result = ctrl.create(user); + //Assert + Assertions.assertEquals(result.status, Message.Status.OK); + + } + + @Test + void withValidInexistentUsername_returnsNOT_OK__MOCKITO() { + // TODO implement test + //Arrange Mockito erstellen (Fake UserValidator mit Mockito) + UserValidator mockitoUv = mock(UserValidator.class); + UserController ctrl = new UserController(mockitoUv); + User user = new User("Martin"); + //Mockito Returnwert setzen + doReturn(true).when(mockitoUv).doesUsernameExist("Martin"); + doReturn(true).when(mockitoUv).isValidUsername("Martin"); + + //Act + Message result = ctrl.create(user); + + //Assert + Assertions.assertEquals(result.status, Message.Status.NOT_OK); + + } + + @Test + void withValidInexistentUsername_shouldAddUserToDB__FAKE() { + // Der Test soll prüfen, ob der Benutzer tatsächlich der DB hinzugefügt wurde. + // Dazu soll ein Mock-Objekt für die Database Klasse verwendet werden. + + // TODO implement test + // Tipp: Wie kann dein Test feststellen, ob der UserController der Datenbank einen Benutzer hinzugefügt hat? + // Welche Art von Fake (Stub oder Mock) kann dir weiterhelfen? + // Arrange MockDatabase erstellt extends Database + MockDatabase mockDb = new MockDatabase(); + UserValidator fakeUv = new FakeUserValidator(false, true); + UserController ctrl = new UserController(mockDb, fakeUv); + User user = new User("Peter"); + + //Act + ctrl.create(user); + boolean userInDB; + userInDB = mockDb.getUsers() == mockDb.users; + + //Assert + // Zwei möglichkeiten für assert + Assertions.assertTrue(userInDB); + Assertions.assertEquals(mockDb.getUsers(), mockDb.users); + + + } + @Test + void withValidInexistentUsername_shouldNOT_AddUserToDB__FAKE() { + // Der Test soll prüfen, ob der Benutzer tatsächlich der DB hinzugefügt wurde. + // Dazu soll ein Mock-Objekt für die Database Klasse verwendet werden. + + // TODO implement test + // Tipp: Wie kann dein Test feststellen, ob der UserController der Datenbank einen Benutzer hinzugefügt hat? + // Welche Art von Fake (Stub oder Mock) kann dir weiterhelfen? + // Arrange MockDatabase erstellt extends Database + MockDatabase mockDb = new MockDatabase(); + UserValidator fakeUv = new FakeUserValidator(false, false); + UserController ctrl = new UserController(mockDb, fakeUv); + User user = new User("Urs"); + //Act + ctrl.create(user); + + //Assert + // Prüft ob List leer ist + + Assertions.assertTrue(mockDb.getUsers().isEmpty()); + + } + + @Test + void withValidInexistentUsername_shouldAddUserToDB__MOCKITO() { + // Der Test soll prüfen, ob der Benutzer tatsächlich der DB hinzugefügt wurde. + // Dazu soll ein Mock-Objekt für die Database Klasse verwendet werden. + + // Tipp: Du kannst prüfen, ob der User hinzugefügt wurde, + // indem du prüfst wie of die Methode Database.addUser aufgerufen wurde. + // TODO implement test + //Arrange + Database mockitoDb = mock(FileDatabase.class); + UserValidator mockitoUv = mock(UserValidator.class); + UserController ctrl = new UserController(mockitoDb, mockitoUv); + //Wenn methoden isValidUsername && doesUsernameExist.thenReturn (Boolean wert) + when(mockitoUv.isValidUsername(anyString())).thenReturn(true); + when(mockitoUv.doesUsernameExist(anyString())).thenReturn(false); + User user = new User("Hampi"); + + //act + ctrl.create(user); + + //assert + verify(mockitoDb, times(1)).addUser(user); + + } + @Test + void withValidInexistentUsername_shouldNOT_AddUserToDB__MOCKITO() { + // Der Test soll prüfen, ob der Benutzer tatsächlich der DB hinzugefügt wurde. + // Dazu soll ein Mock-Objekt für die Database Klasse verwendet werden. + + // Tipp: Du kannst prüfen, ob der User hinzugefügt wurde, + // indem du prüfst wie of die Methode Database.addUser aufgerufen wurde. + // TODO implement test + //Arrange + Database mockitoDb = mock(FileDatabase.class); + UserValidator mockitoUv = mock(UserValidator.class); + UserController ctrl = new UserController(mockitoDb, mockitoUv); + //Wenn methoden isValidUsername && doesUsernameExist.thenReturn (Boolean wert) + when(mockitoUv.isValidUsername(anyString())).thenReturn(false); + when(mockitoUv.doesUsernameExist(anyString())).thenReturn(false); + User user = new User("Hampi"); + + //act + ctrl.create(user); + + //assert + verify(mockitoDb, times(0)).addUser(user); + + + } + + + // --- Testing Exceptions --- + + @Test + void withNullUser_throwsIllegalArgumentExc__TRY_CATCH() { + 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 withNullUser_throwsIllegalArgumentException__THROWN() { + Assertions.assertThrows(IllegalArgumentException.class, () -> { + UserController ctrl = new UserController(); + ctrl.create(null); + }); + } + + @Test + void withNullUser_throwsIllegalArgumentExceptionWithMessage__THROWN_MESSAGE() { + 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 be3486d..be7e325 100644 --- a/src/test/java/fakes/UserValidatorTest.java +++ b/src/test/java/fakes/UserValidatorTest.java @@ -4,6 +4,10 @@ import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; +import java.util.Arrays; + +import static org.mockito.Mockito.*; + class UserValidatorTest { /** @@ -16,22 +20,29 @@ class isValidUsername { @Test void returnsTrueIfOnlyLetters() { // TODO Testcode anpassen, damit er das testet was der Testname sagt. - Assertions.assertTrue(new UserValidator().isValidUsername(null)); + UserValidator userValidator = new UserValidator(); + Assertions.assertTrue(userValidator.isValidUsername("Claudia")); } @Test void returnsFalseIfStartsWithNumber(){ // TODO implement test + UserValidator userValidator = new UserValidator(); + Assertions.assertFalse(userValidator.isValidUsername("1laudia")); } @Test void returnsTrueIfContainsNumberButNotAsFirstChar() { // TODO implement test + UserValidator userValidator = new UserValidator(); + Assertions.assertTrue(userValidator.isValidUsername("Clau4dia")); } @Test void returnsFalseIfContainsAnyNonAlphanumericChar() { // TODO implement test + UserValidator userValidator = new UserValidator(); + Assertions.assertFalse(userValidator.isValidUsername("&udia")); } } @@ -43,34 +54,72 @@ static class doesUsernameExist { @Test void returnsFalseIfUsernameNotInDBYet__FAKE() { // TODO implementiere / ergänze den Test hier, so dass dieser kompiliert und grün ist. - - // boolean usernameExist = uv.doesUsernameExist("peter"); - - // Assertions.assertFalse(usernameExist); + // Arrange + Database mockDb = new MockDatabase(); + UserValidator uv = new UserValidator(mockDb); + //act + boolean usernameExist = uv.doesUsernameExist("peter"); + //assert + Assertions.assertFalse(usernameExist); } @Test void returnsFalseIfUsernameNotInDBYet__MOCKITO() { // TODO implement test + //Arrange + Database mockitoDb = mock(Database.class); + UserValidator uv = new UserValidator(mockitoDb); + //act + boolean usernameExist = uv.doesUsernameExist("peter"); + //assert + Assertions.assertFalse(usernameExist); + } @Test void returnsTrueIfUsernameInDB__FAKE() { // TODO implementiere / ergänze den Test hier, so dass dieser kompiliert und grün ist. - - // boolean usernameExist = uv.doesUsernameExist("peter"); - - // Assertions.assertTrue(usernameExist); + //Arrange + Database mockDb = new MockDatabase(); + mockDb.addUser(new User("Uwe")); + UserValidator uv = new UserValidator(mockDb); + //act + boolean usernameExist = uv.doesUsernameExist("Uwe"); + //Assert + Assertions.assertTrue(usernameExist); } @Test void returnsTrueIfUsernameInDB__MOCKITO() { // TODO implement test + //arrange + Database mockitoDb = mock(Database.class); + + doReturn(Arrays.asList(new User("Hanelore"))).when(mockitoDb).getUsers(); + UserValidator uv = new UserValidator(mockitoDb); + + + //act + boolean usernameExist = uv.doesUsernameExist("Hanelore"); + //assert + Assertions.assertTrue(usernameExist); + } @Test void returnsTrueIfSameNameInDBButWithDifferentLetterCasing() { // TODO implement test + //Arrange + Database mockDb = new MockDatabase(); + User user1 = new User("UWE"); + UserValidator uv = new UserValidator(mockDb); + mockDb.addUser(user1); + + //act + boolean usernameExist = uv.doesUsernameExist("uwE"); + //Assert + Assertions.assertTrue(usernameExist); + } } } From 9015fe28bca3f68734d1367a4b50d770743fbd20 Mon Sep 17 00:00:00 2001 From: Claudia Date: Thu, 18 Nov 2021 14:11:03 +0100 Subject: [PATCH 5/5] =?UTF-8?q?=C3=9Cbungen=20Fakes=20V2.0=20Nach=20review?= =?UTF-8?q?=20=C3=BCberarbeitet=20:)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/fakes/UserControllerTest.java | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/src/test/java/fakes/UserControllerTest.java b/src/test/java/fakes/UserControllerTest.java index 4fb1dda..dd3d40e 100644 --- a/src/test/java/fakes/UserControllerTest.java +++ b/src/test/java/fakes/UserControllerTest.java @@ -93,7 +93,7 @@ void withValidInexistentUsername_returnsOK__MOCKITO() { } @Test - void withValidInexistentUsername_returnsNOT_OK__MOCKITO() { + void withValidExistingUsername_returnsNOT_OK__MOCKITO() { // TODO implement test //Arrange Mockito erstellen (Fake UserValidator mit Mockito) UserValidator mockitoUv = mock(UserValidator.class); @@ -128,17 +128,16 @@ void withValidInexistentUsername_shouldAddUserToDB__FAKE() { //Act ctrl.create(user); boolean userInDB; - userInDB = mockDb.getUsers() == mockDb.users; + userInDB = mockDb.getUsers().contains(user); //Assert - // Zwei möglichkeiten für assert Assertions.assertTrue(userInDB); - Assertions.assertEquals(mockDb.getUsers(), mockDb.users); + } @Test - void withValidInexistentUsername_shouldNOT_AddUserToDB__FAKE() { + void withInValidInexistentUsername_shouldNOT_AddUserToDB__FAKE() { // Der Test soll prüfen, ob der Benutzer tatsächlich der DB hinzugefügt wurde. // Dazu soll ein Mock-Objekt für die Database Klasse verwendet werden. @@ -185,7 +184,7 @@ void withValidInexistentUsername_shouldAddUserToDB__MOCKITO() { } @Test - void withValidInexistentUsername_shouldNOT_AddUserToDB__MOCKITO() { + void withInValidInexistentUsername_shouldNOT_AddUserToDB__MOCKITO() { // Der Test soll prüfen, ob der Benutzer tatsächlich der DB hinzugefügt wurde. // Dazu soll ein Mock-Objekt für die Database Klasse verwendet werden. @@ -193,12 +192,12 @@ void withValidInexistentUsername_shouldNOT_AddUserToDB__MOCKITO() { // indem du prüfst wie of die Methode Database.addUser aufgerufen wurde. // TODO implement test //Arrange - Database mockitoDb = mock(FileDatabase.class); + Database mockitoDb = mock(Database.class); UserValidator mockitoUv = mock(UserValidator.class); UserController ctrl = new UserController(mockitoDb, mockitoUv); //Wenn methoden isValidUsername && doesUsernameExist.thenReturn (Boolean wert) - when(mockitoUv.isValidUsername(anyString())).thenReturn(false); - when(mockitoUv.doesUsernameExist(anyString())).thenReturn(false); + when(mockitoUv.isValidUsername(anyString())).thenReturn(true); + when(mockitoUv.doesUsernameExist(anyString())).thenReturn(true); User user = new User("Hampi"); //act