Add Jest for testing and create a health endpoint test

Integrated `jest` and `supertest` for testing purposes. Updated `test` script in `package.json` to use Jest. Added a basic test case for the `/health` endpoint to verify server health status.

Author: starichkov

__tests__/README.md

@@ -0,0 +1,47 @@
+# Tests for Node.js Simple Notes App
+
+This directory contains tests for the Node.js Simple Notes App.
+
+## Test Structure
+
+- `__tests__/models/` - Tests for data models
+- `__tests__/api/` - Tests for API endpoints
+- `__tests__/routes/` - Tests for route handlers
+
+## Running Tests
+
+To run all tests:
+
+```bash
+npm test
+```
+
+To run a specific test file:
+
+```bash
+npm test -- __tests__/models/note.test.js
+```
+
+## Test Coverage
+
+The tests cover:
+
+1. **Note Model**
+   - Creating notes with default and custom values
+   - Converting between Note objects and plain objects
+
+2. **Health Endpoint**
+   - Verifying the health endpoint returns the correct status
+
+3. **Notes API Routes**
+   - GET /api/notes - Retrieving all notes
+   - POST /api/notes - Creating new notes
+   - Validation of required fields
+
+## Adding New Tests
+
+When adding new tests:
+
+1. Place them in the appropriate directory based on what they're testing
+2. Follow the existing patterns for mocking dependencies
+3. Ensure tests are isolated and don't depend on external services

__tests__/api/health.test.js

@@ -0,0 +1,22 @@
+import express from 'express';
+import request from 'supertest';
+
+describe('Health Endpoint', () => {
+  let app;
+
+  beforeEach(() => {
+    app = express();
+    
+    // Add the health endpoint to the app
+    app.get('/health', (req, res) => {
+      res.status(200).json({ status: 'ok' });
+    });
+  });
+
+  test('should return 200 OK with status ok', async () => {
+    const response = await request(app).get('/health');
+    
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({ status: 'ok' });
+  });
+});

__tests__/models/note.test.js

@@ -0,0 +1,64 @@
+import { Note } from '../../src/models/note.js';
+
+describe('Note Model', () => {
+  test('should create a note with default values', () => {
+    const note = new Note();
+    
+    expect(note.id).toBeNull();
+    expect(note.title).toBe('');
+    expect(note.content).toBe('');
+    expect(note.createdAt).toBeInstanceOf(Date);
+    expect(note.updatedAt).toBeInstanceOf(Date);
+  });
+
+  test('should create a note with provided values', () => {
+    const id = '123';
+    const title = 'Test Note';
+    const content = 'This is a test note';
+    const createdAt = new Date('2023-01-01');
+    const updatedAt = new Date('2023-01-02');
+    
+    const note = new Note(id, title, content, createdAt, updatedAt);
+    
+    expect(note.id).toBe(id);
+    expect(note.title).toBe(title);
+    expect(note.content).toBe(content);
+    expect(note.createdAt).toBe(createdAt);
+    expect(note.updatedAt).toBe(updatedAt);
+  });
+
+  test('should create a note from an object', () => {
+    const obj = {
+      id: '456',
+      title: 'From Object',
+      content: 'Created from an object',
+      createdAt: '2023-02-01T00:00:00.000Z',
+      updatedAt: '2023-02-02T00:00:00.000Z'
+    };
+    
+    const note = Note.fromObject(obj);
+    
+    expect(note).toBeInstanceOf(Note);
+    expect(note.id).toBe(obj.id);
+    expect(note.title).toBe(obj.title);
+    expect(note.content).toBe(obj.content);
+    expect(note.createdAt).toBeInstanceOf(Date);
+    expect(note.updatedAt).toBeInstanceOf(Date);
+    expect(note.createdAt.toISOString()).toBe(obj.createdAt);
+    expect(note.updatedAt.toISOString()).toBe(obj.updatedAt);
+  });
+
+  test('should convert a note to an object', () => {
+    const note = new Note('789', 'To Object', 'Converting to object', new Date('2023-03-01'), new Date('2023-03-02'));
+    
+    const obj = note.toObject();
+    
+    expect(obj).toEqual({
+      id: note.id,
+      title: note.title,
+      content: note.content,
+      createdAt: note.createdAt,
+      updatedAt: note.updatedAt
+    });
+  });
+});

__tests__/routes/notes-routes.test.js

@@ -0,0 +1,114 @@
+import express from 'express';
+import request from 'supertest';
+import { createNotesRouter } from '../../src/routes/notes-routes.js';
+import { Note } from '../../src/models/note.js';
+
+// Mock repository for testing
+class MockNoteRepository {
+  constructor() {
+    this.notes = [];
+    this.nextId = 1;
+  }
+
+  async findAll() {
+    return [...this.notes];
+  }
+
+  async findById(id) {
+    const note = this.notes.find(n => n.id === id);
+    return note || null;
+  }
+
+  async create(noteData) {
+    const id = String(this.nextId++);
+    const note = new Note(
+      id,
+      noteData.title,
+      noteData.content,
+      new Date(),
+      new Date()
+    );
+    this.notes.push(note);
+    return note;
+  }
+
+  async update(id, noteData) {
+    const index = this.notes.findIndex(n => n.id === id);
+    if (index === -1) return null;
+    
+    const note = this.notes[index];
+    note.title = noteData.title;
+    note.content = noteData.content;
+    note.updatedAt = new Date();
+    
+    return note;
+  }
+
+  async delete(id) {
+    const index = this.notes.findIndex(n => n.id === id);
+    if (index === -1) return false;
+    
+    this.notes.splice(index, 1);
+    return true;
+  }
+}
+
+describe('Notes Routes', () => {
+  let app;
+  let repository;
+
+  beforeEach(() => {
+    repository = new MockNoteRepository();
+    app = express();
+    app.use(express.json());
+    app.use('/api/notes', createNotesRouter(repository));
+  });
+
+  describe('GET /api/notes', () => {
+    test('should return empty array when no notes exist', async () => {
+      const response = await request(app).get('/api/notes');
+      
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual([]);
+    });
+
+    test('should return all notes', async () => {
+      // Add some test notes
+      await repository.create({ title: 'Note 1', content: 'Content 1' });
+      await repository.create({ title: 'Note 2', content: 'Content 2' });
+      
+      const response = await request(app).get('/api/notes');
+      
+      expect(response.status).toBe(200);
+      expect(response.body.length).toBe(2);
+      expect(response.body[0].title).toBe('Note 1');
+      expect(response.body[1].title).toBe('Note 2');
+    });
+  });
+
+  describe('POST /api/notes', () => {
+    test('should create a new note', async () => {
+      const noteData = { title: 'New Note', content: 'New Content' };
+      
+      const response = await request(app)
+        .post('/api/notes')
+        .send(noteData)
+        .set('Content-Type', 'application/json');
+      
+      expect(response.status).toBe(201);
+      expect(response.body.title).toBe(noteData.title);
+      expect(response.body.content).toBe(noteData.content);
+      expect(response.body.id).toBeDefined();
+    });
+
+    test('should return 400 if title or content is missing', async () => {
+      const response = await request(app)
+        .post('/api/notes')
+        .send({ title: 'Missing Content' })
+        .set('Content-Type', 'application/json');
+      
+      expect(response.status).toBe(400);
+      expect(response.body.error).toBeDefined();
+    });
+  });
+});

jest.config.js

@@ -0,0 +1,9 @@
+export default {
+  transform: {},
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  testEnvironment: 'node',
+  testMatch: ['**/__tests__/**/*.js', '**/?(*.)+(spec|test).js'],
+  verbose: true
+};