Added Jest testing, ESLint static analysis, and GitHub Actions CI pipeline

Author: shinersup

.eslintrc.json

@@ -0,0 +1,33 @@
+{
+  "env": {
+    "browser": true,
+    "es2021": true,
+    "node": true,
+    "jest": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:react/recommended"
+  ],
+  "parserOptions": {
+    "ecmaFeatures": {
+      "jsx": true
+    },
+    "ecmaVersion": "latest",
+    "sourceType": "module"
+  },
+  "plugins": ["react"],
+  "rules": {
+    "react/react-in-jsx-scope": "off",
+    "react/prop-types": "off",
+    "react/no-unescaped-entities": "off",
+    "react/no-unknown-property": "warn",
+    "no-unused-vars": "warn",
+    "no-console": "off"
+  },
+  "settings": {
+    "react": {
+      "version": "detect"
+    }
+  }
+}

.github/workflows/ci.yml

@@ -0,0 +1,73 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run ESLint
+        run: npm run lint
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests with coverage
+        run: npm run test:coverage
+
+      - name: Upload coverage report
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: coverage/
+          retention-days: 7
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    needs: [lint, test]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build application
+        run: npm run build

__tests__/api/auth.test.js

@@ -0,0 +1,193 @@
+import getUserFromReq from '@/pages/api/auth';
+import { withClient } from '@/pages/api/db';
+import jwt from 'jsonwebtoken';
+
+// Mock dependencies
+jest.mock('@/pages/api/db', () => ({
+  __esModule: true,
+  default: {},
+  withClient: jest.fn(),
+}));
+
+jest.mock('jsonwebtoken', () => ({
+  verify: jest.fn(),
+}));
+
+describe('getUserFromReq (auth)', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env.JWT_SECRET = 'test-secret';
+  });
+
+  describe('Token extraction', () => {
+    it('extracts token from Authorization header', async () => {
+      jwt.verify.mockReturnValue({ userId: 1 });
+      withClient.mockImplementation(async (callback) => {
+        const mockClient = {
+          query: jest.fn().mockResolvedValue({
+            rows: [{ id: 1, username: 'testuser' }],
+          }),
+        };
+        return callback(mockClient);
+      });
+
+      const req = {
+        headers: {
+          authorization: 'Bearer valid-token',
+        },
+      };
+
+      const user = await getUserFromReq(req);
+
+      expect(jwt.verify).toHaveBeenCalledWith('valid-token', 'test-secret');
+      expect(user).toEqual({ id: 1, username: 'testuser' });
+    });
+
+    it('extracts token from cookie', async () => {
+      jwt.verify.mockReturnValue({ userId: 1 });
+      withClient.mockImplementation(async (callback) => {
+        const mockClient = {
+          query: jest.fn().mockResolvedValue({
+            rows: [{ id: 1, username: 'testuser' }],
+          }),
+        };
+        return callback(mockClient);
+      });
+
+      const req = {
+        headers: {
+          cookie: 'token=cookie-token; other=value',
+        },
+      };
+
+      const user = await getUserFromReq(req);
+
+      expect(jwt.verify).toHaveBeenCalledWith('cookie-token', 'test-secret');
+      expect(user).toEqual({ id: 1, username: 'testuser' });
+    });
+
+    it('prefers Authorization header over cookie', async () => {
+      jwt.verify.mockReturnValue({ userId: 1 });
+      withClient.mockImplementation(async (callback) => {
+        const mockClient = {
+          query: jest.fn().mockResolvedValue({
+            rows: [{ id: 1, username: 'testuser' }],
+          }),
+        };
+        return callback(mockClient);
+      });
+
+      const req = {
+        headers: {
+          authorization: 'Bearer header-token',
+          cookie: 'token=cookie-token',
+        },
+      };
+
+      await getUserFromReq(req);
+
+      expect(jwt.verify).toHaveBeenCalledWith('header-token', 'test-secret');
+    });
+  });
+
+  describe('Authentication errors', () => {
+    it('throws 401 when no token provided', async () => {
+      const req = {
+        headers: {},
+      };
+
+      await expect(getUserFromReq(req)).rejects.toMatchObject({
+        message: 'Not authenticated',
+        status: 401,
+      });
+    });
+
+    it('throws 401 when Authorization header is malformed', async () => {
+      const req = {
+        headers: {
+          authorization: 'InvalidFormat token',
+        },
+      };
+
+      await expect(getUserFromReq(req)).rejects.toMatchObject({
+        message: 'Not authenticated',
+        status: 401,
+      });
+    });
+
+    it('throws 401 when token is invalid', async () => {
+      jwt.verify.mockImplementation(() => {
+        throw new Error('invalid token');
+      });
+
+      const req = {
+        headers: {
+          authorization: 'Bearer invalid-token',
+        },
+      };
+
+      await expect(getUserFromReq(req)).rejects.toMatchObject({
+        message: 'Invalid or expired token',
+        status: 401,
+      });
+    });
+
+    it('throws 401 when token is expired', async () => {
+      jwt.verify.mockImplementation(() => {
+        const error = new Error('jwt expired');
+        error.name = 'TokenExpiredError';
+        throw error;
+      });
+
+      const req = {
+        headers: {
+          authorization: 'Bearer expired-token',
+        },
+      };
+
+      await expect(getUserFromReq(req)).rejects.toMatchObject({
+        message: 'Invalid or expired token',
+        status: 401,
+      });
+    });
+
+    it('throws 401 when user not found in database', async () => {
+      jwt.verify.mockReturnValue({ userId: 999 });
+      withClient.mockImplementation(async (callback) => {
+        const mockClient = {
+          query: jest.fn().mockResolvedValue({ rows: [] }),
+        };
+        return callback(mockClient);
+      });
+
+      const req = {
+        headers: {
+          authorization: 'Bearer valid-token',
+        },
+      };
+
+      await expect(getUserFromReq(req)).rejects.toMatchObject({
+        message: 'User not found',
+        status: 401,
+      });
+    });
+  });
+
+  describe('Database errors', () => {
+    it('throws 500 on database connection error', async () => {
+      jwt.verify.mockReturnValue({ userId: 1 });
+      withClient.mockRejectedValue(new Error('Connection refused'));
+
+      const req = {
+        headers: {
+          authorization: 'Bearer valid-token',
+        },
+      };
+
+      await expect(getUserFromReq(req)).rejects.toMatchObject({
+        message: 'Authentication error',
+        status: 500,
+      });
+    });
+  });
+});