Get Settlement info (#14)

app/processing/settlement/get-settled-settlement-by-settlement-id.js

@@ -0,0 +1,19 @@
+const db = require('../../data')
+
+const getSettledSettlementBySettlementId = async (settlementId, transaction) => {
+  return db.settlement.findOne({
+    transaction,
+    attributes: [
+      'paymentRequestId',
+      'reference',
+      'settled'
+    ],
+    where: {
+      settlementId,
+      settled: true
+    },
+    raw: true
+  })
+}
+
+module.exports = getSettledSettlementBySettlementId

app/processing/settlement/get-settlement.js

@@ -0,0 +1,9 @@
+const getSettledSettlementBySettlementId = require('./get-settled-settlement-by-settlement-id')
+const validateSettlement = require('./validate-settlement')
+
+const getSettlement = async (settlementId) => {
+  const settledSettlement = await getSettledSettlementBySettlementId(settlementId)
+  return validateSettlement(settledSettlement)
+}
+
+module.exports = getSettlement

app/processing/settlement/index.js

@@ -0,0 +1,3 @@
+const getSettlement = require('./get-settlement')
+
+module.exports = getSettlement

app/processing/settlement/schema.js

@@ -0,0 +1,7 @@
+const Joi = require('joi')
+
+module.exports = Joi.object({
+  paymentRequestId: Joi.number().integer().required(),
+  reference: Joi.string().required(),
+  settled: Joi.boolean().required()
+}).required()

app/processing/settlement/validate-settlement.js

@@ -0,0 +1,16 @@
+const util = require('util')
+const schema = require('./schema')
+
+const validateSettlement = (settlement) => {
+  const result = schema.validate(settlement, {
+    abortEarly: false
+  })
+
+  if (result.error) {
+    throw new Error(`Settlement: ${util.inspect(settlement, false, null, true)} does not have the required data: ${result.error.message}`)
+  }
+
+  return result.value
+}
+
+module.exports = validateSettlement

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ffc-pay-statement-constructor",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Data construction for statement generation",
   "homepage": "https://github.com/DEFRA/ffc-pay-statement-constructor",
   "main": "app/index.js",

test/integration/processing/settlement/get-settlement.test.js

@@ -0,0 +1,113 @@
+const db = require('../../../../app/data')
+
+const getSettlement = require('../../../../app/processing/settlement')
+
+const schemes = require('../../../../app/constants/schemes')
+const paymentRequest = JSON.parse(JSON.stringify(require('../../../mock-payment-request').submitPaymentRequest))
+
+const SETTLEMENT_ID_NOT_SETTLED = 1
+const SETTLEMENT_ID_SETTLED = 2
+
+let settlement
+let mappedSettlement
+
+describe('process settlement', () => {
+  beforeAll(async () => {
+    await db.sequelize.truncate({
+      cascade: true,
+      restartIdentity: true
+    })
+  })
+
+  beforeEach(async () => {
+    await db.scheme.bulkCreate(schemes)
+    await db.invoiceNumber.create({
+      invoiceNumber: paymentRequest.invoiceNumber,
+      originalInvoiceNumber: paymentRequest.invoiceNumber.slice(0, 5)
+    })
+
+    await db.paymentRequest.create(paymentRequest)
+
+    settlement = JSON.parse(JSON.stringify(require('../../../mock-settlement')))
+    await db.settlement.create({ ...settlement, paymentRequestId: 1, settled: false })
+
+    mappedSettlement = {
+      paymentRequestId: 1,
+      reference: settlement.reference,
+      settled: settlement.settled
+    }
+  })
+
+  afterEach(async () => {
+    await db.sequelize.truncate({
+      cascade: true,
+      restartIdentity: true
+    })
+  })
+
+  afterAll(async () => {
+    await db.sequelize.close()
+  })
+
+  test('should return mapped settled object when existing settled settlement with required information exists', async () => {
+    try { await db.settlement.create({ ...settlement, paymentRequestId: 1 }) } catch { }
+    const result = await getSettlement(SETTLEMENT_ID_SETTLED)
+    expect(result).toStrictEqual(mappedSettlement)
+  })
+
+  test('should throw when no existing settlement exists', async () => {
+    await db.sequelize.truncate({
+      cascade: true,
+      restartIdentity: true
+    })
+
+    const wrapper = async () => { await getSettlement(1) }
+
+    expect(wrapper).rejects.toThrow()
+  })
+
+  test('should throw when no existing settlement exists', async () => {
+    await db.sequelize.truncate({
+      cascade: true,
+      restartIdentity: true
+    })
+
+    const wrapper = async () => { await getSettlement(undefined) }
+
+    expect(wrapper).rejects.toThrow()
+  })
+
+  test('should throw when no existing settlement exists', async () => {
+    await db.sequelize.truncate({
+      cascade: true,
+      restartIdentity: true
+    })
+
+    const wrapper = async () => { await getSettlement(null) }
+
+    expect(wrapper).rejects.toThrow()
+  })
+
+  test('should throw when existing unsettled settlement with required information exists', async () => {
+    const wrapper = async () => { await getSettlement(SETTLEMENT_ID_NOT_SETTLED) }
+    expect(wrapper).rejects.toThrow()
+  })
+
+  test('should throw when existing settled settlement with missing required reference does not exist', async () => {
+    delete settlement.reference
+    await db.settlement.create({ ...settlement, paymentRequestId: 1 })
+
+    const wrapper = async () => { await getSettlement(SETTLEMENT_ID_SETTLED) }
+
+    expect(wrapper).rejects.toThrow()
+  })
+
+  test('should throw when existing settled settlement with missing required settled does not exist', async () => {
+    delete settlement.settled
+    await db.settlement.create({ ...settlement, paymentRequestId: 1 })
+
+    const wrapper = async () => { await getSettlement(SETTLEMENT_ID_SETTLED) }
+
+    expect(wrapper).rejects.toThrow()
+  })
+})

test/integration/processing/settlement/validate-settlement.test.js

@@ -0,0 +1,113 @@
+const validateSettlement = require('../../../../app/processing/settlement/validate-settlement')
+
+let retreivedSettlement
+
+describe('validate settlement', () => {
+  beforeEach(() => {
+    const settlement = JSON.parse(JSON.stringify(require('../../../mock-settlement')))
+    retreivedSettlement = {
+      paymentRequestId: 1,
+      reference: settlement.reference,
+      settled: settlement.settled
+    }
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should return retreivedSettlement', async () => {
+    const result = validateSettlement(retreivedSettlement)
+    expect(result).toStrictEqual(retreivedSettlement)
+  })
+
+  test('should throw when retreivedSettlement is missing required paymentRequestId', async () => {
+    delete retreivedSettlement.paymentRequestId
+
+    const wrapper = async () => {
+      validateSettlement(retreivedSettlement)
+    }
+
+    expect(wrapper).rejects.toThrow()
+  })
+
+  test('should throw Error when retreivedSettlement is missing required paymentRequestId', async () => {
+    delete retreivedSettlement.paymentRequestId
+
+    const wrapper = async () => {
+      validateSettlement(retreivedSettlement)
+    }
+
+    expect(wrapper).rejects.toThrow(Error)
+  })
+
+  test('should throw error which ends "does not have the required data: "paymentRequestId" is required" when retreivedSettlement is missing required paymentRequestId', async () => {
+    delete retreivedSettlement.paymentRequestId
+
+    const wrapper = async () => {
+      validateSettlement(retreivedSettlement)
+    }
+
+    expect(wrapper).rejects.toThrow(/does not have the required data: "paymentRequestId" is required/)
+  })
+
+  test('should throw when retreivedSettlement is missing required reference', async () => {
+    delete retreivedSettlement.reference
+
+    const wrapper = async () => {
+      validateSettlement(retreivedSettlement)
+    }
+
+    expect(wrapper).rejects.toThrow()
+  })
+
+  test('should throw Error when retreivedSettlement is missing required reference', async () => {
+    delete retreivedSettlement.reference
+
+    const wrapper = async () => {
+      validateSettlement(retreivedSettlement)
+    }
+
+    expect(wrapper).rejects.toThrow(Error)
+  })
+
+  test('should throw error which ends "does not have the required data: "reference" is required" when retreivedSettlement is missing required reference', async () => {
+    delete retreivedSettlement.reference
+
+    const wrapper = async () => {
+      validateSettlement(retreivedSettlement)
+    }
+
+    expect(wrapper).rejects.toThrow(/does not have the required data: "reference" is required/)
+  })
+
+  test('should throw when retreivedSettlement is missing required settled', async () => {
+    delete retreivedSettlement.settled
+
+    const wrapper = async () => {
+      validateSettlement(retreivedSettlement)
+    }
+
+    expect(wrapper).rejects.toThrow()
+  })
+
+  test('should throw Error when retreivedSettlement is missing required settled', async () => {
+    delete retreivedSettlement.settled
+
+    const wrapper = async () => {
+      validateSettlement(retreivedSettlement)
+    }
+
+    expect(wrapper).rejects.toThrow(Error)
+  })
+
+  test('should throw error which ends "does not have the required data: "settled" is required" when retreivedSettlement is missing required settled', async () => {
+    delete retreivedSettlement.settled
+
+    const wrapper = async () => {
+      validateSettlement(retreivedSettlement)
+    }
+
+    expect(wrapper).rejects.toThrow(/does not have the required data: "settled" is required/)
+  })
+})