agmission/Development/server/tests/integration/vehicle.integration.test.js

'use strict';

/**
 * Integration tests – vehicle controller (controllers/vehicle.js)
 */

const { connectDB, disconnectDB, clearCollection } = require('./jest.setup');
const { mockApplicator, mockVehicle, mockReq, mockRes, newId } = require('./mock_data');

let Vehicle, Customer;

beforeAll(async () => {
  await connectDB();
  Customer = require('../../model/customer');
  Vehicle  = require('../../model/vehicle');
});

afterAll(async () => {
  await disconnectDB();
});

const vehicleCtl = require('../../controllers/vehicle');

describe('vehicle controller – data methods', () => {
  let applicator;

  beforeAll(async () => {
    await clearCollection(Vehicle);
    applicator = await Customer.create(mockApplicator());
  });

  afterAll(async () => {
    await clearCollection(Vehicle);
    await Customer.deleteMany({ _id: applicator._id });
  });

  const makeReq = (extra = {}) =>
    mockReq({ uid: applicator._id, puid: applicator._id, ut: '1', ...extra });

  // -------------------------------------------------------------------------
  describe('create_post', () => {
    it('creates a vehicle and returns it', async () => {
      const req = makeReq({ body: mockVehicle(applicator._id) });
      const res = mockRes();

      await vehicleCtl.createVehicle_post(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data._id).toBeDefined();
      expect(res._data.name).toMatch(/Aircraft-/);
    });

    it('throws when body is missing', async () => {
      const req = makeReq({ body: null });
      const res = mockRes();
      await expect(vehicleCtl.createVehicle_post(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('getById_get', () => {
    let vehicleId;

    beforeAll(async () => {
      const doc = await Vehicle.create(mockVehicle(applicator._id));
      vehicleId = String(doc._id);
    });

    it('returns vehicle by id', async () => {
      const req = makeReq({ params: { id: vehicleId } });
      const res = mockRes();

      await vehicleCtl.getVehicle_get(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(String(res._data._id)).toBe(vehicleId);
    });
  });

  // -------------------------------------------------------------------------
  describe('search_post', () => {
    it('returns matching vehicles', async () => {
      const req = makeReq({ body: { byUserId: applicator._id } });
      const res = mockRes();

      await vehicleCtl.search_post(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(Array.isArray(res._data)).toBe(true);
    });
  });

  // -------------------------------------------------------------------------
  describe('bulkUpdate_post', () => {
    let vehicleIds;

    beforeAll(async () => {
      const docs = await Vehicle.create([
        mockVehicle(applicator._id),
        mockVehicle(applicator._id),
      ]);
      vehicleIds = docs.map(d => String(d._id));
    });

    it('bulk-updates multiple vehicles', async () => {
      const req = makeReq({
        body: vehicleIds.map(id => ({ _id: id, active: false })),
      });
      const res = mockRes();

      await vehicleCtl.updateVehicles_post(req, res);

      expect(res.json).toHaveBeenCalled();
    });
  });

  // -------------------------------------------------------------------------
  describe('delete_delete', () => {
    let vehicleId;

    beforeAll(async () => {
      const doc = await Vehicle.create(mockVehicle(applicator._id));
      vehicleId = String(doc._id);
    });

    it.skip('soft-deletes a vehicle (skipped: requires MongoDB replica-set for transactions)', async () => {
      const req = makeReq({ params: { id: vehicleId } });
      const res = mockRes();

      await vehicleCtl.deleteVehicle(req, res);

      expect(res.json).toHaveBeenCalled();
      const found = await Vehicle.findById(vehicleId);
      expect(!found || found.markedDelete).toBeTruthy();
    });
  });

  // -------------------------------------------------------------------------
  describe('updateVehicle_put', () => {
    let vehicleId;

    beforeAll(async () => {
      const doc = await Vehicle.create(mockVehicle(applicator._id));
      vehicleId = String(doc._id);
    });

    it('updates a vehicle field', async () => {
      const req = makeReq({
        params: { id: vehicleId },
        body: { name: 'Updated Aircraft Name', kind: '9' },
      });
      const res = mockRes();

      await vehicleCtl.updateVehicle_put(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data.name).toBe('Updated Aircraft Name');
    });

    it('throws when id is invalid', async () => {
      const req = makeReq({ params: {}, body: { name: 'X', kind: '9' } });
      const res = mockRes();
      await expect(vehicleCtl.updateVehicle_put(req, res)).rejects.toThrow();
    });
  });

  // -------------------------------------------------------------------------
  describe('unitIdExists_post', () => {
    let vehicleWithUnit;

    beforeAll(async () => {
      vehicleWithUnit = await Vehicle.create(
        mockVehicle(applicator._id, { unitId: 'UNIT001' })
      );
    });

    it('returns 1 when unitId exists', async () => {
      const req = makeReq({ body: { unitId: vehicleWithUnit.unitId } });
      const res = mockRes();

      await vehicleCtl.unitIdExists_post(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data).toBe(1);
    });

    it('returns 0 when unitId does not exist', async () => {
      const req = makeReq({ body: { unitId: 'NOTEXIST001' } });
      const res = mockRes();

      await vehicleCtl.unitIdExists_post(req, res);

      expect(res.json).toHaveBeenCalled();
      expect(res._data).toBe(0);
    });

    it('throws when unitId is blank', async () => {
      const req = makeReq({ body: { unitId: '' } });
      const res = mockRes();
      await expect(vehicleCtl.unitIdExists_post(req, res)).rejects.toThrow();
    });
  });
});