Split more queries from DatabaseTest:

- WebUserQueriesTest for WebUser related queries
- More Session related queries
- Reduced checkstyle file length 1750 -> 1000
- Reduced checkstyle class fanout complexity 87 -> 60
- Reduced checkstyle cyclomatic complexity 18 -> 17

Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/Nickname.java

@@ -63,7 +63,7 @@ public class Nickname implements DateHolder {
         if (this == o) return true;
         if (!(o instanceof Nickname)) return false;
         Nickname nickname = (Nickname) o;
-        return Objects.equals(name, nickname.name) &&
+        return Objects.equals(getName(), nickname.getName()) &&
                 Objects.equals(serverUUID, nickname.serverUUID);
     }
 

Plan/common/src/test/java/com/djrapitops/plan/storage/database/DatabaseTest.java

@@ -25,7 +25,6 @@ import com.djrapitops.plan.delivery.domain.container.ServerContainer;
 import com.djrapitops.plan.delivery.domain.keys.Key;
 import com.djrapitops.plan.delivery.domain.keys.PlayerKeys;
 import com.djrapitops.plan.delivery.domain.keys.ServerKeys;
-import com.djrapitops.plan.delivery.domain.keys.SessionKeys;
 import com.djrapitops.plan.gathering.domain.*;
 import com.djrapitops.plan.identification.Server;
 import com.djrapitops.plan.query.QuerySvc;
@@ -42,13 +41,15 @@ import com.djrapitops.plan.storage.database.transactions.BackupCopyTransaction;
 import com.djrapitops.plan.storage.database.transactions.StoreConfigTransaction;
 import com.djrapitops.plan.storage.database.transactions.StoreServerInformationTransaction;
 import com.djrapitops.plan.storage.database.transactions.Transaction;
-import com.djrapitops.plan.storage.database.transactions.commands.*;
+import com.djrapitops.plan.storage.database.transactions.commands.RegisterWebUserTransaction;
+import com.djrapitops.plan.storage.database.transactions.commands.RemoveEverythingTransaction;
+import com.djrapitops.plan.storage.database.transactions.commands.RemovePlayerTransaction;
+import com.djrapitops.plan.storage.database.transactions.commands.SetServerAsUninstalledTransaction;
 import com.djrapitops.plan.storage.database.transactions.events.*;
 import com.djrapitops.plan.storage.database.transactions.init.CreateIndexTransaction;
 import com.djrapitops.plan.storage.database.transactions.init.RemoveDuplicateUserInfoTransaction;
 import com.djrapitops.plan.storage.database.transactions.patches.RegisterDateMinimizationPatch;
 import com.djrapitops.plan.storage.upkeep.DBCleanTask;
-import com.djrapitops.plan.utilities.comparators.DateHolderRecentComparator;
 import com.djrapitops.plan.utilities.java.Lists;
 import com.djrapitops.plugin.logging.console.TestPluginLogger;
 import com.djrapitops.plugin.logging.error.ConsoleErrorLogger;
@@ -57,8 +58,6 @@ import org.junit.jupiter.api.Test;
 import utilities.*;
 
 import java.io.File;
-import java.lang.management.ManagementFactory;
-import java.lang.management.OperatingSystemMXBean;
 import java.nio.file.Files;
 import java.sql.ResultSet;
 import java.sql.SQLException;
