model/user: add unit test for user model

Author: clairep94

server/models/__test__/user.test.js

@@ -0,0 +1,123 @@
+import mongoose from 'mongoose';
+import bcrypt from 'bcryptjs';
+import User from '../user';
+
+beforeAll(async () => {
+  const mongoUri = 'mongodb://127.0.0.1:27017/test_db_user';
+  await mongoose.connect(mongoUri, {
+    dbName: 'test_db_user', // optional
+    autoIndex: true
+  });
+});
+
+afterAll(async () => {
+  await mongoose.connection.dropDatabase();
+  await mongoose.connection.close();
+});
+
+beforeEach(async () => {
+  await User.deleteMany({});
+});
+
+describe('User model', () => {
+  it('should hash password before saving', async () => {
+    const user = new User({
+      username: 'alice',
+      email: 'alice@example.com',
+      password: 'mypassword'
+    });
+    await user.save();
+
+    expect(user.password).not.toBe('mypassword');
+    const match = await bcrypt.compare('mypassword', user.password);
+    expect(match).toBe(true);
+  });
+
+  it('should compare passwords correctly', async () => {
+    const user = new User({
+      username: 'bob',
+      email: 'bob@example.com',
+      password: 'secret'
+    });
+    await user.save();
+
+    const isMatch = await user.comparePassword('secret');
+    expect(isMatch).toBe(true);
+
+    const isNotMatch = await user.comparePassword('wrong');
+    expect(isNotMatch).toBe(false);
+  });
+
+  it('should expose virtual id as string', async () => {
+    const user = new User({
+      username: 'carol',
+      email: 'carol@example.com',
+      password: 'pass123'
+    });
+    await user.save();
+
+    expect(user.id).toBe(user._id.toHexString());
+  });
+
+  it('should include virtuals in toJSON output', () => {
+    const user = new User({
+      username: 'testuser',
+      email: 'test@example.com',
+      password: 'secret'
+    });
+    expect(user.id).toBe(user._id.toHexString());
+
+    const json = user.toJSON();
+
+    // check that virtual id is included in the serialized output
+    expect(json).toHaveProperty('id', user._id.toHexString());
+
+    // check that regular fields are also present
+    expect(json).toHaveProperty('username', 'testuser');
+    expect(json).toHaveProperty('email', 'test@example.com');
+  });
+
+  it('should find user by email (case insensitive)', async () => {
+    await new User({
+      username: 'dave',
+      email: 'Dave@Example.com',
+      password: 'pass'
+    }).save();
+
+    const found = await User.findByEmail('dave@example.com');
+    expect(found).not.toBeNull();
+    expect(found.username).toBe('dave');
+  });
+
+  it('should find user by username (case insensitive)', async () => {
+    await new User({
+      username: 'Eve',
+      email: 'eve@example.com',
+      password: 'pass'
+    }).save();
+
+    const found = await User.findByUsername('eve', { caseInsensitive: true });
+    expect(found).not.toBeNull();
+    expect(found.email).toBe('eve@example.com');
+  });
+
+  it('should return null for wrong username/email', async () => {
+    const found = await User.findByEmail('nope@example.com');
+    expect(found).toBeNull();
+  });
+
+  it('should hash apiKeys on save and find matching key', async () => {
+    const user = new User({
+      username: 'frank',
+      email: 'frank@example.com',
+      apiKeys: [{ hashedKey: 'hashedApiKey' }] // gets hashed by bcrypt in pre-save
+    });
+    await user.save();
+
+    const savedUser = await User.findOne({ email: 'frank@example.com' });
+    const keyObj = await savedUser.findMatchingKey('hashedApiKey');
+
+    expect(keyObj.isMatch).toBe(true);
+    expect(keyObj.keyDocument).not.toBeNull();
+  });
+});

server/models/apiKey.js

@@ -1,4 +1,4 @@
-import mongoose, { Schema } from 'mongoose';
+import { Schema } from 'mongoose';
 
 export const apiKeySchema = new Schema(
   {