refactor: convert MyInfo hash update to domain method

src/app/controllers/myinfo.server.controller.js

@@ -83,45 +83,17 @@ exports.addMyInfo = (myInfoService) => async (req, res, next) => {
 
   Promise.props(readOnlyHashPromises)
     .then((readOnlyHashes) => {
-      // Add to DB only if uinFin-form combo not already present
-      let filter = {
-        uinFin: hashedUinFin,
-        form: formId,
-      }
-      MyInfoHash.findOneAndUpdate(
-        filter,
-        {
-          $set: _.extend(
-            {
-              fields: readOnlyHashes,
-              expireAt: Date.now() + myInfoService.spCookieMaxAge,
-            },
-            filter,
-          ),
-        },
-        {
-          upsert: true,
-        },
-        (err) => {
-          if (err) {
-            res.locals.myInfoError = true
-            logger.error({
-              message: 'Error writing to DB',
-              meta: {
-                action: 'addMyInfo',
-                ...createReqMeta(req),
-                formId,
-              },
-              error: err,
-            })
-          }
-          return next()
-        },
+      return MyInfoHash.updateHashes(
+        hashedUinFin,
+        formId,
+        readOnlyHashes,
+        myInfoService.spCookieMaxAge,
       )
     })
+    .then(() => next())
     .catch((error) => {
       logger.error({
-        message: 'Error hashing MyInfo fields',
+        message: 'Error saving MyInfo hashes',
         meta: {
           action: 'addMyInfo',
           ...createReqMeta(req),

src/app/models/myinfo_hash.server.model.ts

@@ -1,6 +1,6 @@
-import { Model, Mongoose, Schema } from 'mongoose'
+import { Mongoose, Schema } from 'mongoose'
 
-import { IMyInfoHashSchema } from '../../types'
+import { IHashes, IMyInfoHashModel, IMyInfoHashSchema } from '../../types'
 
 import { FORM_SCHEMA_ID } from './form.server.model'
 
@@ -43,18 +43,43 @@ MyInfoHashSchema.index({
 })
 MyInfoHashSchema.index({ expireAt: 1 }, { expireAfterSeconds: 0 })
 
+MyInfoHashSchema.statics.updateHashes = async function (
+  this: IMyInfoHashModel,
+  hashedUinFin: string,
+  formId: string,
+  readOnlyHashes: IHashes,
+  spCookieMaxAge: number,
+): Promise<IMyInfoHashSchema | null> {
+  return this.findOneAndUpdate(
+    {
+      uinFin: hashedUinFin,
+      form: formId,
+    },
+    {
+      $set: {
+        fields: readOnlyHashes,
+        expireAt: new Date(Date.now() + spCookieMaxAge),
+      },
+    },
+    { upsert: true, new: true },
+  )
+}
+
 const compileMyInfoHashModel = (db: Mongoose) =>
-  db.model<IMyInfoHashSchema>(MYINFO_HASH_SCHEMA_ID, MyInfoHashSchema)
+  db.model<IMyInfoHashSchema, IMyInfoHashModel>(
+    MYINFO_HASH_SCHEMA_ID,
+    MyInfoHashSchema,
+  )
 
 /**
  * Retrieves the MyInfoHash model on the given Mongoose instance. If the model is
  * not registered yet, the model will be registered and returned.
  * @param db The mongoose instance to retrieve the MyInfoHash model from
  * @returns The MyInfoHash model
  */
-const getMyInfoHashModel = (db: Mongoose) => {
+const getMyInfoHashModel = (db: Mongoose): IMyInfoHashModel => {
   try {
-    return db.model(MYINFO_HASH_SCHEMA_ID) as Model<IMyInfoHashSchema>
+    return db.model(MYINFO_HASH_SCHEMA_ID) as IMyInfoHashModel
   } catch {
     return compileMyInfoHashModel(db)
   }

src/types/myinfo_hash.ts

@@ -1,11 +1,13 @@
-import { Document } from 'mongoose'
+import { Document, Model } from 'mongoose'
 
 import { MyInfoAttribute } from './field'
 import { IFormSchema } from './form'
 
-type IHashes = {
-  [key in MyInfoAttribute]: string
-}
+export type IHashes = Partial<
+  {
+    [key in MyInfoAttribute]: string
+  }
+>
 
 interface IMyInfoHash {
   uinFin: string
@@ -17,3 +19,12 @@ interface IMyInfoHash {
 }
 
 export interface IMyInfoHashSchema extends IMyInfoHash, Document {}
+
+export interface IMyInfoHashModel extends Model<IMyInfoHashSchema> {
+  updateHashes: (
+    hashedUinFin: string,
+    formId: string,
+    readOnlyHashes: IHashes,
+    spCookieMaxAge: number,
+  ) => Promise<IMyInfoHashSchema | null>
+}

tests/unit/backend/models/myinfo_hash.server.model.spec.ts

@@ -0,0 +1,148 @@
+import { ObjectId } from 'bson'
+import { omit, pick } from 'lodash'
+import mongoose from 'mongoose'
+
+import getMyInfoHashModel from 'src/app/models/myinfo_hash.server.model'
+
+import dbHandler from '../helpers/jest-db'
+
+const MyInfoHash = getMyInfoHashModel(mongoose)
+
+const DEFAULT_PARAMS = {
+  uinFin: 'testUinFin',
+  form: new ObjectId(),
+  fields: { name: 'mockHash' },
+  expireAt: new Date(Date.now()),
+  created: new Date(Date.now()),
+}
+const DEFAULT_COOKIE_MAX_AGE = 5
+
+describe('MyInfo Hash Model', () => {
+  beforeAll(async () => await dbHandler.connect())
+  beforeEach(async () => await dbHandler.clearDatabase())
+  afterAll(async () => await dbHandler.closeDatabase())
+
+  describe('Schema', () => {
+    it('should create and save successfully', async () => {
+      // Act
+      const actual = await MyInfoHash.create(DEFAULT_PARAMS)
+
+      // Assert
+      // All fields should exist
+      // Object Id should be defined when successfully saved to MongoDB.
+      expect(actual._id).toBeDefined()
+      expect(
+        pick(actual, ['uinFin', 'form', 'fields', 'created', 'expireAt']),
+      ).toEqual(DEFAULT_PARAMS)
+    })
+
+    it('should throw validation error on missing uinFin', async () => {
+      // Arrange
+      const missingParams = omit(DEFAULT_PARAMS, 'uinFin')
+
+      // Act
+      const myInfoHash = new MyInfoHash(missingParams)
+      const actualPromise = myInfoHash.save()
+
+      // Assert
+      await expect(actualPromise).rejects.toThrowError(
+        mongoose.Error.ValidationError,
+      )
+    })
+
+    it('should throw validation error on missing form', async () => {
+      // Arrange
+      const missingParams = omit(DEFAULT_PARAMS, 'form')
+
+      // Act
+      const myInfoHash = new MyInfoHash(missingParams)
+      const actualPromise = myInfoHash.save()
+
+      // Assert
+      await expect(actualPromise).rejects.toThrowError(
+        mongoose.Error.ValidationError,
+      )
+    })
+
+    it('should throw validation error on missing fields', async () => {
+      // Arrange
+      const missingParams = omit(DEFAULT_PARAMS, 'fields')
+
+      // Act
+      const myInfoHash = new MyInfoHash(missingParams)
+      const actualPromise = myInfoHash.save()
+
+      // Assert
+      await expect(actualPromise).rejects.toThrowError(
+        mongoose.Error.ValidationError,
+      )
+    })
+
+    it('should throw validation error on missing expireAt', async () => {
+      // Arrange
+      const missingParams = omit(DEFAULT_PARAMS, 'expireAt')
+
+      // Act
+      const myInfoHash = new MyInfoHash(missingParams)
+      const actualPromise = myInfoHash.save()
+
+      // Assert
+      await expect(actualPromise).rejects.toThrowError(
+        mongoose.Error.ValidationError,
+      )
+    })
+  })
+
+  describe('Statics', () => {
+    describe('updateHashes', () => {
+      it('should create successfully when document does not exist', async () => {
+        // Should have no documents yet.
+        await expect(MyInfoHash.countDocuments()).resolves.toEqual(0)
+
+        // Act
+        const actual = await MyInfoHash.updateHashes(
+          DEFAULT_PARAMS.uinFin,
+          DEFAULT_PARAMS.form.toHexString(),
+          DEFAULT_PARAMS.fields,
+          DEFAULT_COOKIE_MAX_AGE,
+        )
+
+        // Assert
+        // Should now have one document.
+        await expect(MyInfoHash.countDocuments()).resolves.toEqual(1)
+        const found = await MyInfoHash.findOne({})
+        // Both the returned document and the found document should match
+        expect(pick(actual, ['uinFin', 'form', 'fields'])).toEqual(
+          pick(DEFAULT_PARAMS, ['uinFin', 'form', 'fields']),
+        )
+        expect(pick(found, ['uinFin', 'form', 'fields'])).toEqual(
+          pick(DEFAULT_PARAMS, ['uinFin', 'form', 'fields']),
+        )
+      })
+
+      it('should update successfully when a document already exists', async () => {
+        // Arrange
+        // Insert mock document into collection.
+        await MyInfoHash.create(DEFAULT_PARAMS)
+        // Should have the added document.
+        await expect(MyInfoHash.countDocuments()).resolves.toEqual(1)
+
+        const mockFields = { sex: 'F' }
+
+        // Act
+        const actual = await MyInfoHash.updateHashes(
+          DEFAULT_PARAMS.uinFin,
+          DEFAULT_PARAMS.form.toHexString(),
+          mockFields,
+          DEFAULT_COOKIE_MAX_AGE,
+        )
+        // Assert
+        await expect(MyInfoHash.countDocuments()).resolves.toEqual(1)
+        const found = await MyInfoHash.findOne({})
+        // Both the returned document and the found document should match
+        expect(actual!.fields).toEqual(mockFields)
+        expect(found!.fields).toEqual(mockFields)
+      })
+    })
+  })
+})