debugging: user class and userTest class

cathrkri · Apr 17, 2026 · 863b00b · 863b00b
1 parent f943067
commit 863b00b
Show file tree

Hide file tree

Showing 2 changed files with 150 additions and 55 deletions.
diff --git a/helpmehelpapplication/src/main/java/ntnu/systemutvikling/team6/models/user/User.java b/helpmehelpapplication/src/main/java/ntnu/systemutvikling/team6/models/user/User.java
@@ -45,7 +45,7 @@ public User(
       Role role,
       Settings settings,
       Inbox inbox) {
-    if (displayName == null || username.isBlank()) {
+    if (displayName == null || displayName.isBlank()) {
       throw new IllegalArgumentException("displayName cannot be null or blank.");
     }
 

diff --git a/helpmehelpapplication/src/test/java/ntnu/systemutvikling/team6/models/user/UserTest.java b/helpmehelpapplication/src/test/java/ntnu/systemutvikling/team6/models/user/UserTest.java
@@ -1,36 +1,80 @@
 package ntnu.systemutvikling.team6.models.user;
 
 import static org.junit.jupiter.api.Assertions.*;
-import static org.junit.jupiter.api.Assertions.assertEquals;
 
-import java.util.UUID;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
 class UserTest {
 
   @Nested
   class constructorTests {
-    private final UUID validID = UUID.randomUUID();
-    private final String validName = "Name";
+    private final String validDisplayName = "Name";
+    private final String validUsername = "username";
     private final String validEmail = "Email@gmail.com";
     private final String validPassword = "Password";
     private final Role validRole = Role.NORMAL_USER;
     private final Settings validSettings = new Settings();
     private final Inbox validInbox = new Inbox();
 
     @Test
-    void shouldThrowIfNameIsNull() {
+    void shouldThrowIfDisplayNameIsNull() {
       assertThrows(
-          IllegalArgumentException.class,
-          () -> new User(null, validEmail, validPassword, validRole, validSettings, validInbox));
+              IllegalArgumentException.class,
+              () ->
+                      new User(
+                              null,
+                              validUsername,
+                              validEmail,
+                              validPassword,
+                              validRole,
+                              validSettings,
+                              validInbox));
     }
 
     @Test
-    void shouldThrowIfNameIsBlank() {
+    void shouldThrowIfDisplayNameIsBlank() {
       assertThrows(
-          IllegalArgumentException.class,
-          () -> new User(" ", validEmail, validPassword, validRole, validSettings, validInbox));
+              IllegalArgumentException.class,
+              () ->
+                      new User(
+                              " ",
+                              validUsername,
+                              validEmail,
+                              validPassword,
+                              validRole,
+                              validSettings,
+                              validInbox));
+    }
+
+    @Test
+    void shouldThrowIfUsernameIsNull() {
+      assertThrows(
+              IllegalArgumentException.class,
+              () ->
+                      new User(
+                              validDisplayName,
+                              null,
+                              validEmail,
+                              validPassword,
+                              validRole,
+                              validSettings,
+                              validInbox));
+    }
+
+    @Test
+    void shouldThrowIfUsernameIsBlank() {
+      assertThrows(
+              IllegalArgumentException.class,
+              () ->
+                      new User(
+                              validDisplayName,
+                              " ",
+                              validEmail,
+                              validPassword,
+                              validRole,
+                              validSettings,
+                              validInbox));
     }
 
     @Nested
@@ -39,92 +83,143 @@ class emailTests {
       @Test
       void shouldThrowIfEmailIsNull() {
         assertThrows(
-            IllegalArgumentException.class,
-            () -> new User(validName, null, validPassword, validRole, validSettings, validInbox));
+                IllegalArgumentException.class,
+                () ->
+                        new User(
+                                validDisplayName,
+                                validUsername,
+                                null,
+                                validPassword,
+                                validRole,
+                                validSettings,
+                                validInbox));
       }
 
       @Test
       void shouldThrowIfEmailIsBlank() {
         assertThrows(
-            IllegalArgumentException.class,
-            () -> new User(validName, " ", validPassword, validRole, validSettings, validInbox));
+                IllegalArgumentException.class,
+                () ->
+                        new User(
+                                validDisplayName,
+                                validUsername,
+                                " ",
+                                validPassword,
+                                validRole,
+                                validSettings,
+                                validInbox));
       }
 
       @Test
       void shouldThrowIfEmailDoesNotContainAt() {
         assertThrows(
-            IllegalArgumentException.class,
-            () ->
-                new User(
-                    validName,
-                    "test.gmail.com",
-                    validPassword,
-                    validRole,
-                    validSettings,
-                    validInbox));
+                IllegalArgumentException.class,
+                () ->
+                        new User(
+                                validDisplayName,
+                                validUsername,
+                                "test.gmail.com",
+                                validPassword,
+                                validRole,
+                                validSettings,
+                                validInbox));
       }
 
       @Test
       void shouldThrowIfEmailDoesNotContainPeriod() {
         assertThrows(
-            IllegalArgumentException.class,
-            () ->
-                new User(
-                    validName,
-                    "test@gmailcom",
-                    validPassword,
-                    validRole,
-                    validSettings,
-                    validInbox));
+                IllegalArgumentException.class,
+                () ->
+                        new User(
+                                validDisplayName,
+                                validUsername,
+                                "test@gmailcom",
+                                validPassword,
+                                validRole,
+                                validSettings,
+                                validInbox));
       }
     }
 
     @Test
     void shouldThrowIfPasswordIsNull() {
       assertThrows(
-          IllegalArgumentException.class,
-          () -> new User(validName, validEmail, null, validRole, validSettings, validInbox));
+              IllegalArgumentException.class,
+              () ->
+                      new User(
+                              validDisplayName,
+                              validUsername,
+                              validEmail,
+                              null,
+                              validRole,
+                              validSettings,
+                              validInbox));
     }
 
     @Test
     void shouldThrowIfRoleIsNull() {
       assertThrows(
-          IllegalArgumentException.class,
-          () -> new User(validName, validEmail, validPassword, null, validSettings, validInbox));
-    }
-
-    @Test
-    void shouldThrowIfPasswordIsBlank() {
-      assertThrows(
-          IllegalArgumentException.class,
-          () -> new User(validName, validEmail, " ", validRole, validSettings, validInbox));
+              IllegalArgumentException.class,
+              () ->
+                      new User(
+                              validDisplayName,
+                              validUsername,
+                              validEmail,
+                              validPassword,
+                              null,
+                              validSettings,
+                              validInbox));
     }
 
     @Test
     void shouldThrowIfSettingsIsNull() {
       assertThrows(
-          IllegalArgumentException.class,
-          () -> new User(validName, validEmail, validPassword, validRole, null, validInbox));
+              IllegalArgumentException.class,
+              () ->
+                      new User(
+                              validDisplayName,
+                              validUsername,
+                              validEmail,
+                              validPassword,
+                              validRole,
+                              null,
+                              validInbox));
     }
 
     @Test
     void shouldThrowIfInboxIsNull() {
       assertThrows(
-          IllegalArgumentException.class,
-          () -> new User(validName, validEmail, validPassword, validRole, validSettings, null));
+              IllegalArgumentException.class,
+              () ->
+                      new User(
+                              validDisplayName,
+                              validUsername,
+                              validEmail,
+                              validPassword,
+                              validRole,
+                              validSettings,
+                              null));
     }
 
     @Test
     void shouldCreateUser() {
       User user =
-          new User(validName, validEmail, validPassword, validRole, validSettings, validInbox);
+              new User(
+                      validDisplayName,
+                      validUsername,
+                      validEmail,
+                      validPassword,
+                      validRole,
+                      validSettings,
+                      validInbox);
 
       assertAll(
-          () -> assertEquals(validName, user.getName()),
-          () -> assertEquals(validEmail, user.getEmail()),
-          () -> assertEquals(validRole, user.getRole()),
-          () -> assertEquals(validSettings, user.getSettings()),
-          () -> assertEquals(validInbox, user.getInbox()));
+              () -> assertEquals(validDisplayName, user.getDisplayName()),
+              () -> assertEquals(validUsername, user.getUsername()),
+              () -> assertEquals(validEmail, user.getEmail()),
+              () -> assertEquals(validRole, user.getRole()),
+              () -> assertEquals(validSettings, user.getSettings()),
+              () -> assertEquals(validInbox, user.getInbox()));
     }
   }
-}
+}