WIP SPV: Red Tests

controllers/SPV.js

@@ -0,0 +1,52 @@
+const SPV = require('../models/SPV');
+
+// Create a new SPV
+exports.createSPV = async (req, res) => {
+  try {
+    const { SPVID, Name, Purpose, CreationDate, Status, ParentCompanyID, ComplianceStatus } = req.body;
+
+    if (!SPVID || !Name || !Purpose || !CreationDate || !Status || !ParentCompanyID || !ComplianceStatus) {
+      return res.status(400).json({ message: 'Missing required fields' });
+    }
+
+    const newSPV = new SPV({
+      SPVID,
+      Name,
+      Purpose,
+      CreationDate,
+      Status,
+      ParentCompanyID,
+      ComplianceStatus,
+    });
+
+    const savedSPV = await newSPV.save();
+    res.status(201).json(savedSPV);
+  } catch (error) {
+    res.status(500).json({ message: 'Failed to create SPV', error: error.message });
+  }
+};
+
+// Get all SPVs
+exports.getSPVs = async (req, res) => {
+  try {
+    const spvs = await SPV.find();
+    res.status(200).json({ spvs });
+  } catch (error) {
+    res.status(500).json({ message: 'Failed to retrieve SPVs', error: error.message });
+  }
+};
+
+// Delete an SPV by ID
+exports.deleteSPV = async (req, res) => {
+  try {
+    const deletedSPV = await SPV.findByIdAndDelete(req.params.id);
+
+    if (!deletedSPV) {
+      return res.status(404).json({ message: 'SPV not found' });
+    }
+
+    res.status(200).json({ message: 'SPV deleted' });
+  } catch (error) {
+    res.status(500).json({ message: 'Failed to delete SPV', error: error.message });
+  }
+};

models/SPV.js

@@ -0,0 +1,37 @@
+const mongoose = require('mongoose');
+
+const SPVSchema = new mongoose.Schema({
+  SPVID: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  Name: {
+    type: String,
+    required: true,
+  },
+  Purpose: {
+    type: String,
+    required: true,
+  },
+  CreationDate: {
+    type: Date,
+    required: true,
+  },
+  Status: {
+    type: String,
+    enum: ['Active', 'Inactive'], // Modify these as needed
+    required: true,
+  },
+  ParentCompanyID: {
+    type: String,
+    required: true,
+  },
+  ComplianceStatus: {
+    type: String,
+    enum: ['Compliant', 'Non-Compliant'], // Modify these as needed
+    required: true,
+  },
+});
+
+module.exports = mongoose.model('SPV', SPVSchema);

routes/SPV.js

@@ -0,0 +1,56 @@
+const express = require('express');
+const SPV = require('../models/SPV');
+const router = express.Router();
+
+// POST /api/spvs - Create a new SPV
+router.post('/', async (req, res) => {
+  try {
+    const { SPVID, Name, Purpose, CreationDate, Status, ParentCompanyID, ComplianceStatus } = req.body;
+
+    if (!SPVID || !Name || !Purpose || !CreationDate || !Status || !ParentCompanyID || !ComplianceStatus) {
+      return res.status(400).json({ message: 'Missing required fields' });
+    }
+
+    const newSPV = new SPV({
+      SPVID,
+      Name,
+      Purpose,
+      CreationDate,
+      Status,
+      ParentCompanyID,
+      ComplianceStatus,
+    });
+
+    const savedSPV = await newSPV.save();
+    res.status(201).json(savedSPV);
+  } catch (error) {
+    res.status(500).json({ message: 'Failed to create SPV', error: error.message });
+  }
+});
+
+// GET /api/spvs - Get all SPVs
+router.get('/', async (req, res) => {
+  try {
+    const spvs = await SPV.find();
+    res.status(200).json({ spvs });
+  } catch (error) {
+    res.status(500).json({ message: 'Failed to retrieve SPVs', error: error.message });
+  }
+});
+
+// DELETE /api/spvs/:id - Delete an SPV by ID
+router.delete('/:id', async (req, res) => {
+  try {
+    const deletedSPV = await SPV.findByIdAndDelete(req.params.id);
+
+    if (!deletedSPV) {
+      return res.status(404).json({ message: 'SPV not found' });
+    }
+
+    res.status(200).json({ message: 'SPV deleted' });
+  } catch (error) {
+    res.status(500).json({ message: 'Failed to delete SPV', error: error.message });
+  }
+});
+
+module.exports = router;

test/SPVController.test.js