@@ -78,9 +77,8 @@ import static org.junit.jupiter.api.Assertions.*;
 public interface DatabaseTest extends DatabaseTestPreparer {
 
     @Test
-    default void testTPSSaving() {
+    default void tpsIsStored() {
         List<TPS> expected = RandomData.randomTPS();
-
         for (TPS tps : expected) {
             execute(DataStoreQueries.storeTPS(serverUUID(), tps));
         }
@@ -96,45 +94,23 @@ public interface DatabaseTest extends DatabaseTestPreparer {
     }
 
     default void saveUserTwo() {
-        db().executeTransaction(new PlayerRegisterTransaction(player2UUID, () -> 123456789L, "Test"));
+        db().executeTransaction(new PlayerRegisterTransaction(player2UUID, RandomData::randomTime, TestConstants.PLAYER_TWO_NAME));
     }
 
     @Test
-    default void testNicknamesTable() {
+    default void allNicknamesAreSaved() {
         saveUserOne();
 
-        Nickname expected = new Nickname("TestNickname", System.currentTimeMillis(), serverUUID());
-        db().executeTransaction(new NicknameStoreTransaction(playerUUID, expected, (uuid, name) -> false /* Not cached */));
-        db().executeTransaction(new NicknameStoreTransaction(playerUUID, expected, (uuid, name) -> true /* Cached */));
+        List<Nickname> saved = RandomData.randomNicknames(serverUUID());
+        for (Nickname nickname : saved) {
+            db().executeTransaction(new NicknameStoreTransaction(playerUUID, nickname, (uuid, name) -> false /* Not cached */));
+            db().executeTransaction(new NicknameStoreTransaction(playerUUID, nickname, (uuid, name) -> true /* Cached */));
+        }
+
         forcePersistenceCheck();
 
-        List<Nickname> nicknames = db().query(NicknameQueries.fetchNicknameDataOfPlayer(playerUUID));
-        assertEquals(1, nicknames.size());
-        assertEquals(expected, nicknames.get(0));
-    }
-
-    @Test
-    default void webUserIsRegistered() {
-        WebUser expected = new WebUser(TestConstants.PLAYER_ONE_NAME, "RandomGarbageBlah", 0);
-        db().executeTransaction(new RegisterWebUserTransaction(expected));
-        forcePersistenceCheck();
-
-        Optional<WebUser> found = db().query(WebUserQueries.fetchWebUser(TestConstants.PLAYER_ONE_NAME));
-        assertTrue(found.isPresent());
-        assertEquals(expected, found.get());
-    }
-
-    @Test
-    default void multipleWebUsersAreFetchedAppropriately() {
-        webUserIsRegistered();
-        assertEquals(1, db().query(WebUserQueries.fetchAllPlanWebUsers()).size());
-    }
-
-    @Test
-    default void webUserIsRemoved() {
-        webUserIsRegistered();
-        db().executeTransaction(new RemoveWebUserTransaction(TestConstants.PLAYER_ONE_NAME));
-        assertFalse(db().query(WebUserQueries.fetchWebUser(TestConstants.PLAYER_ONE_NAME)).isPresent());
+        List<Nickname> fetched = db().query(NicknameQueries.fetchNicknameDataOfPlayer(playerUUID));
+        assertEquals(saved, fetched);
     }
 
     @Test
@@ -162,30 +138,6 @@ public interface DatabaseTest extends DatabaseTestPreparer {
         saveWorlds(worlds);
     }
 
-    default WorldTimes createWorldTimes() {
-        Map<String, GMTimes> times = new HashMap<>();
-        Map<String, Long> gm = new HashMap<>();
-        String[] gms = GMTimes.getGMKeyArray();
-        gm.put(gms[0], 1000L);
-        gm.put(gms[1], 2000L);
-        gm.put(gms[2], 3000L);
-        gm.put(gms[3], 4000L);
-
-        String worldName = worlds[0];
-        times.put(worldName, new GMTimes(gm));
-        db().executeTransaction(new WorldNameStoreTransaction(serverUUID(), worldName));
-
-        return new WorldTimes(times);
-    }
-
-    default List<PlayerKill> createKills() {
-        List<PlayerKill> kills = new ArrayList<>();
-        kills.add(new PlayerKill(TestConstants.PLAYER_TWO_UUID, "Iron Sword", 4321L));
-        kills.add(new PlayerKill(TestConstants.PLAYER_TWO_UUID, "Gold Sword", 5321L));
-        kills.sort(new DateHolderRecentComparator());
-        return kills;
-    }
-
     @Test
     default void userInfoTableStoresCorrectUserInformation() {
         saveUserOne();
@@ -253,17 +205,14 @@ public interface DatabaseTest extends DatabaseTestPreparer {
     default void testRemovalSingleUser() {
         saveUserTwo();
 
-        db().executeTransaction(new PlayerServerRegisterTransaction(playerUUID, () -> 223456789L, "Test_name", serverUUID()));
+        db().executeTransaction(new PlayerServerRegisterTransaction(playerUUID, RandomData::randomTime, TestConstants.PLAYER_ONE_NAME, serverUUID()));
         saveTwoWorlds();
 
-        Session session = new Session(playerUUID, serverUUID(), 12345L, worlds[0], "SURVIVAL");
-        session.endSession(22345L);
-        session.setWorldTimes(createWorldTimes());
-        session.setPlayerKills(createKills());
+        Session session = RandomData.randomSession(serverUUID(), worlds, playerUUID, player2UUID);
 
         execute(DataStoreQueries.storeSession(session));
-        db().executeTransaction(new NicknameStoreTransaction(playerUUID, new Nickname("TestNick", System.currentTimeMillis(), serverUUID()), (uuid, name) -> false /* Not cached */));
-        saveGeoInfo(playerUUID, new GeoInfo("TestLoc", 223456789L));
+        db().executeTransaction(new NicknameStoreTransaction(playerUUID, new Nickname("TestNick", RandomData.randomTime(), serverUUID()), (uuid, name) -> false /* Not cached */));
+        saveGeoInfo(playerUUID, new GeoInfo("TestLoc", RandomData.randomTime()));
 
         assertTrue(db().query(PlayerFetchQueries.isPlayerRegistered(playerUUID)));
 
@@ -304,42 +253,27 @@ public interface DatabaseTest extends DatabaseTestPreparer {
 
         saveTwoWorlds();
 
-        Session session = new Session(playerUUID, serverUUID(), 12345L, worlds[0], "SURVIVAL");
-        session.endSession(22345L);
-        session.setWorldTimes(createWorldTimes());
-        session.setPlayerKills(createKills());
+        Session session = RandomData.randomSession(serverUUID(), worlds, playerUUID, player2UUID);
 
         execute(DataStoreQueries.storeSession(session));
         db().executeTransaction(
-                new NicknameStoreTransaction(playerUUID, new Nickname("TestNick", System.currentTimeMillis(), serverUUID()), (uuid, name) -> false /* Not cached */)
+                new NicknameStoreTransaction(playerUUID, RandomData.randomNickname(serverUUID()), (uuid, name) -> false /* Not cached */)
         );
-        saveGeoInfo(playerUUID, new GeoInfo("TestLoc", 223456789L));
+        saveGeoInfo(playerUUID, new GeoInfo("TestLoc", RandomData.randomTime()));
 
         assertTrue(db().query(PlayerFetchQueries.isPlayerRegistered(playerUUID)));
 
-        List<TPS> expected = new ArrayList<>();
-        Random r = new Random();
-        OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
-        int availableProcessors = ManagementFactory.getOperatingSystemMXBean().getAvailableProcessors();
-        double averageCPUUsage = operatingSystemMXBean.getSystemLoadAverage() / availableProcessors * 100.0;
-        long usedMemory = 51231251254L;
-        int entityCount = 6123;
-        int chunksLoaded = 2134;
-        long freeDiskSpace = new File("").getUsableSpace();
-        expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
-        expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
-        expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
-        expected.add(new TPS(r.nextLong(), r.nextDouble(), r.nextInt(100000000), averageCPUUsage, usedMemory, entityCount, chunksLoaded, freeDiskSpace));
+        List<TPS> expected = RandomData.randomTPS();
         for (TPS tps : expected) {
             execute(DataStoreQueries.storeTPS(serverUUID(), tps));
         }
 
         db().executeTransaction(new PingStoreTransaction(
                 playerUUID, serverUUID(),
-                Collections.singletonList(new DateObj<>(System.currentTimeMillis(), r.nextInt())))
+                Collections.singletonList(new DateObj<>(System.currentTimeMillis(), RandomData.randomInt(-1, 40))))
         );
 
-        WebUser webUser = new WebUser(TestConstants.PLAYER_ONE_NAME, "RandomGarbageBlah", 0);
+        WebUser webUser = new WebUser(TestConstants.PLAYER_ONE_NAME, RandomData.randomString(100), 0);
         db().executeTransaction(new RegisterWebUserTransaction(webUser));
     }
 
@@ -347,28 +281,6 @@ public interface DatabaseTest extends DatabaseTestPreparer {
         db().executeTransaction(new GeoInfoStoreTransaction(uuid, geoInfo));
     }
 
-    @Test
-    default void testSessionTableGetInfoOfServer() {
-        saveUserOne();
-        saveUserTwo();
-
-        Session session = new Session(playerUUID, serverUUID(), 12345L, worlds[0], "SURVIVAL");
-        session.endSession(22345L);
-        session.setWorldTimes(createWorldTimes());
-        session.setPlayerKills(createKills());
-        execute(DataStoreQueries.storeSession(session));
-
-        forcePersistenceCheck();
-
-        Map<UUID, List<Session>> sessions = db().query(SessionQueries.fetchSessionsOfServer(serverUUID()));
-
-        List<Session> sSessions = sessions.get(playerUUID);
-        assertFalse(sessions.isEmpty());
-        assertNotNull(sSessions);
-        assertFalse(sSessions.isEmpty());
-        assertEquals(session, sSessions.get(0));
-    }
-
     @Test
     default void cleanDoesNotCleanActivePlayers() {
         saveUserOne();
@@ -422,45 +334,6 @@ public interface DatabaseTest extends DatabaseTestPreparer {
         );
     }
 
-    @Test
-    default void testKillTableGetKillsOfServer() {
-        saveUserOne();
-        saveUserTwo();
-
-        Session session = createSession();
-        List<PlayerKill> expected = createKills();
-        session.setPlayerKills(expected);
-        execute(DataStoreQueries.storeSession(session));
-
-        forcePersistenceCheck();
-
-        Map<UUID, List<Session>> sessions = db().query(SessionQueries.fetchSessionsOfPlayer(playerUUID));
-        List<Session> savedSessions = sessions.get(serverUUID());
-        assertNotNull(savedSessions);
-        assertFalse(savedSessions.isEmpty());
-
-        Session savedSession = savedSessions.get(0);
-        assertNotNull(savedSession);
-
-        List<PlayerKill> kills = savedSession.getPlayerKills();
-        assertNotNull(kills);
-        assertFalse(kills.isEmpty());
-        assertEquals(expected, kills);
-    }
-
-    default Session createSession() {
-        Session session = new Session(
-                playerUUID,
-                serverUUID(),
-                System.currentTimeMillis(),
-                "world",
-                GMTimes.getGMKeyArray()[0]
-        );
-        db().executeTransaction(new WorldNameStoreTransaction(serverUUID(), "world"));
-        session.endSession(System.currentTimeMillis() + 1L);
-        return session;
-    }
-
     @Test
     default void testBackupAndRestoreSQLite() throws Exception {
         File tempFile = Files.createTempFile(system().getPlanFiles().getDataFolder().toPath(), "backup-", ".db").toFile();
@@ -519,24 +392,6 @@ public interface DatabaseTest extends DatabaseTestPreparer {
         assertEquals(one.query(query), two.query(query));
     }
 
-    @Test
-    default void sessionWorldTimesAreFetchedCorrectly() {
-        saveUserOne();
-        WorldTimes worldTimes = createWorldTimes();
-        Session session = new Session(1, playerUUID, serverUUID(), 12345L, 23456L, 0, 0, 0);
-        session.setWorldTimes(worldTimes);
-        execute(DataStoreQueries.storeSession(session));
-
-        // Fetch the session
-        Map<UUID, List<Session>> sessions = db().query(SessionQueries.fetchSessionsOfPlayer(playerUUID));
-        List<Session> serverSessions = sessions.get(serverUUID());
-        assertNotNull(serverSessions);
-        assertFalse(serverSessions.isEmpty());
-
-        Session savedSession = serverSessions.get(0);
-        assertEquals(worldTimes, savedSession.getUnsafe(SessionKeys.WORLD_TIMES));
-    }
-
     @Test
     default void playerIsRegisteredToUsersTable() {
         assertFalse(db().query(PlayerFetchQueries.isPlayerRegistered(playerUUID)));
@@ -600,7 +455,7 @@ public interface DatabaseTest extends DatabaseTestPreparer {
                 Collections.singletonList(new GeoInfo("TestLoc", 223456789));
         OptionalAssert.equals(expectedGeoInfo, container.getValue(PlayerKeys.GEO_INFO));
 
-        List<Nickname> expectedNicknames = Collections.singletonList(new Nickname("TestNick", -1, serverUUID()));
+        List<Nickname> expectedNicknames = db().query(NicknameQueries.fetchNicknameDataOfPlayer(playerUUID));
         OptionalAssert.equals(expectedNicknames, container.getValue(PlayerKeys.NICKNAMES));
 
         OptionalAssert.equals(false, container.getValue(PlayerKeys.OPERATOR));

Plan/common/src/test/java/com/djrapitops/plan/storage/database/H2Test.java

@@ -20,6 +20,7 @@ import com.djrapitops.plan.PlanSystem;
 import com.djrapitops.plan.storage.database.queries.ActivityIndexQueriesTest;
 import com.djrapitops.plan.storage.database.queries.GeolocationQueriesTest;
 import com.djrapitops.plan.storage.database.queries.SessionQueriesTest;
+import com.djrapitops.plan.storage.database.queries.WebUserQueriesTest;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -44,7 +45,8 @@ public class H2Test implements DatabaseTest,
         ExtensionsDatabaseTest,
         ActivityIndexQueriesTest,
         GeolocationQueriesTest,
-        SessionQueriesTest {
+        SessionQueriesTest,
+        WebUserQueriesTest {
 
     private static final int TEST_PORT_NUMBER = RandomData.randomInt(9005, 9500);
 

Plan/common/src/test/java/com/djrapitops/plan/storage/database/MySQLTest.java

@@ -20,6 +20,7 @@ import com.djrapitops.plan.PlanSystem;
 import com.djrapitops.plan.storage.database.queries.ActivityIndexQueriesTest;
 import com.djrapitops.plan.storage.database.queries.GeolocationQueriesTest;
 import com.djrapitops.plan.storage.database.queries.SessionQueriesTest;
+import com.djrapitops.plan.storage.database.queries.WebUserQueriesTest;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.BeforeAll;
@@ -50,7 +51,8 @@ class MySQLTest implements DatabaseTest,
         ExtensionsDatabaseTest,
         ActivityIndexQueriesTest,
         GeolocationQueriesTest,
-        SessionQueriesTest {
+        SessionQueriesTest,
+        WebUserQueriesTest {
 
     private static final int TEST_PORT_NUMBER = RandomData.randomInt(9005, 9500);
 

Plan/common/src/test/java/com/djrapitops/plan/storage/database/SQLiteTest.java

@@ -20,6 +20,7 @@ import com.djrapitops.plan.PlanSystem;
 import com.djrapitops.plan.storage.database.queries.ActivityIndexQueriesTest;
 import com.djrapitops.plan.storage.database.queries.GeolocationQueriesTest;
 import com.djrapitops.plan.storage.database.queries.SessionQueriesTest;
+import com.djrapitops.plan.storage.database.queries.WebUserQueriesTest;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -44,7 +45,8 @@ public class SQLiteTest implements DatabaseTest,
         ExtensionsDatabaseTest,
         ActivityIndexQueriesTest,
         GeolocationQueriesTest,
-        SessionQueriesTest {
+        SessionQueriesTest,
+        WebUserQueriesTest {
 
     private static final int TEST_PORT_NUMBER = RandomData.randomInt(9005, 9500);
 

Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/SessionQueriesTest.java

@@ -18,6 +18,7 @@ package com.djrapitops.plan.storage.database.queries;
 
 import com.djrapitops.plan.delivery.domain.keys.SessionKeys;
 import com.djrapitops.plan.delivery.domain.mutators.SessionsMutator;
+import com.djrapitops.plan.gathering.domain.PlayerKill;
 import com.djrapitops.plan.gathering.domain.Session;
 import com.djrapitops.plan.gathering.domain.WorldTimes;
 import com.djrapitops.plan.storage.database.DatabaseTestPreparer;
@@ -140,7 +141,7 @@ public interface SessionQueriesTest extends DatabaseTestPreparer {
     default void playersWorldTimesMatchTotal() {
         worldTimesAreSavedWithSession();
         Session session = db().query(SessionQueries.fetchSessionsOfPlayer(playerUUID)).get(serverUUID()).get(0);
-        WorldTimes expected = session.getValue(SessionKeys.WORLD_TIMES).orElse(new WorldTimes());
+        WorldTimes expected = session.getValue(SessionKeys.WORLD_TIMES).orElseThrow(AssertionError::new);
         WorldTimes worldTimesOfUser = db().query(WorldTimesQueries.fetchPlayerTotalWorldTimes(playerUUID));
         assertEquals(expected, worldTimesOfUser);
     }
@@ -149,7 +150,7 @@ public interface SessionQueriesTest extends DatabaseTestPreparer {
     default void serverWorldTimesMatchTotal() {
         worldTimesAreSavedWithSession();
         Session session = db().query(SessionQueries.fetchSessionsOfPlayer(playerUUID)).get(serverUUID()).get(0);
-        WorldTimes expected = session.getValue(SessionKeys.WORLD_TIMES).orElse(new WorldTimes());
+        WorldTimes expected = session.getValue(SessionKeys.WORLD_TIMES).orElseThrow(AssertionError::new);
         WorldTimes worldTimesOfServer = db().query(WorldTimesQueries.fetchServerTotalWorldTimes(serverUUID()));
         assertEquals(expected, worldTimesOfServer);
     }
@@ -160,4 +161,68 @@ public interface SessionQueriesTest extends DatabaseTestPreparer {
         assertEquals(new WorldTimes(), worldTimesOfServer);
     }
 
+    @Test
+    default void serverSessionsAreFetchedByPlayerUUID() {
+        prepareForSessionSave();
+        Session session = RandomData.randomSession(serverUUID(), worlds, playerUUID, player2UUID);
+        execute(DataStoreQueries.storeSession(session));
+
+        forcePersistenceCheck();
+
+        Map<UUID, List<Session>> expected = Collections.singletonMap(playerUUID, Collections.singletonList(session));
+        Map<UUID, List<Session>> fetched = db().query(SessionQueries.fetchSessionsOfServer(serverUUID()));
+
+        assertEquals(expected, fetched);
+    }
+
+    @Test
+    default void playerSessionsAreFetchedByServerUUID() {
+        prepareForSessionSave();
+
+        Session session = RandomData.randomSession(serverUUID(), worlds, playerUUID, player2UUID);
+        execute(DataStoreQueries.storeSession(session));
+
+        forcePersistenceCheck();
+
+        Map<UUID, List<Session>> expected = Collections.singletonMap(serverUUID(), Collections.singletonList(session));
+        Map<UUID, List<Session>> fetched = db().query(SessionQueries.fetchSessionsOfPlayer(playerUUID));
+        assertEquals(expected, fetched);
+    }
+
+    @Test
+    default void testKillTableGetKillsOfServer() {
+        prepareForSessionSave();
+
+        Session session = RandomData.randomSession(serverUUID(), worlds, playerUUID, player2UUID);
+        List<PlayerKill> expected = session.getPlayerKills();
+        execute(DataStoreQueries.storeSession(session));
+
+        forcePersistenceCheck();
+
+        Map<UUID, List<Session>> sessions = db().query(SessionQueries.fetchSessionsOfPlayer(playerUUID));
+        List<Session> savedSessions = sessions.get(serverUUID());
+        assertNotNull(savedSessions);
+        assertFalse(savedSessions.isEmpty());
+
+        List<PlayerKill> got = savedSessions.get(0).getPlayerKills();
+        assertEquals(expected, got);
+    }
+
+    @Test
+    default void sessionWorldTimesAreFetchedCorrectly() {
+        prepareForSessionSave();
+
+        Session session = RandomData.randomSession(serverUUID(), worlds, playerUUID, player2UUID);
+        WorldTimes expected = session.getValue(SessionKeys.WORLD_TIMES).orElseThrow(AssertionError::new);
+        execute(DataStoreQueries.storeSession(session));
+
+        // Fetch the session
+        Map<UUID, List<Session>> sessions = db().query(SessionQueries.fetchSessionsOfPlayer(playerUUID));
+        List<Session> serverSessions = sessions.get(serverUUID());
+        assertNotNull(serverSessions);
+        assertFalse(serverSessions.isEmpty());
+
+        WorldTimes got = serverSessions.get(0).getValue(SessionKeys.WORLD_TIMES).orElseThrow(AssertionError::new);
+        assertEquals(expected, got);
+    }
 }

Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/WebUserQueriesTest.java

@@ -0,0 +1,57 @@
+/*
+ *  This file is part of Player Analytics (Plan).
+ *
+ *  Plan is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License v3 as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Plan is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with Plan. If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.djrapitops.plan.storage.database.queries;
+
+import com.djrapitops.plan.delivery.domain.WebUser;
+import com.djrapitops.plan.storage.database.DatabaseTestPreparer;
+import com.djrapitops.plan.storage.database.queries.objects.WebUserQueries;
+import com.djrapitops.plan.storage.database.transactions.commands.RegisterWebUserTransaction;
+import com.djrapitops.plan.storage.database.transactions.commands.RemoveWebUserTransaction;
+import org.junit.jupiter.api.Test;
+import utilities.TestConstants;
+
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public interface WebUserQueriesTest extends DatabaseTestPreparer {
+
+    @Test
+    default void webUserIsRegistered() {
+        WebUser expected = new WebUser(TestConstants.PLAYER_ONE_NAME, "RandomGarbageBlah", 0);
+        db().executeTransaction(new RegisterWebUserTransaction(expected));
+        forcePersistenceCheck();
+
+        Optional<WebUser> found = db().query(WebUserQueries.fetchWebUser(TestConstants.PLAYER_ONE_NAME));
+        assertTrue(found.isPresent());
+        assertEquals(expected, found.get());
+    }
+
+    @Test
+    default void multipleWebUsersAreFetchedAppropriately() {
+        webUserIsRegistered();
+        assertEquals(1, db().query(WebUserQueries.fetchAllPlanWebUsers()).size());
+    }
+
+    @Test
+    default void webUserIsRemoved() {
+        webUserIsRegistered();
+        db().executeTransaction(new RemoveWebUserTransaction(TestConstants.PLAYER_ONE_NAME));
+        assertFalse(db().query(WebUserQueries.fetchWebUser(TestConstants.PLAYER_ONE_NAME)).isPresent());
+    }
+
+}

Plan/common/src/test/java/utilities/RandomData.java

@@ -16,6 +16,7 @@
  */
 package utilities;
 
+import com.djrapitops.plan.delivery.domain.Nickname;
 import com.djrapitops.plan.delivery.domain.WebUser;
 import com.djrapitops.plan.delivery.rendering.json.graphs.line.Point;
 import com.djrapitops.plan.gathering.domain.*;
@@ -56,6 +57,14 @@ public class RandomData {
         return RandomStringUtils.randomAlphanumeric(size);
     }
 
+    public static List<Nickname> randomNicknames(UUID serverUUID) {
+        return pickMultiple(randomInt(15, 30), () -> randomNickname(serverUUID));
+    }
+
+    public static Nickname randomNickname(UUID serverUUID) {
+        return new Nickname(randomString(randomInt(50, 100)), randomTime(), serverUUID);
+    }
+
     public static List<WebUser> randomWebUsers() throws PassEncryptUtil.CannotPerformOperationException {
         List<WebUser> test = new ArrayList<>();
         for (int i = 0; i < 20; i++) {

Plan/config/checkstyle/checkstyle.xml

@@ -10,8 +10,8 @@
         <property name="headerFile" value="${config_loc}/java.header"/>
     </module>
     <module name="FileLength">
-        <!-- This value is high. Notable: DatabaseTest 1521 -->
-        <property name="max" value="1750"/>
+        <!-- This value is alright. Notable: SessionQueries 808 -->
+        <property name="max" value="1000"/>
         <property name="fileExtensions" value=".java"/>
     </module>
     <module name="LineLength">
@@ -65,12 +65,12 @@
 
         <!-- Metrics -->
         <module name="ClassFanOutComplexity">
-            <!-- This value is high. Notable: DatabaseTest: 86, SQLDB: 56 -->
-            <property name="max" value="87"/>
+            <!-- This value is high. Notable: SQLDB: 57 -->
+            <property name="max" value="60"/>
         </module>
         <module name="CyclomaticComplexity">
-            <!-- This value is high. Notable: ActivityIndex: 18 -->
-            <property name="max" value="18"/>
+            <!-- This value is high. Notable: ThemeConfig: 16 -->
+            <property name="max" value="17"/>
         </module>
 
         <!-- Bugs -->