diff --git a/backend/src/__tests__/socket.test.js b/backend/src/__tests__/socket.test.js
index fe5aa90..63e5669 100644
--- a/backend/src/__tests__/socket.test.js
+++ b/backend/src/__tests__/socket.test.js
@@ -50,10 +50,12 @@ describe('Socket.IO Server', () => {
   });
 
   afterAll(async () => {
-    // Cleanup test user
-    await prisma.user.delete({
-      where: { id: testUser.id },
-    });
+    // Cleanup test user (using deleteMany to avoid errors if already deleted)
+    if (testUser?.id) {
+      await prisma.user.deleteMany({
+        where: { id: testUser.id },
+      });
+    }
 
     // Close server and client
     if (clientSocket) clientSocket.close();
@@ -131,28 +133,42 @@ describe('Socket.IO Server', () => {
       });
 
       // Create event participant (check-in) for test user
-      await prisma.eventParticipant.create({
-        data: {
-          userId: testUser.id,
-          eventId: testEvent.id,
-        },
+      // Check if user exists first to avoid foreign key constraint errors
+      const userExists = await prisma.user.findUnique({
+        where: { id: testUser.id },
       });
+      if (userExists) {
+        await prisma.eventParticipant.create({
+          data: {
+            userId: testUser.id,
+            eventId: testEvent.id,
+          },
+        }).catch(() => {
+          // Ignore if already exists or other errors
+        });
+      }
     });
 
     afterAll(async () => {
-      // Cleanup test data
-      await prisma.eventParticipant.deleteMany({
-        where: {
-          userId: testUser.id,
-          eventId: testEvent.id,
-        },
-      });
-      await prisma.chatRoom.delete({
-        where: { id: testChatRoom.id },
-      });
-      await prisma.event.delete({
-        where: { id: testEvent.id },
-      });
+      // Cleanup test data (using deleteMany to avoid errors if already deleted)
+      if (testUser?.id && testEvent?.id) {
+        await prisma.eventParticipant.deleteMany({
+          where: {
+            userId: testUser.id,
+            eventId: testEvent.id,
+          },
+        });
+      }
+      if (testChatRoom?.id) {
+        await prisma.chatRoom.deleteMany({
+          where: { id: testChatRoom.id },
+        });
+      }
+      if (testEvent?.id) {
+        await prisma.event.deleteMany({
+          where: { id: testEvent.id },
+        });
+      }
     });
 
     test('should join event room successfully', (done) => {
@@ -323,19 +339,27 @@ describe('Socket.IO Server', () => {
     });
 
     afterAll(async () => {
-      // Cleanup
-      await prisma.match.delete({
-        where: { id: testMatch.id },
-      });
-      await prisma.chatRoom.delete({
-        where: { id: testMatchRoom.id },
-      });
-      await prisma.user.delete({
-        where: { id: testUser2.id },
-      });
-      await prisma.event.delete({
-        where: { id: testEvent.id },
-      });
+      // Cleanup (using deleteMany to avoid errors if already deleted)
+      if (testMatch?.id) {
+        await prisma.match.deleteMany({
+          where: { id: testMatch.id },
+        });
+      }
+      if (testMatchRoom?.id) {
+        await prisma.chatRoom.deleteMany({
+          where: { id: testMatchRoom.id },
+        });
+      }
+      if (testUser2?.id) {
+        await prisma.user.deleteMany({
+          where: { id: testUser2.id },
+        });
+      }
+      if (testEvent?.id) {
+        await prisma.event.deleteMany({
+          where: { id: testEvent.id },
+        });
+      }
     });
 
     test('should join match room successfully', (done) => {
@@ -444,27 +468,42 @@ describe('Socket.IO Server', () => {
       });
 
       // Create event participant (check-in) for test user
-      await prisma.eventParticipant.create({
-        data: {
-          userId: testUser.id,
-          eventId: testEvent.id,
-        },
+      // Check if user exists first to avoid foreign key constraint errors
+      const userExists = await prisma.user.findUnique({
+        where: { id: testUser.id },
       });
+      if (userExists) {
+        await prisma.eventParticipant.create({
+          data: {
+            userId: testUser.id,
+            eventId: testEvent.id,
+          },
+        }).catch(() => {
+          // Ignore if already exists or other errors
+        });
+      }
     });
 
     afterAll(async () => {
-      await prisma.eventParticipant.deleteMany({
-        where: {
-          userId: testUser.id,
-          eventId: testEvent.id,
-        },
-      });
-      await prisma.chatRoom.delete({
-        where: { id: testChatRoom.id },
-      });
-      await prisma.event.delete({
-        where: { id: testEvent.id },
-      });
+      // Cleanup (using deleteMany to avoid errors if already deleted)
+      if (testUser?.id && testEvent?.id) {
+        await prisma.eventParticipant.deleteMany({
+          where: {
+            userId: testUser.id,
+            eventId: testEvent.id,
+          },
+        });
+      }
+      if (testChatRoom?.id) {
+        await prisma.chatRoom.deleteMany({
+          where: { id: testChatRoom.id },
+        });
+      }
+      if (testEvent?.id) {
+        await prisma.event.deleteMany({
+          where: { id: testEvent.id },
+        });
+      }
     });
 
     test('should handle disconnect and update active users', (done) => {
@@ -520,24 +559,37 @@ describe('Socket.IO Server', () => {
       });
 
       // Create event participant (check-in) for test user
-      await prisma.eventParticipant.create({
-        data: {
-          userId: testUser.id,
-          eventId: testEvent.id,
-        },
+      // Check if user exists first to avoid foreign key constraint errors
+      const userExists = await prisma.user.findUnique({
+        where: { id: testUser.id },
       });
+      if (userExists) {
+        await prisma.eventParticipant.create({
+          data: {
+            userId: testUser.id,
+            eventId: testEvent.id,
+          },
+        }).catch(() => {
+          // Ignore if already exists or other errors
+        });
+      }
     });
 
     afterAll(async () => {
-      await prisma.eventParticipant.deleteMany({
-        where: {
-          userId: testUser.id,
-          eventId: testEvent.id,
-        },
-      });
-      await prisma.event.delete({
-        where: { id: testEvent.id },
-      });
+      // Cleanup (using deleteMany to avoid errors if already deleted)
+      if (testUser?.id && testEvent?.id) {
+        await prisma.eventParticipant.deleteMany({
+          where: {
+            userId: testUser.id,
+            eventId: testEvent.id,
+          },
+        });
+      }
+      if (testEvent?.id) {
+        await prisma.event.deleteMany({
+          where: { id: testEvent.id },
+        });
+      }
     });
 
     test('should handle chat room not found error', (done) => {