ai-spec-dev 0.41.0 → 0.42.0

package/demo-backend/src/routes/bookmark.routes.test.ts

@@ -0,0 +1,264 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import http from 'http';
+import { app } from '../app';
+
+let server: http.Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  server = app.listen(0);
+  const address = server.address();
+  if (typeof address === 'object' && address !== null) {
+    baseUrl = `http://localhost:${address.port}`;
+  } else {
+    throw new Error('Server address is not available');
+  }
+});
+
+afterAll(() => {
+  server.close();
+});
+
+function request(method: string, path: string, body?: any): Promise<{ statusCode: number; body: any }> {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, baseUrl);
+    const options = {
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname + url.search,
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      res.on('end', () => {
+        try {
+          const parsedBody = data ? JSON.parse(data) : {};
+          resolve({ statusCode: res.statusCode || 500, body: parsedBody });
+        } catch (e) {
+          resolve({ statusCode: res.statusCode || 500, body: data });
+        }
+      });
+    });
+
+    req.on('error', reject);
+
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+
+    req.end();
+  });
+}
+
+describe('Bookmark API Endpoints', () => {
+  let createdBookmarkId: string;
+
+  describe('POST /api/v1/bookmarks', () => {
+    it('should create a new bookmark with valid data', async () => {
+      const bookmarkData = {
+        title: 'Test Bookmark',
+        url: 'https://example.com',
+        tags: ['test', 'example'],
+      };
+
+      const response = await request('POST', '/api/v1/bookmarks', bookmarkData);
+
+      expect(response.statusCode).toBe(201);
+      expect(response.body.code).toBe(201);
+      expect(response.body.message).toBe('success');
+      expect(response.body.data).toHaveProperty('id');
+      expect(response.body.data.title).toBe(bookmarkData.title);
+      expect(response.body.data.url).toBe(bookmarkData.url);
+      expect(response.body.data.tags).toEqual(bookmarkData.tags);
+      expect(response.body.data).toHaveProperty('createdAt');
+      expect(response.body.data).toHaveProperty('updatedAt');
+
+      createdBookmarkId = response.body.data.id;
+    });
+
+    it('should return 400 when title is missing', async () => {
+      const bookmarkData = {
+        url: 'https://example.com',
+      };
+
+      const response = await request('POST', '/api/v1/bookmarks', bookmarkData);
+
+      expect(response.statusCode).toBe(400);
+      expect(response.body.code).toBe(400);
+      expect(response.body.message).toBeDefined();
+    });
+
+    it('should return 400 when URL is invalid', async () => {
+      const bookmarkData = {
+        title: 'Invalid URL',
+        url: 'invalid-url',
+      };
+
+      const response = await request('POST', '/api/v1/bookmarks', bookmarkData);
+
+      expect(response.statusCode).toBe(400);
+      expect(response.body.code).toBe(400);
+      expect(response.body.message).toBeDefined();
+    });
+
+    it('should return 400 when URL is missing', async () => {
+      const bookmarkData = {
+        title: 'No URL',
+      };
+
+      const response = await request('POST', '/api/v1/bookmarks', bookmarkData);
+
+      expect(response.statusCode).toBe(400);
+      expect(response.body.code).toBe(400);
+      expect(response.body.message).toBeDefined();
+    });
+  });
+
+  describe('GET /api/v1/bookmarks', () => {
+    it('should return paginated list of bookmarks', async () => {
+      const response = await request('GET', '/api/v1/bookmarks?limit=10&offset=0');
+
+      expect(response.statusCode).toBe(200);
+      expect(response.body.code).toBe(200);
+      expect(response.body.message).toBe('success');
+      expect(response.body.data).toHaveProperty('bookmarks');
+      expect(Array.isArray(response.body.data.bookmarks)).toBe(true);
+      expect(response.body.data).toHaveProperty('total');
+      expect(typeof response.body.data.total).toBe('number');
+    });
+
+    it('should use default pagination when no parameters provided', async () => {
+      const response = await request('GET', '/api/v1/bookmarks');
+
+      expect(response.statusCode).toBe(200);
+      expect(response.body.code).toBe(200);
+      expect(response.body.message).toBe('success');
+      expect(response.body.data).toHaveProperty('bookmarks');
+      expect(response.body.data).toHaveProperty('total');
+    });
+
+    it('should return 400 for invalid limit parameter', async () => {
+      const response = await request('GET', '/api/v1/bookmarks?limit=invalid');
+
+      expect(response.statusCode).toBe(400);
+      expect(response.body.code).toBe(400);
+      expect(response.body.message).toBeDefined();
+    });
+
+    it('should return 400 for invalid offset parameter', async () => {
+      const response = await request('GET', '/api/v1/bookmarks?offset=-1');
+
+      expect(response.statusCode).toBe(400);
+      expect(response.body.code).toBe(400);
+      expect(response.body.message).toBeDefined();
+    });
+  });
+
+  describe('PUT /api/v1/bookmarks/:id', () => {
+    it('should update an existing bookmark', async () => {
+      if (!createdBookmarkId) {
+        throw new Error('No bookmark created to update');
+      }
+
+      const updateData = {
+        title: 'Updated Title',
+        url: 'https://updated-example.com',
+        tags: ['updated', 'test'],
+      };
+
+      const response = await request('PUT', `/api/v1/bookmarks/${createdBookmarkId}`, updateData);
+
+      expect(response.statusCode).toBe(200);
+      expect(response.body.code).toBe(200);
+      expect(response.body.message).toBe('success');
+      expect(response.body.data.id).toBe(createdBookmarkId);
+      expect(response.body.data.title).toBe(updateData.title);
+      expect(response.body.data.url).toBe(updateData.url);
+      expect(response.body.data.tags).toEqual(updateData.tags);
+    });
+
+    it('should return 404 for non-existent bookmark', async () => {
+      const nonExistentId = '00000000-0000-0000-0000-000000000000';
+      const updateData = {
+        title: 'Updated Title',
+        url: 'https://example.com',
+        tags: ['test'],
+      };
+
+      const response = await request('PUT', `/api/v1/bookmarks/${nonExistentId}`, updateData);
+
+      expect(response.statusCode).toBe(404);
+      expect(response.body.code).toBe(404);
+      expect(response.body.message).toBeDefined();
+    });
+
+    it('should return 400 for invalid bookmark ID format', async () => {
+      const invalidId = 'invalid-uuid';
+      const updateData = {
+        title: 'Updated Title',
+        url: 'https://example.com',
+        tags: ['test'],
+      };
+
+      const response = await request('PUT', `/api/v1/bookmarks/${invalidId}`, updateData);
+
+      expect(response.statusCode).toBe(400);
+      expect(response.body.code).toBe(400);
+      expect(response.body.message).toBeDefined();
+    });
+
+    it('should return 400 when required fields are missing', async () => {
+      if (!createdBookmarkId) {
+        throw new Error('No bookmark created to update');
+      }
+
+      const updateData = {
+        title: 'Updated Title',
+      };
+
+      const response = await request('PUT', `/api/v1/bookmarks/${createdBookmarkId}`, updateData);
+
+      expect(response.statusCode).toBe(400);
+      expect(response.body.code).toBe(400);
+      expect(response.body.message).toBeDefined();
+    });
+  });
+
+  describe('DELETE /api/v1/bookmarks/:id', () => {
+    it('should delete an existing bookmark', async () => {
+      if (!createdBookmarkId) {
+        throw new Error('No bookmark created to delete');
+      }
+
+      const response = await request('DELETE', `/api/v1/bookmarks/${createdBookmarkId}`);
+
+      expect(response.statusCode).toBe(204);
+      expect(response.body).toBe('');
+    });
+
+    it('should return 404 for non-existent bookmark', async () => {
+      const nonExistentId = '00000000-0000-0000-0000-000000000000';
+      const response = await request('DELETE', `/api/v1/bookmarks/${nonExistentId}`);
+
+      expect(response.statusCode).toBe(404);
+      expect(response.body.code).toBe(404);
+      expect(response.body.message).toBeDefined();
+    });
+
+    it('should return 400 for invalid bookmark ID format', async () => {
+      const invalidId = 'invalid-uuid';
+      const response = await request('DELETE', `/api/v1/bookmarks/${invalidId}`);
+
+      expect(response.statusCode).toBe(400);
+      expect(response.body.code).toBe(400);
+      expect(response.body.message).toBeDefined();
+    });
+  });
+});

package/demo-backend/src/routes/bookmark.routes.ts

@@ -0,0 +1,11 @@
+import { Router } from 'express';
+import { getBookmarks, createBookmark, updateBookmark, deleteBookmark } from '../controllers/bookmark.controller';
+
+const router = Router();
+
+router.get('/', getBookmarks);
+router.post('/', createBookmark);
+router.put('/:id', updateBookmark);
+router.delete('/:id', deleteBookmark);
+
+export default router;

package/demo-backend/src/routes/index.ts

@@ -0,0 +1,8 @@
+import { Router } from 'express';
+import bookmarkRoutes from './bookmark.routes';
+
+const router = Router();
+
+router.use('/api/v1/bookmarks', bookmarkRoutes);
+
+export default router;