Testing

npm run test:ci          # backend coverage + frontend coverage (full suites, closest one-liner to “green merge”)
npm run test:backend     # backend only (coverage: unit + integration + route outcomes)
npm run test:frontend    # frontend only (coverage)
npm run test:backend:routes   # backend route-outcome tests only (fast feedback on API tests)

npm --prefix frontend run test           # local watch / interactive
npm --prefix frontend run test:ci        # CI-style: no watch, in band (used in CI unit-tests job)
npm --prefix frontend run test:coverage  # coverage + reporters (used in CI coverage job)

// backend/tests/unit — exercise pure helpers: fixed input → expected output.
function clampRating(n) {
  return Math.min(5, Math.max(1, n));
}

describe('clampRating', () => {
  test('bounds values', () => {
    expect(clampRating(10)).toBe(5);
    expect(clampRating(-3)).toBe(1);
  });
});

// backend/tests/integration — drive HTTP without starting real Mongo.
const express = require('express');
const request = require('supertest');

jest.mock('../../connectionsManager', () => ({
  connectToDatabase: jest.fn(), // Meridian resolves tenant DB by school; tests stub it.
}));

const { connectToDatabase } = require('../../connectionsManager');
const adminRoutes = require('../../routes/adminRoutes'); // example: routes that call connectToDatabase('rpi')

test('GET /health when DB ping succeeds', async () => {
  connectToDatabase.mockResolvedValue({
    db: { admin: () => ({ ping: jest.fn().mockResolvedValue({ ok: 1 }) }) },
  });

  const app = express();
  app.use((req, _res, next) => {
    req.school = 'rpi'; // same string app.js derives from host / tenant routing
    next();
  });
  app.use(adminRoutes);

  const res = await request(app).get('/health');
  expect(res.statusCode).toBe(200);
});

const express = require('express');
const request = require('supertest');

test('tenant context is visible inside a route (illustrative)', async () => {
  const app = express();
  app.use(express.json());

  // Same responsibility as app.js middleware: attach tenant connection + school key.
  app.use((req, _res, next) => {
    req.db = { kind: 'mongoose-connection-for-this-school' }; // tests: real connection from createMongoMemoryConnection
    req.school = 'rpi';
    next();
  });

  app.post('/_echo', (req, res) => {
    // Real handlers: const { User } = getModels(req, 'User'); await User.find(...)
    res.status(200).json({ school: req.school, db: req.db.kind });
  });

  const res = await request(app).post('/_echo').send({});
  expect(res.body.school).toBe('rpi');
  expect(res.body.db).toBe('mongoose-connection-for-this-school');
});

// frontend/src/utils/__tests__ — axios is an implementation detail; tests mock it.
jest.mock('axios', () => {
  const fn = jest.fn();
  fn.post = jest.fn(); // postRequest triggers POST /refresh-token on 401 retry path
  return fn;
});

import axios from 'axios';
import postRequest from '../postRequest';

test('POST returns JSON body on success', async () => {
  axios.mockResolvedValueOnce({ data: { id: '1' } });

  const body = await postRequest('/api/widgets', { name: 'Tab' });

  expect(body).toEqual({ id: '1' });
  expect(axios).toHaveBeenCalledWith(
    expect.objectContaining({
      method: 'POST',
      url: '/api/widgets',
      withCredentials: true, // Meridian relies on cookies for auth in the browser
    })
  );
});

// Colocate under frontend/src/**/__tests__ — assert what the user sees.
import { render, screen } from '@testing-library/react';

test('shows title', () => {
  render(<h1>Meridian</h1>);
  expect(screen.getByRole('heading', { name: /meridian/i })).toBeInTheDocument();
});