diff --git a/Documents/~$ftware Vision document - spring 2026.docx b/Documents/~$ftware Vision document - spring 2026.docx
new file mode 100644
index 0000000..38d2bf9
Binary files /dev/null and b/Documents/~$ftware Vision document - spring 2026.docx differ
diff --git a/src/test/java/application/user/UserRegisterTest.java b/src/test/java/application/user/UserRegisterTest.java
index 4a18c35..8ed6894 100644
--- a/src/test/java/application/user/UserRegisterTest.java
+++ b/src/test/java/application/user/UserRegisterTest.java
@@ -2,6 +2,7 @@
 
 import application.security.PasswordHasher;
 import domain.user.User;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import persistence.dao.UserRepository;
 
@@ -11,47 +12,53 @@
 
 public class UserRegisterTest {
 
+
+    private static final String USERNAME = "testuser";
+    private static final String PHONE = "12345678";
+    private static final String PASSWORD = "secret";
+    private static final String EMAIL = "test@example.com";
+    private static final String HASHED_PASSWORD = "hashed-password";
+
+    private RecordingUserRepository repo;
+    private UserRegister userRegister;
+
+    @BeforeEach
+    void setUp() {
+        repo = new RecordingUserRepository();
+        PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD);
+        userRegister = new UserRegister(hasher, repo);
+    }
+
     @Test
     void executeInsertsUserWhenInputIsValid() {
-        RecordingUserRepository repo = new RecordingUserRepository();
-        PasswordHasher hasher = new FakePasswordHasher("hashed-password");
-        UserRegister userRegister = new UserRegister(hasher, repo);
-
-        userRegister.execute("testuser", "12345678", "secret", "test@example.com");
+        userRegister.execute(USERNAME, PHONE, PASSWORD, EMAIL);
 
         assertNotNull(repo.insertedUser);
-        assertEquals("testuser", repo.insertedUser.getUsername());
-        assertEquals("12345678", repo.insertedUser.getPhoneNumber());
-        assertEquals("hashed-password", repo.insertedUser.getPassword());
-        assertEquals("test@example.com", repo.insertedUser.getEmail());
+        assertEquals(USERNAME, repo.insertedUser.getUsername());
+        assertEquals(PHONE, repo.insertedUser.getPhoneNumber());
+        assertEquals(HASHED_PASSWORD, repo.insertedUser.getPassword());
+        assertEquals(EMAIL, repo.insertedUser.getEmail());
     }
 
 
     @Test
     void executeNormalizesUsernameEmailAndPhoneBeforeInsert() {
-        RecordingUserRepository repo = new RecordingUserRepository();
-        PasswordHasher hasher = new FakePasswordHasher("hashed-password");
-        UserRegister userRegister = new UserRegister(hasher, repo);
-
-        userRegister.execute("  testuser  ", " 12345678 ", "secret", "  TEST@EXAMPLE.COM  ");
+        userRegister.execute("  testuser  ", " 12345678 ", PASSWORD, "  TEST@EXAMPLE.COM  ");
 
         assertNotNull(repo.insertedUser);
-        assertEquals("testuser", repo.insertedUser.getUsername());
-        assertEquals("12345678", repo.insertedUser.getPhoneNumber());
-        assertEquals("test@example.com", repo.insertedUser.getEmail());
+        assertEquals(USERNAME, repo.insertedUser.getUsername());
+        assertEquals(PHONE, repo.insertedUser.getPhoneNumber());
+        assertEquals(EMAIL, repo.insertedUser.getEmail());
     }
 
 
     @Test
     void executeThrowsWhenEmailAlreadyExists() {
-        RecordingUserRepository repo = new RecordingUserRepository();
         repo.emailExists = true;
-        PasswordHasher hasher = new FakePasswordHasher("hashed-password");
-        UserRegister userRegister = new UserRegister(hasher, repo);
 
         IllegalArgumentException exception = assertThrows(
                 IllegalArgumentException.class,
-                () -> userRegister.execute("testuser", "12345678", "secret", "test@example.com")
+                () -> userRegister.execute(USERNAME, PHONE, PASSWORD, EMAIL)
         );
 
         assertEquals("Email already in use", exception.getMessage());
@@ -60,14 +67,11 @@ void executeThrowsWhenEmailAlreadyExists() {
 
     @Test
     void executeThrowsWhenUsernameAlreadyExists() {
-        RecordingUserRepository repo = new RecordingUserRepository();
         repo.usernameExists = true;
-        PasswordHasher hasher = new FakePasswordHasher("hashed-password");
-        UserRegister userRegister = new UserRegister(hasher, repo);
 
         IllegalArgumentException exception = assertThrows(
                 IllegalArgumentException.class,
-                () -> userRegister.execute("testuser", "12345678", "secret", "test@example.com")
+                () -> userRegister.execute(USERNAME, PHONE, PASSWORD, EMAIL)
         );
 
         assertEquals("This username is taken", exception.getMessage());
@@ -76,26 +80,21 @@ void executeThrowsWhenUsernameAlreadyExists() {
 
     @Test
     void executeHashesPasswordBeforeSavingUser() {
-        RecordingUserRepository repo = new RecordingUserRepository();
-        RecordingPasswordHasher hasher = new RecordingPasswordHasher("hashed-password");
-        UserRegister userRegister = new UserRegister(hasher, repo);
+        RecordingPasswordHasher recordingHasher = new RecordingPasswordHasher(HASHED_PASSWORD);
+        userRegister = new UserRegister(recordingHasher, repo);
 
-        userRegister.execute("testuser", "12345678", "secret", "test@example.com");
+        userRegister.execute(USERNAME, PHONE, PASSWORD, EMAIL);
 
-        assertEquals("secret", hasher.lastPasswordInput);
+        assertEquals(PASSWORD, recordingHasher.lastPasswordInput);
         assertNotNull(repo.insertedUser);
-        assertEquals("hashed-password", repo.insertedUser.getPassword());
+        assertEquals(HASHED_PASSWORD, repo.insertedUser.getPassword());
     }
 
     @Test
     void executePropagatesDomainValidationErrors() {
-        RecordingUserRepository repo = new RecordingUserRepository();
-        PasswordHasher hasher = new FakePasswordHasher("hashed-password");
-        UserRegister userRegister = new UserRegister(hasher, repo);
-
         IllegalArgumentException exception = assertThrows(
                 IllegalArgumentException.class,
-                () -> userRegister.execute("testuser", "1234", "secret", "test@example.com")
+                () -> userRegister.execute(USERNAME, "1234", PASSWORD, EMAIL)
         );
 
         assertEquals("Fill in a phonenumber with 8 digits", exception.getMessage());
diff --git a/src/test/java/application/user/UserSignInTest.java b/src/test/java/application/user/UserSignInTest.java
index 50e8e29..b223da9 100644
--- a/src/test/java/application/user/UserSignInTest.java
+++ b/src/test/java/application/user/UserSignInTest.java
@@ -2,6 +2,7 @@
 
 import application.security.PasswordHasher;
 import domain.user.User;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import persistence.dao.UserRepository;
 
@@ -11,29 +12,41 @@
 
 public class UserSignInTest {
 
+    private static final String USERNAME = "testUser";
+    private static final String RAW_PASSWORD = "secret";
+    private static final String HASHED_PASSWORD = "hashed-secret";
+    private static final String EMAIL = "test@example.com";
+    private static final String PHONE = "12345678";
+
+    private User user;
+
+    @BeforeEach
+    void init() {
+        user = new User(USERNAME, PHONE, HASHED_PASSWORD, EMAIL);
+    }
+
     @Test
     void executeReturnsUserWhenCredentialsAreValid() {
-        User user = new User("testuser", "12345678", "hashed-secret", "test@example.com");
-        PasswordHasher hasher = new FakePasswordHasher("hashed-secret");
-        UserRepository repo = new FakeUserRepository(Optional.of(user));
+        PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD);
+        UserRepository repo = new FakeUserRepository(user);
 
         UserSignIn userSignIn = new UserSignIn(hasher, repo);
 
-        User result = userSignIn.execute("testuser", "secret");
+        User result = userSignIn.execute(USERNAME, RAW_PASSWORD);
 
         assertSame(user, result);
     }
 
     @Test
     void executeThrowsWhenLoginDoesNotExist() {
-        PasswordHasher hasher = new FakePasswordHasher("hashed-secret");
-        UserRepository repo = new FakeUserRepository(Optional.empty());
+        PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD);
+        UserRepository repo = new FakeUserRepository(null);
 
         UserSignIn userSignIn = new UserSignIn(hasher, repo);
 
         IllegalArgumentException exception = assertThrows(
-            IllegalArgumentException.class,
-            () -> userSignIn.execute("missing-user", "secret")
+                IllegalArgumentException.class,
+                () -> userSignIn.execute("missing-user", RAW_PASSWORD)
         );
 
         assertEquals("Invalid credentials", exception.getMessage());
@@ -41,125 +54,114 @@ void executeThrowsWhenLoginDoesNotExist() {
 
     @Test
     void executeThrowsWhenPasswordIsWrong() {
-        User user = new User("testuser", "12345678", "stored-hash", "test@example.com");
         PasswordHasher hasher = new FakePasswordHasher("different-hash");
-        UserRepository repo = new FakeUserRepository(Optional.of(user));
+        UserRepository repo = new FakeUserRepository(user);
 
         UserSignIn userSignIn = new UserSignIn(hasher, repo);
 
         IllegalArgumentException exception = assertThrows(
-            IllegalArgumentException.class,
-            () -> userSignIn.execute("testuser", "wrong-password")
+                IllegalArgumentException.class,
+                () -> userSignIn.execute(USERNAME, "wrong-password")
         );
 
         assertEquals("Invalid password", exception.getMessage());
     }
 
     @Test
-    void executeUsesNormalizedLoginBeforeLookup() {
-        User user = new User("testuser", "12345678", "hashed-secret", "test@example.com");
-        RecordingUserRepository repo = new RecordingUserRepository(Optional.of(user));
-        PasswordHasher hasher = new FakePasswordHasher("hashed-secret");
+    void executeDoesNotHashPasswordWhenLoginDoesNotExist() {
+        TrackingPasswordHasher hasher = new TrackingPasswordHasher(HASHED_PASSWORD);
+        UserRepository repo = new FakeUserRepository(null);
 
         UserSignIn userSignIn = new UserSignIn(hasher, repo);
 
-        userSignIn.execute("  TestUser  ", "secret");
+        assertThrows(IllegalArgumentException.class,
+                () -> userSignIn.execute("missing-user", RAW_PASSWORD));
 
-        assertEquals("testuser", repo.lastLoginUsed);
+        assertFalse(hasher.wasCalled);
     }
 
-    private static class FakePasswordHasher implements PasswordHasher{
-        private final String hashToReturn;
-        private FakePasswordHasher(String hashToReturn) {
-            this.hashToReturn = hashToReturn;
-        }
+    @Test
+    void executePassesRawPasswordToHasher() {
+        RecordingPasswordHasher hasher = new RecordingPasswordHasher(HASHED_PASSWORD);
+        UserRepository repo = new FakeUserRepository(user);
 
-        @Override
-        public String hash(String password) {
-            return hashToReturn;
-        }
-    }
+        UserSignIn userSignIn = new UserSignIn(hasher, repo);
 
-    private static class FakeUserRepository implements UserRepository {
-        private final Optional<User> userToReturn;
+        userSignIn.execute(USERNAME, RAW_PASSWORD);
 
-        private FakeUserRepository(Optional<User> userToReturn) {
-            this.userToReturn = userToReturn;
-        }
+        assertEquals(RAW_PASSWORD, hasher.lastPassword);
+    }
 
-        @Override
-        public Optional<User> findByUsername(String username){
-            return Optional.empty();
-        }
+    private record FakePasswordHasher(String hashToReturn) implements PasswordHasher {
 
         @Override
-        public Optional<User> findByEmail(String email){
-            return Optional.empty();
+            public String hash(String password) {
+                return hashToReturn;
+            }
         }
 
-        @Override
-        public Optional<User> findByLogin(String login) {
-            return userToReturn;
-        }
+    private record FakeUserRepository(User userToReturn) implements UserRepository {
 
-        @Override
-        public boolean existsByEmail(String email) {
-            return false;
-        }
+      @Override
+      public Optional<User> findByUsername(String username) {
+        return Optional.empty();
+      }
 
-        @Override
-        public boolean existsByUsername(String username) {
-            return false;
-        }
+      @Override
+      public Optional<User> findByEmail(String email) {
+        return Optional.empty();
+      }
 
-        @Override
-        public void insert(User user) {
-        }
+      @Override
+      public Optional<User> findByLogin(String login) {
+        return Optional.ofNullable(userToReturn);
+      }
 
-        @Override
-        public void updateUser(User user) {}
-    }
+      @Override
+      public boolean existsByEmail(String email) {
+        return false;
+      }
 
-    private static class RecordingUserRepository implements UserRepository {
-        private final Optional<User> userToReturn;
-        private String lastLoginUsed;
+      @Override
+      public boolean existsByUsername(String username) {
+        return false;
+      }
 
-        private RecordingUserRepository(Optional<User> userToReturn) {
-            this.userToReturn = userToReturn;
-        }
+      @Override
+      public void insert(User user) {
+      }
 
         @Override
-        public Optional<User> findByUsername(String username) {
-            return Optional.empty();
-        }
+        public void updateUser(User user) {}
+    }
 
-        @Override
-        public Optional<User> findByEmail(String email) {
-            return Optional.empty();
-        }
+    private static class TrackingPasswordHasher implements PasswordHasher {
+        private final String hashToReturn;
+        private boolean wasCalled;
 
-        @Override
-        public Optional<User> findByLogin(String login) {
-            lastLoginUsed = login;
-            return userToReturn;
+        private TrackingPasswordHasher(String hashToReturn) {
+            this.hashToReturn = hashToReturn;
         }
 
         @Override
-        public boolean existsByEmail(String email) {
-            return false;
+        public String hash(String password) {
+            wasCalled = true;
+            return hashToReturn;
         }
+    }
 
-        @Override
-        public boolean existsByUsername(String username) {
-            return false;
-        }
+    private static class RecordingPasswordHasher implements PasswordHasher {
+        private final String hashToReturn;
+        private String lastPassword;
 
-        @Override
-        public void insert(User user) {
+        private RecordingPasswordHasher(String hashToReturn) {
+            this.hashToReturn = hashToReturn;
         }
 
         @Override
-        public void updateUser(User user) {}
+        public String hash(String password) {
+            lastPassword = password;
+            return hashToReturn;
+        }
     }
-}
-
+}
\ No newline at end of file
diff --git a/src/test/java/application/user/UserStatisticsTest.java b/src/test/java/application/user/UserStatisticsTest.java
index 492ac43..b8f2413 100644
--- a/src/test/java/application/user/UserStatisticsTest.java
+++ b/src/test/java/application/user/UserStatisticsTest.java
@@ -1,59 +1,70 @@
 package application.user;
 
 import domain.user.User;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import persistence.dao.DonationDao;
 
 import java.lang.reflect.Field;
 import java.util.List;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class UserStatisticsTest {
 
+    private static final String USERNAME = "testuser";
+    private static final String PHONE = "12345678";
+    private static final String PASSWORD = "password";
+    private static final String EMAIL = "test@example.com";
+
+
+    private FakeDonationDao fakeDao;
+    private UserStatistics statistics;
+
+    @BeforeEach void init() throws Exception {
+        fakeDao = new FakeDonationDao();
+        statistics = createStatisticsWithFakeDao(fakeDao);
+    }
+
+
     @Test
-    void userFavoriteOrganization_returnsListFromDonationDao() throws Exception {
-        FakeDonationDao fakeDao = new FakeDonationDao();
-        fakeDao.favoriteOrganizationsToReturn = List.of(
-            "Org1 (3 donasjoner)",
-            "Org2 (2 donasjoner)"
+    void userFavoriteOrganization_returnsListFromDonationDao() {
+        List<String> expected = List.of(
+                "Org1 (3 donations)",
+                "Org2 (2 donations)"
         );
 
-        UserStatistics statistics = createStatisticsWithFakeDao(fakeDao);
+        fakeDao.favoriteOrganizationsToReturn = expected;
+
         User user = createUserWithId(42L);
 
         List<String> result = statistics.userFavoriteOrganization(user);
 
-        assertEquals(List.of("Org1 (3 donasjoner)", "Org2 (2 donasjoner)"), result);
-        assertEquals(42L, fakeDao.lastUserIdForFavorites);
+        assertEquals(expected, result);
+        assertEquals(42L, fakeDao.lastUserIdForFavorite);
     }
 
     @Test
-    void userDonations_returnsListFromDonationDao() throws Exception {
-        FakeDonationDao fakeDao = new FakeDonationDao();
-        fakeDao.userDonationsToReturn = List.of(
-            "Amount: 100, Date: 2026-04-15, Organization: Org1",
-            "Amount: 50, Date: 2026-04-16, Organization: Org2"
+    void userDonations_returnsListFromDonationDao() {
+        List<String> expected = List.of(
+                "Amount: 100, Date: 2026-04-15, Organization: Org1",
+                "Amount: 50, Date: 2026-04-16, Organization: Org2"
         );
 
-        UserStatistics statistics = createStatisticsWithFakeDao(fakeDao);
+        fakeDao.userDonationsToReturn = expected;
+
         User user = createUserWithId(7L);
 
         List<String> result = statistics.userDonations(user);
 
-        assertEquals(List.of(
-            "Amount: 100, Date: 2026-04-15, Organization: Org1",
-            "Amount: 50, Date: 2026-04-16, Organization: Org2"
-        ), result);
+        assertEquals(expected, result);
         assertEquals(7L, fakeDao.lastUserIdForDonations);
     }
 
     @Test
-    void userTotalDonationAmount_returnsValueFromDonationDao() throws Exception {
-        FakeDonationDao fakeDao = new FakeDonationDao();
+    void userTotalDonationAmount_returnsValueFromDonationDao() {
         fakeDao.totalDonationAmountToReturn = "250.00";
 
-        UserStatistics statistics = createStatisticsWithFakeDao(fakeDao);
         User user = createUserWithId(15L);
 
         String result = statistics.userTotalDonationAmount(user);
@@ -63,11 +74,9 @@ void userTotalDonationAmount_returnsValueFromDonationDao() throws Exception {
     }
 
     @Test
-    void getTotalDonationsMade_returnsValueFromDonationDao() throws Exception {
-        FakeDonationDao fakeDao = new FakeDonationDao();
+    void getTotalDonationsMade_returnsValueFromDonationDao() {
         fakeDao.totalDonationsMadeToReturn = "5";
 
-        UserStatistics statistics = createStatisticsWithFakeDao(fakeDao);
         User user = createUserWithId(99L);
 
         String result = statistics.getTotalDonationsMade(user);
@@ -76,16 +85,61 @@ void getTotalDonationsMade_returnsValueFromDonationDao() throws Exception {
         assertEquals(99L, fakeDao.lastUserIdForTotalCount);
     }
 
+    @Test
+    void userFavoriteOrganization_withNullUser_throwsNullPointerException() {
+        //noinspection DataFlowIssue
+        assertThrows(NullPointerException.class, () -> statistics.userFavoriteOrganization(null));
+    }
+
+    @Test
+    void userDonations_withNullUser_throwsNullPointerException() {
+        //noinspection DataFlowIssue
+        assertThrows(NullPointerException.class, () -> statistics.userDonations(null));
+    }
+
+    @Test
+    void userTotalDonationAmount_withNullUser_throwsNullPointerException() {
+        //noinspection DataFlowIssue
+        assertThrows(NullPointerException.class, () -> statistics.userTotalDonationAmount(null));
+    }
+
+    @Test
+    void getTotalDonationsMade_withNullUser_throwsNullPointerException() {
+        //noinspection DataFlowIssue
+        assertThrows(NullPointerException.class, () -> statistics.getTotalDonationsMade(null));
+    }
+
+    @Test
+    void userFavoriteOrganization_withUserNullId_throwsNullPointerException() {
+        User user = new User(USERNAME, PHONE, PASSWORD, EMAIL);
+
+        assertThrows(NullPointerException.class, () -> statistics.userFavoriteOrganization(user));
+    }
+
+    @Test
+    void constructor_initializesDonationDao() throws Exception {
+        Field field = UserStatistics.class.getDeclaredField("donationDao");
+        field.setAccessible(true);
+
+        UserStatistics newStatistics = new UserStatistics();
+        Object dao = field.get(newStatistics);
+
+        assertNotNull(dao);
+        assertEquals(DonationDao.class, dao.getClass());
+    }
+
     private UserStatistics createStatisticsWithFakeDao(FakeDonationDao fakeDao) throws Exception {
         UserStatistics statistics = new UserStatistics();
+
         Field field = UserStatistics.class.getDeclaredField("donationDao");
         field.setAccessible(true);
         field.set(statistics, fakeDao);
+
         return statistics;
     }
 
     private User createUserWithId(long id) {
-        User user = new User("testuser", "12345678", "password", "test@example.com");
+        User user = new User(USERNAME, PHONE, PASSWORD, EMAIL);
         user.setId(id);
         return user;
     }
@@ -96,14 +150,14 @@ private static class FakeDonationDao extends DonationDao {
         String totalDonationAmountToReturn = "0";
         String totalDonationsMadeToReturn = "0";
 
-        long lastUserIdForFavorites;
-        long lastUserIdForDonations;
-        long lastUserIdForTotalAmount;
-        long lastUserIdForTotalCount;
+        private long lastUserIdForFavorite;
+        private long lastUserIdForDonations;
+        private long lastUserIdForTotalAmount;
+        private long lastUserIdForTotalCount;
 
         @Override
         public List<String> getFavoriteOrganization(long userId) {
-            lastUserIdForFavorites = userId;
+            lastUserIdForFavorite = userId;
             return favoriteOrganizationsToReturn;
         }
 
diff --git a/src/test/java/domain/DonationTest.java b/src/test/java/domain/DonationTest.java
index 57c5be1..aafacfd 100644
--- a/src/test/java/domain/DonationTest.java
+++ b/src/test/java/domain/DonationTest.java
@@ -10,15 +10,17 @@
 import java.time.Duration;
 import java.time.LocalDateTime;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
+
 
 class DonationTest {
 
+
+    private static final BigDecimal VALID_AMOUNT = new BigDecimal("1500");
+    private static final BigDecimal SMALL_VALID_AMOUNT = new BigDecimal("0.01");
+
     private User testUser;
     private Organization testOrganization;
-    private BigDecimal testAmount = new BigDecimal("1500");
 
     @BeforeEach
     public void init() {
@@ -30,54 +32,148 @@ public void init() {
         testOrganization.setUrl("https://test.com");
     }
 
+
     @Test
-    public void validDonation_createsSuccessfully() {
-        Donation donation = new Donation(testAmount, testUser, testOrganization);
+    public void constructor_withValidInput_createsDonation() {
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
+        assertNotNull(donation);
     }
 
     @Test
-    public void nullUser_throwsNullPointerException() {
-        NullPointerException exception = assertThrows(NullPointerException.class,
-            () -> new Donation(testAmount, null, testOrganization));
-        assertEquals("User cannot be null", exception.getMessage());
+    public void constructor_withNullUser_throwsNullPointerException() {
+        testUser = null;
+        NullPointerException Exception = assertThrows(NullPointerException.class,
+                () -> new Donation(VALID_AMOUNT, testUser, testOrganization));
+
+        assertEquals("User cannot be null", Exception.getMessage());
     }
 
     @Test
-    public void nullOrganization_throwsNullPointerException() {
-        NullPointerException exception = assertThrows(NullPointerException.class,
-            () -> new Donation(testAmount, testUser, null));
-        assertEquals("Organization cannot be null", exception.getMessage());
+    public void constructor_withNullOrganization_throwsNullPointerException() {
+        testOrganization = null;
+        NullPointerException Exception = assertThrows(NullPointerException.class,
+                () -> new Donation(VALID_AMOUNT, testUser, testOrganization));
+
+        assertEquals("Organization cannot be null", Exception.getMessage());
     }
 
     @Test
-    public void negativeAmount_throwsIllegalArgumentException() {
-        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-            () -> new Donation(new BigDecimal("-23"), testUser, testOrganization));
-        assertEquals("Amount must be greater than 0", exception.getMessage());
+    public void constructor_withPositiveDecimalAmount_setsFieldsCorrectly() {
+        Donation donation = new Donation(SMALL_VALID_AMOUNT, testUser, testOrganization);
+
+        assertEquals(SMALL_VALID_AMOUNT, donation.getAmount());
+        assertEquals(testUser, donation.getUser());
+        assertEquals(testOrganization, donation.getOrganization());
+    }
+
+    @Test
+    public void constructor_withNegativeAmount_throwsIllegalArgumentException() {
+        IllegalArgumentException Exception = assertThrows(IllegalArgumentException.class,
+                () -> new Donation(new BigDecimal("-23"), testUser, testOrganization));
+
+        assertEquals("Amount must be greater than 0", Exception.getMessage());
+    }
+
+
+    @Test
+    public void constructor_withZeroAmount_throwsIllegalArgumentException() {
+        IllegalArgumentException Exception = assertThrows(IllegalArgumentException.class,
+                () -> new Donation(new BigDecimal("0"), testUser, testOrganization));
+
+        assertEquals("Amount must be greater than 0", Exception.getMessage());
+    }
+
+    @Test
+    public void constructor_withNullAmount_throwsNullPointerException() {
+        NullPointerException Exception = assertThrows(NullPointerException.class,
+                () -> new Donation(null, testUser, testOrganization));
+
+        assertEquals("Amount cannot be null", Exception.getMessage());
     }
 
     @Test
     public void getAmount_returnsCorrectValue() {
-        Donation donation = new Donation(testAmount, testUser, testOrganization);
-        assertEquals(testAmount, donation.getAmount());
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
+        assertEquals(VALID_AMOUNT, donation.getAmount());
+
     }
 
     @Test
     public void getDateTime_returnsCurrentTime() {
         LocalDateTime now = LocalDateTime.now();
-        Donation donation = new Donation(testAmount, testUser, testOrganization);
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
+
         assertTrue(Duration.between(now, donation.getDateTime()).abs().toMillis() < 1000);
     }
 
     @Test
     public void getUser_returnsCorrectUser() {
-        Donation donation = new Donation(testAmount, testUser, testOrganization);
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
         assertEquals(testUser, donation.getUser());
     }
 
     @Test
     public void getOrganization_returnsCorrectOrganization() {
-        Donation donation = new Donation(testAmount, testUser, testOrganization);
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
         assertEquals(testOrganization, donation.getOrganization());
     }
+
+    @Test
+    public void setId_withValidPositiveId_setsIdSuccessfully() {
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
+
+        donation.setId(1L);
+
+        assertEquals(1L, donation.getId());
+
+    }
+
+    @Test
+    public void setId_withInvalidNullId_throwsIllegalArgumentException() {
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
+
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+                () -> donation.setId(null));
+
+        assertEquals("ID must be positive", exception.getMessage());
+    }
+
+    @Test
+    public void setId_withInvalidNegativeId_throwsIllegalArgumentException() {
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
+
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+                () -> donation.setId(-1L));
+
+        assertEquals("ID must be positive", exception.getMessage());
+    }
+
+    @Test
+    public void setId_withInvalidZeroId_throwsIllegalArgumentException() {
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
+
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+                () -> donation.setId(0L));
+
+        assertEquals("ID must be positive", exception.getMessage());
+    }
+
+    @Test
+    public void setId_whenCalledTwice_throwsIllegalStateException() {
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
+
+        donation.setId(1L);
+
+        IllegalStateException exception = assertThrows(IllegalStateException.class,
+                () -> donation.setId(2L));
+
+        assertEquals("ID is already set", exception.getMessage());
+    }
+
+    @Test
+    public void getId_beforeSetId_throwsNullPointerException() {
+        Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization);
+
+        assertThrows(NullPointerException.class, donation::getId);
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/domain/OrganizationTest.java b/src/test/java/domain/OrganizationTest.java
index b15d2da..f616b8d 100644
--- a/src/test/java/domain/OrganizationTest.java
+++ b/src/test/java/domain/OrganizationTest.java
@@ -1,26 +1,137 @@
 package domain;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
 import domain.organization.Organization;
 import domain.user.User;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 class OrganizationTest {
 
+    private final ObjectMapper mapper = new ObjectMapper();
+
+    @Test
+    void constructor_setsDefaultEmptyValues() {
+        Organization org = new Organization();
+
+        assertNull(org.getOrgNumber());
+        assertNull(org.getName());
+        assertNull(org.getUrl());
+        assertNull(org.getStatus());
+        assertFalse(org.isPreApproved());
+    }
+
+    @Test
+    void setters_updateAllFields() {
+        Organization org = new Organization();
+
+        org.setOrgNumber("123456789");
+        org.setName("TestOrg");
+        org.setUrl("https://testOrg.com");
+        org.setStatus("ACTIVE");
+        org.setPreApproved(true);
+
+        assertEquals("123456789", org.getOrgNumber());
+        assertEquals("TestOrg", org.getName());
+        assertEquals("https://testOrg.com", org.getUrl());
+        assertEquals("ACTIVE", org.getStatus());
+        assertTrue(org.isPreApproved());
+    }
+
+    @Test
+    void deserializeJson_mapsAllFieldsCorrectly() throws Exception {
+        String json = """
+                {
+                  "org_number": "123456789",
+                  "name": "TestOrg",
+                  "status": "ACTIVE",
+                  "url": "https://testOrg.com",
+                  "is_pre_approved": true
+                }
+                """;
+
+
+        Organization org = mapper.readValue(json, Organization.class);
+
+        assertEquals("123456789", org.getOrgNumber());
+        assertEquals("TestOrg", org.getName());
+        assertEquals("ACTIVE", org.getStatus());
+        assertEquals("https://testOrg.com", org.getUrl());
+        assertTrue(org.isPreApproved());
+    }
+
     private Organization organization;
+    @Test
+    void deserializeJson_ignoresUnknownFields() throws Exception {
+        String json = """
+                {
+                  "org_number": "123456789",
+                  "name": "TestOrg",
+                  "status": "ACTIVE",
+                  "url": "https://testOrg.com",
+                  "is_pre_approved": true,
+                  "unknown_field": "Ignore this"
+                }
+                """;
 
-    @BeforeEach
-    public void init() {
+      Organization org = mapper.readValue(json, Organization.class);
+
+      assertEquals("123456789", org.getOrgNumber());
+      assertEquals("TestOrg", org.getName());
+      assertEquals("ACTIVE", org.getStatus());
+      assertEquals("https://testOrg.com", org.getUrl());
+      assertTrue(org.isPreApproved());
+    }
+
+    @Test
+    void deserializeJson_usesDefaultValuesForMissingFields() throws Exception {
+        String json = """
+                {
+                  "org_number": "123456789",
+                  "name": "TestOrg",
+                  "status": "ACTIVE",
+                  "url": "https://testOrg.com"
+                }
+                """;
+
+
+        Organization org = mapper.readValue(json, Organization.class);
+
+        assertEquals("123456789", org.getOrgNumber());
+        assertEquals("TestOrg", org.getName());
+        assertEquals("ACTIVE", org.getStatus());
+        assertEquals("https://testOrg.com", org.getUrl());
+        assertFalse(org.isPreApproved());
+    }
+
+      @BeforeEach
+      public void init() {
         organization = new Organization();
         organization.setOrgNumber("123456789");
         organization.setName("Test Organization");
         organization.setStatus("approved");
         organization.setUrl("https://test.com");
         organization.setPreApproved(true);
+
+        assertEquals("123456789", organization.getOrgNumber());
+        assertEquals("TestOrg", organization.getName());
+        assertEquals("ACTIVE", organization.getStatus());
+        assertEquals("https://testOrg.com", organization.getUrl());
+        assertTrue(organization.isPreApproved());
+      }
+
+
+      @Test
+    void setPreApproved_togglesValue() {
+        Organization org = new Organization();
+
+        org.setPreApproved(true);
+        assertTrue(org.isPreApproved());
+
+        org.setPreApproved(false);
+        assertFalse(org.isPreApproved());
     }
 
     @Test
diff --git a/src/test/java/domain/UserTest.java b/src/test/java/domain/UserTest.java
index 2aa440c..5ae4d3d 100644
--- a/src/test/java/domain/UserTest.java
+++ b/src/test/java/domain/UserTest.java
@@ -2,141 +2,137 @@
 
 import domain.user.User;
 import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 class UserTest {
 
-    private String testUserName = "testUser";
-    private String testPhoneNumber = "90909090";
-    private String testEmail = "test@email.com";
-    private final String testPassword = "password";
+    private static final String USERNAME = "testUser";
+    private static final String PHONE = "90909090";
+    private static final String EMAIL = "test@email.com";
+    private static final String PASSWORD = "password";
 
-    //Positive tests
     @Test
-    public void userTestPositive(){
-        User User = new User(testUserName, testPhoneNumber, testPassword, testEmail);
+    public void constructor_withValidInput_createsUser(){
+        User user = createUser();
+        assertNotNull(user);
     }
 
-    //Negative tests
     @Test
-    public void userTestUserNameBlank(){
-        testUserName = "";
+    public void constructor_withBlankUsername_throwsIllegalArgumentException(){
         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-                () -> new User(testUserName, testPhoneNumber, testPassword, testEmail));
+                () -> new User("", PHONE, PASSWORD, EMAIL));
 
         assertEquals("Username has to be filled in", exception.getMessage());
     }
 
     @Test
-    public void userTestUserNameNull(){
-        testUserName = null;
+    public void constructor_withNullUsername_throwsIllegalArgumentException(){
         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-                () -> new User(testUserName, testPhoneNumber, testPassword, testEmail));
+                () -> new User(null, PHONE, PASSWORD, EMAIL));
 
         assertEquals("Username has to be filled in", exception.getMessage());
     }
 
     @Test
-    public void userTestPhoneNumberBlank(){
-        testPhoneNumber = "";
+    public void constructor_withBlankPhoneNumber_throwsIllegalArgumentException(){
         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-                () -> new User(testUserName, testPhoneNumber, testPassword, testEmail));
+                () -> new User(USERNAME, "", PASSWORD, EMAIL));
 
         assertEquals("Phonenumber has to be filled in", exception.getMessage());
     }
 
     @Test
-    public void userTestPhoneNumberNull(){
-        testPhoneNumber = null;
+    public void constructor_withNullPhoneNumber_throwsIllegalArgumentException(){
         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-                () -> new User(testUserName, testPhoneNumber, testPassword, testEmail));
+                () -> new User(USERNAME, null, PASSWORD, EMAIL));
 
         assertEquals("Phonenumber has to be filled in", exception.getMessage());
     }
 
     @Test
-    public void userTestPhoneNumberShort() {
-        testPhoneNumber = "909090";
+    public void constructor_withShortPhoneNumber_throwsIllegalArgumentException() {
         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-                () -> new User(testUserName, testPhoneNumber, testPassword, testEmail));
+                () -> new User(USERNAME, "909090", PASSWORD, EMAIL));
 
         assertEquals("Fill in a phonenumber with 8 digits", exception.getMessage());
     }
 
     @Test
-    public void userTestEmailBlank(){
-        testEmail = "";
+    public void constructor_withBlankEmail_throwsIllegalArgumentException(){
         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-                () -> new User(testUserName, testPhoneNumber, testPassword, testEmail));
+                () -> new User(USERNAME, PHONE, PASSWORD, ""));
 
         assertEquals("Invalid email address: ", exception.getMessage());
     }
 
     @Test
-    public void userTestEmailNull(){
-        testEmail = null;
+    public void constructor_withNullEmail_throwsIllegalArgumentException(){
         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-                () -> new User(testUserName, testPhoneNumber, testPassword, testEmail));
+                () -> new User(USERNAME, PHONE, PASSWORD, null));
 
         assertEquals("Invalid email address: null", exception.getMessage());
     }
 
-    //Getter tests
     @Test
-    public void userTestUserNameGet(){
-        User User = new User(testUserName, testPhoneNumber, testPassword, testEmail);
-        assertEquals(User.getUsername(), testUserName);
+    public void getUsername_returnsUsername(){
+        User user = createUser();
+        assertEquals(USERNAME, user.getUsername());
     }
 
     @Test
-    public void userTestPhoneNumberGet(){
-        User User = new User(testUserName, testPhoneNumber, testPassword, testEmail);
-        assertEquals(User.getPhoneNumber(), testPhoneNumber);
+    public void getPhoneNumber_returnsPhoneNumber(){
+        User user = createUser();
+        assertEquals(PHONE, user.getPhoneNumber());
     }
 
     @Test
-    public void userTestEmailGet(){
-        User User = new User(testUserName, testPhoneNumber, testPassword, testEmail);
-        assertEquals(User.getEmail(), testEmail);
+    public void getEmail_returnsEmail(){
+        User user = createUser();
+        assertEquals(EMAIL, user.getEmail());
     }
 
     @Test
-    public void userTestPasswordGet(){
-        User User = new User(testUserName, testPhoneNumber, testPassword, testEmail);
-        assertEquals(User.getPassword(), testPassword);
+    public void getPassword_returnsPassword(){
+        User user = createUser();
+        assertEquals(PASSWORD, user.getPassword());
     }
 
-    //Setter tests
     @Test
-    public void userTestPasswordSet(){
-        User User = new User(testUserName, testPhoneNumber, testPassword, testEmail);
-        String newPassword = "NewPassoword";
-        User.setPassword(newPassword);
-        assertEquals(newPassword, User.getPassword());
+    public void setPassword_updatesPassword(){
+        User user = createUser();
+        String newPassword = "newPassword";
+        user.setPassword(newPassword);
+        assertEquals(newPassword, user.getPassword());
     }
 
     @Test
-    public void userTestUserNameSet(){
-        User User = new User(testUserName, testPhoneNumber, testPassword, testEmail);
+    public void setUsername_updatesUsername(){
+        User user = createUser();
         String newUserName = "NewUsername";
-        User.setUsername(newUserName);
-        assertEquals(newUserName, User.getUsername());
+        user.setUsername(newUserName);
+        assertEquals(newUserName, user.getUsername());
     }
 
     @Test
-    public void userTestPhoneNumberSet(){
-        User User = new User(testUserName, testPhoneNumber, testPassword, testEmail);
-        String newPhoneNumber = "12345678";
-        User.setPhoneNumber(newPhoneNumber);
-        assertEquals(newPhoneNumber, User.getPhoneNumber());
+    public void setPhoneNumber_updatesPhoneNumber(){
+        User user = createUser();
+        String newPhoneNumber = "123456asdsad7";
+        user.setPhoneNumber(newPhoneNumber);
+        assertEquals(newPhoneNumber, user.getPhoneNumber());
     }
 
-    @Test
-    public void userTestEmailSet() {
-        User user = new User(testUserName, testPhoneNumber, testPassword, testEmail);
-        String newEmail = "new@email.com";
-        user.setEmail(newEmail);
-        assertEquals(newEmail, user.getEmail());
+  public void userTestEmailSet() {
+    User user = createUser()
+    String newEmail = "new@email.com";
+    user.setEmail(newEmail);
+    assertEquals(newEmail, user.getEmail());
+  }
+
+    private User createUser() {
+        return new User(USERNAME, PHONE, PASSWORD, EMAIL);
     }
+
+
+
 }
\ No newline at end of file