@studious-lms/server 1.2.45 → 1.2.47

package/tests/setup.ts

@@ -1,4 +1,6 @@
 import { execSync } from 'child_process';
+import { config } from 'dotenv';
+import { resolve } from 'path';
 import { prisma } from '../src/lib/prisma';
 import { beforeAll, beforeEach, afterAll, afterEach } from 'vitest';
 import { logger } from '../src/utils/logger';
@@ -7,26 +9,31 @@ import { createTRPCContext } from '../src/trpc';
 import { Session } from '@prisma/client';
 import { clearDatabase } from '../src/seedDatabase';
 
+// Load test environment variables
+config({ path: resolve(process.cwd(), '.env.test') });
+
 const getCaller = async (token: string) => {
   const ctx = await createTRPCContext({
     req: { headers: {
-      authorization: `Bearer ${token}`,
-      'x-user': token,
+      authorization: token ? `Bearer ${token}` : undefined,
+      'x-user': token || undefined,
     } } as any,
     res: {} as any,
   });
   return appRouter.createCaller(ctx);
 };
 
-  // Before the entire test suite runs
-  beforeAll(async () => {
-
+// Before the entire test suite runs
+beforeAll(async () => {
+  try {
+    logger.info('DATABASE_URL: ' + process.env.DATABASE_URL);
     await clearDatabase();
+    logger.info('Database cleared for tests');
 
-    logger.info('Getting caller');
-
+    // Create public caller (no auth) for registration
     caller = await getCaller('');
 
+    // Register users
     const user1 = await caller.auth.register({
       username: 'testuser1',
       email: 'test@test.com',
@@ -41,18 +48,37 @@ const getCaller = async (token: string) => {
       confirmPassword: 'password_is_1234',
     });
 
+    const user3 = await caller.auth.register({
+      username: 'testuser3',
+      email: 'test3@test.com',
+      password: 'password_is_1234',
+      confirmPassword: 'password_is_1234',
+    });
+
+    // Get sessions created during registration
     session1 = await prisma.session.findFirst({
       where: {
         userId: user1.user.id,
       },
     }) as Session;
 
-    session2 = (await prisma.session.findFirst({
+    session2 = await prisma.session.findFirst({
       where: {
         userId: user2.user.id,
       },
-    })) as Session;
+    }) as Session;
+
+    session3 = await prisma.session.findFirst({ 
+      where: {
+        userId: user3.user.id,
+      },
+    }) as Session;
 
+    if (!session1 || !session2 || !session3) {
+      throw new Error('Failed to create sessions for test users');
+    }
+
+    // Verify emails using session tokens
     verification1 = await caller.auth.verify({
       token: session1.id,
     });
@@ -61,6 +87,11 @@ const getCaller = async (token: string) => {
       token: session2.id,
     });
 
+    verification3 = await caller.auth.verify({
+      token: session3.id,
+    });
+
+    // Login to get fresh tokens
     login1 = await caller.auth.login({
       username: 'testuser1',
       password: 'password_is_1234',
@@ -71,22 +102,45 @@ const getCaller = async (token: string) => {
       password: 'password_is_1234',
     });
 
-    user1Caller = await getCaller(login1.token);
-    user2Caller = await getCaller(login2.token);
-  });
+    login3 = await caller.auth.login({
+      username: 'testuser3',
+      password: 'password_is_1234',
+    });
 
+    if (!login1.token || !login2.token || !login3.token) {
+      throw new Error('Failed to get login tokens');
+    }
 
-  // After all tests, close the DB
-  afterAll(async () => {
+    // Create authenticated callers
+    user1Caller = await getCaller(login1.token);
+    user2Caller = await getCaller(login2.token);
+    user3Caller = await getCaller(login3.token);
+    logger.info('Test setup completed successfully');
+  } catch (error) {
+    logger.error('Test setup failed', { error });
+    throw error;
+  }
+});
+
+// After all tests, close the DB
+afterAll(async () => {
+  try {
     await prisma.$disconnect();
-  });
+  } catch (error) {
+    logger.error('Error disconnecting from database', { error });
+  }
+});
 
 export let user1Caller: ReturnType<typeof appRouter.createCaller>;
 export let user2Caller: ReturnType<typeof appRouter.createCaller>;
+export let user3Caller: ReturnType<typeof appRouter.createCaller>;
 export let caller: ReturnType<typeof appRouter.createCaller>;
 export let session1: Session;
 export let session2: Session;
+export let session3: Session;
 export let verification1: any;
 export let verification2: any;
+export let verification3: any;
 export let login1: any;
-export let login2: any;
+export let login2: any;
+export let login3: any;

package/tests/user.test.ts

@@ -0,0 +1,158 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+import { user1Caller, user2Caller } from './setup';
+import { createTRPCContext } from '../src/trpc';
+import { appRouter } from '../src/routers/_app';
+
+describe('User Router', () => {
+  describe('getProfile', () => {
+    test('should get user profile successfully', async () => {
+      const profile = await user1Caller.user.getProfile();
+      
+      expect(profile).toBeDefined();
+      expect(profile.id).toBeDefined();
+      expect(profile.username).toBe('testuser1');
+      expect(profile.profile).toBeDefined();
+      expect(profile.profile.displayName).toBeNull();
+      expect(profile.profile.bio).toBeNull();
+      expect(profile.profile.location).toBeNull();
+      expect(profile.profile.website).toBeNull();
+      expect(profile.profile.profilePicture).toBeNull();
+    });
+
+    test('should fail without authentication', async () => {
+      const invalidCaller = await createTRPCContext({
+        req: { headers: {} } as any,
+        res: {} as any,
+      });
+      const router = appRouter.createCaller(invalidCaller);
+      
+      await expect(router.user.getProfile()).rejects.toThrow();
+    });
+  });
+
+  describe('updateProfile', () => {
+    test('should update profile with display name and bio', async () => {
+      const updated = await user1Caller.user.updateProfile({
+        profile: {
+          displayName: 'Test User One',
+          bio: 'This is a test bio',
+          location: 'Test City',
+          website: 'https://example.com',
+        },
+      });
+
+      expect(updated).toBeDefined();
+      expect(updated.profile.displayName).toBe('Test User One');
+      expect(updated.profile.bio).toBe('This is a test bio');
+      expect(updated.profile.location).toBe('Test City');
+      expect(updated.profile.website).toBe('https://example.com');
+    });
+
+    test('should update profile with partial data', async () => {
+      const updated = await user2Caller.user.updateProfile({
+        profile: {
+          displayName: 'Test User Two',
+        },
+      });
+
+      expect(updated.profile.displayName).toBe('Test User Two');
+    });
+
+    test('should update profile with DiceBear avatar', async () => {
+      const updated = await user1Caller.user.updateProfile({
+        dicebearAvatar: {
+          url: 'https://api.dicebear.com/7.x/avataaars/svg?seed=test',
+        },
+      });
+
+      expect(updated.profile.profilePicture).toBe('https://api.dicebear.com/7.x/avataaars/svg?seed=test');
+    });
+
+    // test('should clear profile fields when set to null', async () => {
+    //   // First set some values
+    //   await user1Caller.user.updateProfile({
+    //     profile: {
+    //       displayName: 'Test Name',
+    //       bio: 'Test Bio',
+    //     },
+    //   });
+
+    //   // Then clear them
+    //   const cleared = await user1Caller.user.updateProfile({
+    //     profile: {
+    //       displayName: null,
+    //       bio: null,
+    //     },
+    //   });
+
+    //   expect(cleared.profile.displayName).toBeNull();
+    //   expect(cleared.profile.bio).toBeNull();
+    // });
+
+    test('should fail without authentication', async () => {
+      const invalidCaller = await createTRPCContext({
+        req: { headers: {} } as any,
+        res: {} as any,
+      });
+      const router = appRouter.createCaller(invalidCaller);
+      
+      await expect(router.user.updateProfile({
+        profile: { displayName: 'Test' },
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('getUploadUrl', () => {
+    test('should generate upload URL for valid image file', async () => {
+      const result = await user1Caller.user.getUploadUrl({
+        fileName: 'profile.jpg',
+        fileType: 'image/jpeg',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.uploadUrl).toBeDefined();
+      expect(result.filePath).toBeDefined();
+      expect(result.fileName).toBeDefined();
+      expect(result.filePath).toContain('users/');
+      expect(result.filePath).toContain('/profile/');
+    });
+
+    test('should generate upload URL for PNG file', async () => {
+      const result = await user1Caller.user.getUploadUrl({
+        fileName: 'avatar.png',
+        fileType: 'image/png',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.fileName).toContain('.png');
+    });
+
+    test('should fail for invalid file type', async () => {
+      await expect(user1Caller.user.getUploadUrl({
+        fileName: 'document.pdf',
+        fileType: 'application/pdf',
+      })).rejects.toThrow();
+    });
+
+    test('should fail for empty file name', async () => {
+      await expect(user1Caller.user.getUploadUrl({
+        fileName: '',
+        fileType: 'image/jpeg',
+      })).rejects.toThrow();
+    });
+
+    test('should fail without authentication', async () => {
+      const invalidCaller = await createTRPCContext({
+        req: { headers: {} } as any,
+        res: {} as any,
+      });
+      const router = appRouter.createCaller(invalidCaller);
+      
+      await expect(router.user.getUploadUrl({
+        fileName: 'test.jpg',
+        fileType: 'image/jpeg',
+      })).rejects.toThrow();
+    });
+  });
+});
+

package/vitest.config.ts

@@ -1,11 +1,37 @@
 import { defineConfig } from 'vitest/config';
+import { config } from 'dotenv';
+import { resolve } from 'path';
+
+// Load test environment variables before anything else
+config({ path: resolve(process.cwd(), '.env.test'), override: true });
 
 export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
     hookTimeout: 60000, // 60 seconds
+    testTimeout: 30000, // 30 seconds per test
     include: ['tests/**/*.test.ts'],
     setupFiles: ['./tests/setup.ts'], // run setup before tests
+    // Run tests sequentially to avoid database conflicts
+    // Can be changed to true once tests are fully isolated
+    sequence: {
+      concurrent: false,
+    },
+    coverage: {
+      exclude: [
+        "generated/**",
+        "prisma/**",
+        "scripts/**",
+        "src/lib/prisma.ts",
+        "src/seedDatabase.ts",
+        "src/socket/**",
+        "**/node_modules/**",
+        "**/dist/**",
+      ],
+    },
+    env: {
+      NODE_ENV: 'test',
+    },
   },
 });