@@ -0,0 +1,99 @@
+const mongoose = require('mongoose');
+const sinon = require('sinon');
+const { expect } = require('@jest/globals');
+const SPV = require('../models/SPV');
+const spvController = require('../controllers/SPV'); // Make sure to create this controller file
+
+describe('SPV Controller', function () {
+  beforeAll(async () => {
+    await mongoose.connect('mongodb://localhost:27017/test', {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+    await mongoose.connection.dropDatabase();
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+  });
+
+  beforeEach(async () => {
+    await SPV.deleteMany({});
+  });
+
+  it('should create a new SPV', async function () {
+    const req = {
+      body: {
+        SPVID: 'unique-spv-id',
+        Name: 'Test SPV',
+        Purpose: 'Investment',
+        CreationDate: new Date().toISOString(),
+        Status: 'Active',
+        ParentCompanyID: 'company123',
+        ComplianceStatus: 'Compliant',
+      },
+    };
+    const res = {
+      status: sinon.stub().returnsThis(),
+      json: sinon.stub(),
+    };
+
+    await spvController.createSPV(req, res);
+
+    expect(res.status.calledWith(201)).toBe(true);
+    expect(res.json.calledWith(sinon.match.has('SPVID', 'unique-spv-id'))).toBe(true);
+  });
+
+  it('should get all SPVs', async function () {
+    const spvData = {
+      SPVID: 'unique-spv-id',
+      Name: 'Test SPV',
+      Purpose: 'Investment',
+      CreationDate: new Date().toISOString(),
+      Status: 'Active',
+      ParentCompanyID: 'company123',
+      ComplianceStatus: 'Compliant',
+    };
+    await new SPV(spvData).save();
+
+    const req = {};
+    const res = {
+      status: sinon.stub().returnsThis(),
+      json: sinon.stub(),
+    };
+
+    await spvController.getSPVs(req, res);
+
+    expect(res.status.calledWith(200)).toBe(true);
+    expect(res.json.args[0][0].spvs).toBeInstanceOf(Array);
+    expect(res.json.args[0][0].spvs[0].SPVID).toBe(spvData.SPVID);
+  });
+
+  it('should delete an SPV by ID', async function () {
+    const spv = new SPV({
+      SPVID: 'unique-spv-id',
+      Name: 'Test SPV',
+      Purpose: 'Investment',
+      CreationDate: new Date().toISOString(),
+      Status: 'Active',
+      ParentCompanyID: 'company123',
+      ComplianceStatus: 'Compliant',
+    });
+    await spv.save();
+
+    const req = {
+      params: {
+        id: spv._id.toString(),
+      },
+    };
+    const res = {
+      status: sinon.stub().returnsThis(),
+      json: sinon.stub(),
+    };
+
+    await spvController.deleteSPV(req, res);
+
+    expect(res.status.calledWith(200)).toBe(true);
+    expect(res.json.calledWith(sinon.match.has('message', 'SPV deleted'))).toBe(true);
+  });
+});

test/SPVModel.test.js

@@ -0,0 +1,83 @@
+const mongoose = require('mongoose');
+const { expect } = require('@jest/globals');
+const SPV = require('../models/SPV');
+
+describe('SPV Model', () => {
+  beforeAll(async () => {
+    await mongoose.connect('mongodb://localhost:27017/test', {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+    await mongoose.connection.dropDatabase();
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+  });
+
+  beforeEach(async () => {
+    await SPV.deleteMany({});
+  });
+
+  it('should create an SPV with valid fields', async () => {
+    const spvData = {
+      SPVID: 'unique-spv-id',
+      Name: 'Test SPV',
+      Purpose: 'Investment',
+      CreationDate: new Date(),
+      Status: 'Active',
+      ParentCompanyID: 'company123',
+      ComplianceStatus: 'Compliant',
+    };
+
+    const spv = new SPV(spvData);
+    const savedSPV = await spv.save();
+
+    expect(savedSPV.SPVID).toBe(spvData.SPVID);
+    expect(savedSPV.Name).toBe(spvData.Name);
+    expect(savedSPV.Purpose).toBe(spvData.Purpose);
+    expect(new Date(savedSPV.CreationDate).toISOString()).toBe(spvData.CreationDate.toISOString());
+    expect(savedSPV.Status).toBe(spvData.Status);
+    expect(savedSPV.ParentCompanyID).toBe(spvData.ParentCompanyID);
+    expect(savedSPV.ComplianceStatus).toBe(spvData.ComplianceStatus);
+  });
+
+  it('should not create an SPV without required fields', async () => {
+    const spvData = {
+      Name: 'Test SPV',
+      Purpose: 'Investment',
+    };
+
+    try {
+      const spv = new SPV(spvData);
+      await spv.save();
+    } catch (error) {
+      expect(error.errors.SPVID).toBeTruthy();
+      expect(error.errors.CreationDate).toBeTruthy();
+      expect(error.errors.Status).toBeTruthy();
+      expect(error.errors.ParentCompanyID).toBeTruthy();
+      expect(error.errors.ComplianceStatus).toBeTruthy();
+    }
+  });
+
+  it('should not create an SPV with invalid enum values', async () => {
+    const spvData = {
+      SPVID: 'unique-spv-id',
+      Name: 'Test SPV',
+      Purpose: 'Investment',
+      CreationDate: new Date(),
+      Status: 'InvalidStatus', // Invalid enum value
+      ParentCompanyID: 'company123',
+      ComplianceStatus: 'InvalidStatus', // Invalid enum value
+    };
+
+    try {
+      const spv = new SPV(spvData);
+      await spv.save();
+    } catch (error) {
+      expect(error.errors.Status).toBeTruthy();
+      expect(error.errors.ComplianceStatus).toBeTruthy();
+    }
+  });
+});
+