525 lines
16 KiB
JavaScript
525 lines
16 KiB
JavaScript
'use strict';
|
||
|
||
/**
|
||
* Integration tests – partner controller (controllers/partner.js)
|
||
*/
|
||
|
||
const { connectDB, disconnectDB, clearCollection } = require('./jest.setup');
|
||
const { mockApplicator, mockReq, mockRes, newId } = require('./mock_data');
|
||
|
||
let Partner, Customer, PartnerSystemUser;
|
||
|
||
beforeAll(async () => {
|
||
await connectDB();
|
||
Customer = require('../../model/customer');
|
||
// Ensure partner discriminator is registered
|
||
const partnerModel = require('../../model/partner');
|
||
Partner = partnerModel.Partner || partnerModel;
|
||
PartnerSystemUser = partnerModel.PartnerSystemUser;
|
||
});
|
||
|
||
afterAll(async () => {
|
||
await disconnectDB();
|
||
});
|
||
|
||
const partnerCtl = require('../../controllers/partner');
|
||
|
||
describe('partner controller – data methods', () => {
|
||
let admin;
|
||
|
||
function makePartnerBody() {
|
||
return {
|
||
name: `Partner-${Date.now()}`,
|
||
username: `partner_${Date.now()}@test.com`,
|
||
password: 'Test@123',
|
||
active: true,
|
||
kind: '20',
|
||
partnerCode: `TESTCODE-${Date.now()}`,
|
||
};
|
||
}
|
||
|
||
beforeAll(async () => {
|
||
await clearCollection(Partner);
|
||
admin = await Customer.create(mockApplicator());
|
||
});
|
||
|
||
afterAll(async () => {
|
||
await clearCollection(Partner);
|
||
await Customer.deleteMany({ _id: admin._id });
|
||
});
|
||
|
||
const makeReq = (extra = {}) =>
|
||
mockReq({ uid: admin._id, puid: admin._id, ut: '1', ...extra });
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('createPartner_post', () => {
|
||
it('creates a partner and returns it', async () => {
|
||
const req = makeReq({ body: makePartnerBody() });
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.createPartner_post(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(res._data._id).toBeDefined();
|
||
expect(res._data.kind).toBe('20');
|
||
});
|
||
|
||
it('throws when body is missing', async () => {
|
||
const req = makeReq({ body: null });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.createPartner_post(req, res)).rejects.toThrow();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('getPartners_get', () => {
|
||
it('returns array of partners', async () => {
|
||
const req = makeReq({ query: {} });
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.getPartners_get(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(Array.isArray(res._data)).toBe(true);
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('getPartners_post', () => {
|
||
it('returns partners matching search criteria', async () => {
|
||
const req = makeReq({ body: { name: 'Partner' } });
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.getPartners_post(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(Array.isArray(res._data)).toBe(true);
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('getPartnerById_get', () => {
|
||
let partnerId;
|
||
|
||
beforeAll(async () => {
|
||
const req = makeReq({ body: makePartnerBody() });
|
||
const res = mockRes();
|
||
await partnerCtl.createPartner_post(req, res);
|
||
partnerId = String(res._data._id);
|
||
});
|
||
|
||
it('returns partner by id', async () => {
|
||
const req = makeReq({ params: { id: partnerId } });
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.getPartnerById_get(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(String(res._data._id)).toBe(partnerId);
|
||
});
|
||
|
||
it('throws when partner id is invalid', async () => {
|
||
const req = makeReq({ params: { id: 'invalid-id' } });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.getPartnerById_get(req, res)).rejects.toThrow();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('getPartnerById_post', () => {
|
||
let partnerId;
|
||
|
||
beforeAll(async () => {
|
||
const req = makeReq({ body: makePartnerBody() });
|
||
const res = mockRes();
|
||
await partnerCtl.createPartner_post(req, res);
|
||
partnerId = String(res._data._id);
|
||
});
|
||
|
||
it('returns partner by id from body', async () => {
|
||
const req = makeReq({ body: { partner: partnerId } });
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.getPartnerById_post(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(String(res._data._id)).toBe(partnerId);
|
||
});
|
||
|
||
it('throws when partner id is missing from body', async () => {
|
||
const req = makeReq({ body: {} });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.getPartnerById_post(req, res)).rejects.toThrow();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('updatePartner_put', () => {
|
||
let partnerId;
|
||
|
||
beforeAll(async () => {
|
||
const req = makeReq({ body: makePartnerBody() });
|
||
const res = mockRes();
|
||
await partnerCtl.createPartner_post(req, res);
|
||
partnerId = String(res._data._id);
|
||
});
|
||
|
||
it('updates a partner field', async () => {
|
||
const req = makeReq({
|
||
params: { id: partnerId },
|
||
body: { name: 'Updated Partner Name', kind: '20' },
|
||
});
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.updatePartner_put(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(res._data.name).toBe('Updated Partner Name');
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('deletePartner', () => {
|
||
let partnerId;
|
||
|
||
beforeAll(async () => {
|
||
const req = makeReq({ body: makePartnerBody() });
|
||
const res = mockRes();
|
||
await partnerCtl.createPartner_post(req, res);
|
||
partnerId = String(res._data._id);
|
||
});
|
||
|
||
it('soft-deletes a partner', async () => {
|
||
const req = makeReq({ params: { id: partnerId } });
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.deletePartner(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
const found = await Partner.findById(partnerId);
|
||
expect(!found || found.active === false).toBeTruthy();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('syncData_post', () => {
|
||
it('returns 500 json response when partnerCode or customer is missing', async () => {
|
||
const req = makeReq({ body: {} });
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.syncData_post(req, res);
|
||
|
||
expect(res.status).toHaveBeenCalledWith(500);
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(res._data.success).toBe(false);
|
||
});
|
||
|
||
it('returns success when partnerCode and customer are provided', async () => {
|
||
const req = makeReq({
|
||
body: { partnerCode: 'TEST', customer: String(admin._id) },
|
||
});
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.syncData_post(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(res._data.success).toBe(true);
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('uploadJob_post', () => {
|
||
it('returns 500 json response when required params are missing', async () => {
|
||
const req = makeReq({ body: {} });
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.uploadJob_post(req, res);
|
||
|
||
expect(res.status).toHaveBeenCalledWith(500);
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(res._data.success).toBe(false);
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('getSystemUsers_get', () => {
|
||
it('returns empty array when no system users exist for valid partner+customer pair', async () => {
|
||
const req = makeReq({
|
||
query: { partnerId: String(newId()), customerId: String(admin._id) },
|
||
});
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.getSystemUsers_get(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(Array.isArray(res._data)).toBe(true);
|
||
});
|
||
|
||
it('throws when partnerId is not a valid ObjectId', async () => {
|
||
const req = makeReq({
|
||
query: { partnerId: 'bad-id', customerId: String(admin._id) },
|
||
});
|
||
const res = mockRes();
|
||
await expect(partnerCtl.getSystemUsers_get(req, res)).rejects.toThrow();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('getCurrentSystemUser_get', () => {
|
||
it('throws NOT_FOUND when no active system user exists', async () => {
|
||
const req = makeReq({
|
||
query: { partnerId: String(newId()), customerId: String(admin._id) },
|
||
});
|
||
const res = mockRes();
|
||
await expect(partnerCtl.getCurrentSystemUser_get(req, res)).rejects.toThrow();
|
||
});
|
||
|
||
it('throws when params are invalid', async () => {
|
||
const req = makeReq({
|
||
query: { partnerId: 'bad-id', customerId: 'bad-id' },
|
||
});
|
||
const res = mockRes();
|
||
await expect(partnerCtl.getCurrentSystemUser_get(req, res)).rejects.toThrow();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('getSystemUser_get', () => {
|
||
it('throws when id is missing', async () => {
|
||
const req = makeReq({ params: {} });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.getSystemUser_get(req, res)).rejects.toThrow();
|
||
});
|
||
|
||
it('throws NOT_FOUND when id does not match any system user', async () => {
|
||
const req = makeReq({ params: { id: String(newId()) } });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.getSystemUser_get(req, res)).rejects.toThrow();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('createSystemUser_post', () => {
|
||
let partner;
|
||
|
||
beforeAll(async () => {
|
||
const req = makeReq({ body: makePartnerBody() });
|
||
const res = mockRes();
|
||
await partnerCtl.createPartner_post(req, res);
|
||
partner = res._data;
|
||
});
|
||
|
||
it('throws when required params are missing', async () => {
|
||
const req = makeReq({ body: { partnerId: String(partner._id) } });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.createSystemUser_post(req, res)).rejects.toThrow();
|
||
});
|
||
|
||
it('creates a partner system user for valid partner+customer', async () => {
|
||
const req = makeReq({
|
||
body: {
|
||
partnerId: String(partner._id),
|
||
customerId: String(admin._id),
|
||
username: `psu_${Date.now()}@test.com`,
|
||
password: 'Pass@123',
|
||
name: 'Test PSU',
|
||
},
|
||
});
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.createSystemUser_post(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(res._data._id).toBeDefined();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('updateSystemUser_put', () => {
|
||
let systemUserId, partner;
|
||
|
||
beforeAll(async () => {
|
||
const pReq = makeReq({ body: makePartnerBody() });
|
||
const pRes = mockRes();
|
||
await partnerCtl.createPartner_post(pReq, pRes);
|
||
partner = pRes._data;
|
||
|
||
const req = makeReq({
|
||
body: {
|
||
partnerId: String(partner._id),
|
||
customerId: String(admin._id),
|
||
username: `psu2_${Date.now()}@test.com`,
|
||
password: 'Pass@123',
|
||
},
|
||
});
|
||
const res = mockRes();
|
||
await partnerCtl.createSystemUser_post(req, res);
|
||
systemUserId = String(res._data._id);
|
||
});
|
||
|
||
it('updates a system user field via updateUser_put', async () => {
|
||
const req = makeReq({
|
||
params: { id: systemUserId },
|
||
body: { name: 'Updated PSU Name', kind: '21' },
|
||
});
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.updateSystemUser_put(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(res._data.name).toBe('Updated PSU Name');
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('updateSystemUser_post', () => {
|
||
let systemUserId, partner;
|
||
|
||
beforeAll(async () => {
|
||
const pReq = makeReq({ body: makePartnerBody() });
|
||
const pRes = mockRes();
|
||
await partnerCtl.createPartner_post(pReq, pRes);
|
||
partner = pRes._data;
|
||
|
||
const req = makeReq({
|
||
body: {
|
||
partnerId: String(partner._id),
|
||
customerId: String(admin._id),
|
||
username: `psu3_${Date.now()}@test.com`,
|
||
password: 'Pass@123',
|
||
},
|
||
});
|
||
const res = mockRes();
|
||
await partnerCtl.createSystemUser_post(req, res);
|
||
systemUserId = String(res._data._id);
|
||
});
|
||
|
||
it('updates system user fields via patch approach', async () => {
|
||
const req = makeReq({
|
||
params: { id: systemUserId },
|
||
body: { name: 'PATCH Updated PSU' },
|
||
});
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.updateSystemUser_post(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(res._data.name).toBe('PATCH Updated PSU');
|
||
});
|
||
|
||
it('throws NOT_FOUND for non-existent system user id', async () => {
|
||
const req = makeReq({
|
||
params: { id: String(newId()) },
|
||
body: { name: 'X' },
|
||
});
|
||
const res = mockRes();
|
||
await expect(partnerCtl.updateSystemUser_post(req, res)).rejects.toThrow();
|
||
});
|
||
|
||
it('throws when id is missing', async () => {
|
||
const req = makeReq({ params: {}, body: { name: 'X' } });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.updateSystemUser_post(req, res)).rejects.toThrow();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('deleteSystemUser', () => {
|
||
let systemUserId, partner;
|
||
|
||
beforeAll(async () => {
|
||
const pReq = makeReq({ body: makePartnerBody() });
|
||
const pRes = mockRes();
|
||
await partnerCtl.createPartner_post(pReq, pRes);
|
||
partner = pRes._data;
|
||
|
||
const req = makeReq({
|
||
body: {
|
||
partnerId: String(partner._id),
|
||
customerId: String(admin._id),
|
||
username: `psu4_${Date.now()}@test.com`,
|
||
password: 'Pass@123',
|
||
},
|
||
});
|
||
const res = mockRes();
|
||
await partnerCtl.createSystemUser_post(req, res);
|
||
systemUserId = String(res._data._id);
|
||
});
|
||
|
||
it('soft-deletes a system user (marks inactive)', async () => {
|
||
const req = makeReq({ params: { id: systemUserId } });
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.deleteSystemUser(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(res._data.ok).toBe(true);
|
||
});
|
||
|
||
it('throws NOT_FOUND for non-existent system user', async () => {
|
||
const req = makeReq({ params: { id: String(newId()) } });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.deleteSystemUser(req, res)).rejects.toThrow();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('testPartnerAuth_post', () => {
|
||
it('throws when required params are missing', async () => {
|
||
const req = makeReq({ body: { customerId: String(admin._id) } });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.testPartnerAuth_post(req, res)).rejects.toThrow();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('getPartnerCustomers_get', () => {
|
||
let partnerId;
|
||
|
||
beforeAll(async () => {
|
||
const req = makeReq({ body: makePartnerBody() });
|
||
const res = mockRes();
|
||
await partnerCtl.createPartner_post(req, res);
|
||
partnerId = String(res._data._id);
|
||
});
|
||
|
||
it('returns empty array when no system users exist for the partner', async () => {
|
||
const req = makeReq({ query: { partnerId } });
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.getPartnerCustomers_get(req, res);
|
||
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(Array.isArray(res._data)).toBe(true);
|
||
});
|
||
|
||
it('throws when partnerId is missing', async () => {
|
||
const req = makeReq({ query: {} });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.getPartnerCustomers_get(req, res)).rejects.toThrow();
|
||
});
|
||
});
|
||
|
||
// -------------------------------------------------------------------------
|
||
describe('getPartnerAircraft_get', () => {
|
||
it('throws when customerId is not a valid ObjectId', async () => {
|
||
const req = makeReq({ query: { partnerId: String(newId()), customerId: 'bad-id' } });
|
||
const res = mockRes();
|
||
await expect(partnerCtl.getPartnerAircraft_get(req, res)).rejects.toThrow();
|
||
});
|
||
|
||
it('returns a 422 response when partner is not found', async () => {
|
||
const req = makeReq({
|
||
query: { partnerId: String(newId()), customerId: String(admin._id) },
|
||
});
|
||
const res = mockRes();
|
||
|
||
await partnerCtl.getPartnerAircraft_get(req, res);
|
||
|
||
expect(res.status).toHaveBeenCalledWith(422);
|
||
expect(res.json).toHaveBeenCalled();
|
||
expect(res._data.success).toBe(false);
|
||
});
|
||
});
|
||
});
|