diff --git a/test/db_tests/game_test.dart b/test/db_tests/game_test.dart
index 4f4b23f..0c86e45 100644
--- a/test/db_tests/game_test.dart
+++ b/test/db_tests/game_test.dart
@@ -1,3 +1,4 @@
+import 'package:clock/clock.dart';
 import 'package:drift/drift.dart';
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
@@ -15,6 +16,8 @@ void main() {
   late Player player5;
   late Group testgroup;
   late Game testgame;
+  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
 
   setUp(() {
     database = AppDatabase(
@@ -25,17 +28,22 @@ void main() {
       ),
     );
 
-    player1 = Player(name: 'Alice');
-    player2 = Player(name: 'Bob');
-    player3 = Player(name: 'Charlie');
-    player4 = Player(name: 'Diana');
-    player5 = Player(name: 'Eve');
-    testgroup = Group(name: 'Test Group', members: [player1, player2, player3]);
-    testgame = Game(
-      name: 'Test Game',
-      group: testgroup,
-      players: [player4, player5],
-    );
+    withClock(fakeClock, () {
+      player1 = Player(name: 'Alice');
+      player2 = Player(name: 'Bob');
+      player3 = Player(name: 'Charlie');
+      player4 = Player(name: 'Diana');
+      player5 = Player(name: 'Eve');
+      testgroup = Group(
+        name: 'Test Group',
+        members: [player1, player2, player3],
+      );
+      testgame = Game(
+        name: 'Test Game',
+        group: testgroup,
+        players: [player4, player5],
+      );
+    });
   });
   tearDown(() async {
     await database.close();
@@ -43,34 +51,41 @@ void main() {
 
   group('game tests', () {
     test('game is added correctly', () async {
-      await database.gameDao.addGame(game: testgame);
+      await withClock(fakeClock, () async {
+        await database.gameDao.addGame(game: testgame);
 
-      final result = await database.gameDao.getGameById(gameId: testgame.id);
+        final result = await database.gameDao.getGameById(gameId: testgame.id);
 
-      expect(result.id, testgame.id);
-      expect(result.name, testgame.name);
-      expect(result.winner, testgame.winner);
+        expect(result.id, testgame.id);
+        expect(result.name, testgame.name);
+        expect(result.winner, testgame.winner);
+        expect(result.createdAt, testgame.createdAt);
 
-      if (result.group != null) {
-        expect(result.group!.members.length, testgroup.members.length);
+        if (result.group != null) {
+          expect(result.group!.members.length, testgroup.members.length);
 
-        for (int i = 0; i < testgroup.members.length; i++) {
-          expect(result.group!.members[i].id, testgroup.members[i].id);
-          expect(result.group!.members[i].name, testgroup.members[i].name);
+          for (int i = 0; i < testgroup.members.length; i++) {
+            expect(result.group!.members[i].id, testgroup.members[i].id);
+            expect(result.group!.members[i].name, testgroup.members[i].name);
+          }
+        } else {
+          fail('Group is null');
         }
-      } else {
-        fail('Group is null');
-      }
-      if (result.players != null) {
-        expect(result.players!.length, testgame.players!.length);
+        if (result.players != null) {
+          expect(result.players!.length, testgame.players!.length);
 
-        for (int i = 0; i < testgame.players!.length; i++) {
-          expect(result.players![i].id, testgame.players![i].id);
-          expect(result.players![i].name, testgame.players![i].name);
+          for (int i = 0; i < testgame.players!.length; i++) {
+            expect(result.players![i].id, testgame.players![i].id);
+            expect(result.players![i].name, testgame.players![i].name);
+            expect(
+              result.players![i].createdAt,
+              testgame.players![i].createdAt,
+            );
+          }
+        } else {
+          fail('Players is null');
         }
-      } else {
-        fail('Players is null');
-      }
+      });
     });
 
     test('game is deleted correctly', () async {
diff --git a/test/db_tests/group_test.dart b/test/db_tests/group_test.dart
index 3a9d8ca..5730617 100644
--- a/test/db_tests/group_test.dart
+++ b/test/db_tests/group_test.dart
@@ -1,3 +1,4 @@
+import 'package:clock/clock.dart';
 import 'package:drift/drift.dart';
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
@@ -12,6 +13,8 @@ void main() {
   late Player player3;
   late Player player4;
   late Group testgroup;
+  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
 
   setUp(() {
     database = AppDatabase(
@@ -22,54 +25,69 @@ void main() {
       ),
     );
 
-    player1 = Player(name: 'Alice');
-    player2 = Player(name: 'Bob');
-    player3 = Player(name: 'Charlie');
-    player4 = Player(name: 'Diana');
-    testgroup = Group(name: 'Test Group', members: [player1, player2, player3]);
+    withClock(fakeClock, () {
+      player1 = Player(name: 'Alice');
+      player2 = Player(name: 'Bob');
+      player3 = Player(name: 'Charlie');
+      player4 = Player(name: 'Diana');
+      testgroup = Group(
+        name: 'Test Group',
+        members: [player1, player2, player3],
+      );
+    });
   });
   tearDown(() async {
     await database.close();
   });
   group('group tests', () {
     test('all groups get fetched correctly', () async {
-      final testgroup2 = Group(
-        id: 'gr2',
-        name: 'Second Group',
-        members: [player2, player3, player4],
-      );
-      await database.groupDao.addGroup(group: testgroup);
-      await database.groupDao.addGroup(group: testgroup2);
+      await withClock(fakeClock, () async {
+        final testgroup2 = Group(
+          id: 'gr2',
+          name: 'Second Group',
+          members: [player2, player3, player4],
+        );
+        await database.groupDao.addGroup(group: testgroup);
+        await database.groupDao.addGroup(group: testgroup2);
 
-      final allGroups = await database.groupDao.getAllGroups();
-      expect(allGroups.length, 2);
+        final allGroups = await database.groupDao.getAllGroups();
+        expect(allGroups.length, 2);
 
-      final fetchedGroup1 = allGroups.firstWhere((g) => g.id == testgroup.id);
-      expect(fetchedGroup1.name, testgroup.name);
-      expect(fetchedGroup1.members.length, testgroup.members.length);
-      expect(fetchedGroup1.members.elementAt(0).id, player1.id);
+        final fetchedGroup1 = allGroups.firstWhere((g) => g.id == testgroup.id);
+        expect(fetchedGroup1.name, testgroup.name);
+        expect(fetchedGroup1.members.length, testgroup.members.length);
+        expect(fetchedGroup1.members.elementAt(0).id, player1.id);
+        expect(fetchedGroup1.members.elementAt(0).createdAt, player1.createdAt);
 
-      final fetchedGroup2 = allGroups.firstWhere((g) => g.id == testgroup2.id);
-      expect(fetchedGroup2.name, testgroup2.name);
-      expect(fetchedGroup2.members.length, testgroup2.members.length);
-      expect(fetchedGroup2.members.elementAt(0).id, player2.id);
+        final fetchedGroup2 = allGroups.firstWhere(
+          (g) => g.id == testgroup2.id,
+        );
+        expect(fetchedGroup2.name, testgroup2.name);
+        expect(fetchedGroup2.members.length, testgroup2.members.length);
+        expect(fetchedGroup2.members.elementAt(0).id, player2.id);
+        expect(fetchedGroup2.members.elementAt(0).createdAt, player2.createdAt);
+      });
     });
 
     test('group and group members gets added correctly', () async {
-      await database.groupDao.addGroup(group: testgroup);
+      await withClock(fakeClock, () async {
+        await database.groupDao.addGroup(group: testgroup);
 
-      final result = await database.groupDao.getGroupById(
-        groupId: testgroup.id,
-      );
+        final result = await database.groupDao.getGroupById(
+          groupId: testgroup.id,
+        );
 
-      expect(result.id, testgroup.id);
-      expect(result.name, testgroup.name);
+        expect(result.id, testgroup.id);
+        expect(result.name, testgroup.name);
+        expect(result.createdAt, testgroup.createdAt);
 
-      expect(result.members.length, testgroup.members.length);
-      for (int i = 0; i < testgroup.members.length; i++) {
-        expect(result.members[i].id, testgroup.members[i].id);
-        expect(result.members[i].name, testgroup.members[i].name);
-      }
+        expect(result.members.length, testgroup.members.length);
+        for (int i = 0; i < testgroup.members.length; i++) {
+          expect(result.members[i].id, testgroup.members[i].id);
+          expect(result.members[i].name, testgroup.members[i].name);
+          expect(result.members[i].createdAt, testgroup.members[i].createdAt);
+        }
+      });
     });
 
     test('group gets deleted correctly', () async {
@@ -103,36 +121,39 @@ void main() {
     });
 
     test('Adding player to group works correctly', () async {
-      await database.groupDao.addGroup(group: testgroup);
+      await withClock(fakeClock, () async {
+        await database.groupDao.addGroup(group: testgroup);
 
-      await database.playerGroupDao.addPlayerToGroup(
-        player: player4,
-        groupId: testgroup.id,
-      );
+        await database.playerGroupDao.addPlayerToGroup(
+          player: player4,
+          groupId: testgroup.id,
+        );
 
-      final playerAdded = await database.playerGroupDao.isPlayerInGroup(
-        playerId: player4.id,
-        groupId: testgroup.id,
-      );
+        final playerAdded = await database.playerGroupDao.isPlayerInGroup(
+          playerId: player4.id,
+          groupId: testgroup.id,
+        );
 
-      expect(playerAdded, true);
+        expect(playerAdded, true);
 
-      final playerNotAdded = !await database.playerGroupDao.isPlayerInGroup(
-        playerId: '',
-        groupId: testgroup.id,
-      );
+        final playerNotAdded = !await database.playerGroupDao.isPlayerInGroup(
+          playerId: '',
+          groupId: testgroup.id,
+        );
 
-      expect(playerNotAdded, true);
+        expect(playerNotAdded, true);
 
-      expect(playerAdded, true);
+        final result = await database.groupDao.getGroupById(
+          groupId: testgroup.id,
+        );
+        expect(result.members.length, testgroup.members.length + 1);
 
-      final result = await database.groupDao.getGroupById(
-        groupId: testgroup.id,
-      );
-      expect(result.members.length, testgroup.members.length + 1);
-
-      final addedPlayer = result.members.firstWhere((p) => p.id == player4.id);
-      expect(addedPlayer.name, player4.name);
+        final addedPlayer = result.members.firstWhere(
+          (p) => p.id == player4.id,
+        );
+        expect(addedPlayer.name, player4.name);
+        expect(addedPlayer.createdAt, player4.createdAt);
+      });
     });
 
     test('Removing player from group works correctly', () async {
diff --git a/test/db_tests/player_test.dart b/test/db_tests/player_test.dart
index 91f4acb..ce75297 100644
--- a/test/db_tests/player_test.dart
+++ b/test/db_tests/player_test.dart
@@ -1,3 +1,4 @@
+import 'package:clock/clock.dart';
 import 'package:drift/drift.dart';
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
@@ -7,6 +8,8 @@ import 'package:game_tracker/data/dto/player.dart';
 void main() {
   late AppDatabase database;
   late Player testPlayer;
+  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
 
   setUp(() {
     database = AppDatabase(
@@ -17,7 +20,9 @@ void main() {
       ),
     );
 
-    testPlayer = Player(name: 'Test Player');
+    withClock(fakeClock, () {
+      testPlayer = Player(name: 'Test Player');
+    });
   });
   tearDown(() async {
     await database.close();
@@ -25,32 +30,39 @@ void main() {
 
   group('player tests', () {
     test('all players get fetched correctly', () async {
-      final testPlayer2 = Player(name: 'Second Group');
-      await database.playerDao.addPlayer(player: testPlayer);
-      await database.playerDao.addPlayer(player: testPlayer2);
+      await withClock(fakeClock, () async {
+        final testPlayer2 = Player(name: 'Second Group');
+        await database.playerDao.addPlayer(player: testPlayer);
+        await database.playerDao.addPlayer(player: testPlayer2);
 
-      final allPlayers = await database.playerDao.getAllPlayers();
-      expect(allPlayers.length, 2);
+        final allPlayers = await database.playerDao.getAllPlayers();
+        expect(allPlayers.length, 2);
 
-      final fetchedPlayer1 = allPlayers.firstWhere(
-        (g) => g.id == testPlayer.id,
-      );
-      expect(fetchedPlayer1.name, testPlayer.name);
+        final fetchedPlayer1 = allPlayers.firstWhere(
+          (g) => g.id == testPlayer.id,
+        );
+        expect(fetchedPlayer1.name, testPlayer.name);
+        expect(fetchedPlayer1.createdAt, testPlayer.createdAt);
 
-      final fetchedPlayer2 = allPlayers.firstWhere(
-        (g) => g.id == testPlayer2.id,
-      );
-      expect(fetchedPlayer2.name, testPlayer2.name);
+        final fetchedPlayer2 = allPlayers.firstWhere(
+          (g) => g.id == testPlayer2.id,
+        );
+        expect(fetchedPlayer2.name, testPlayer2.name);
+        expect(fetchedPlayer2.createdAt, testPlayer2.createdAt);
+      });
     });
 
     test('players get inserted correcly ', () async {
-      await database.playerDao.addPlayer(player: testPlayer);
-      final result = await database.playerDao.getPlayerById(
-        playerId: testPlayer.id,
-      );
+      await withClock(fakeClock, () async {
+        await database.playerDao.addPlayer(player: testPlayer);
+        final result = await database.playerDao.getPlayerById(
+          playerId: testPlayer.id,
+        );
 
-      expect(result.id, testPlayer.id);
-      expect(result.name, testPlayer.name);
+        expect(result.id, testPlayer.id);
+        expect(result.name, testPlayer.name);
+        expect(result.createdAt, testPlayer.createdAt);
+      });
     });
 
     test('players get deleted correcly ', () async {