:gear: adjust test for queue return

backend/lib/routes/profile/patch-queue.js

                 responses: Joi.array().items(),
                 user_type: Joi.any(),
             }),
-        )
+        ),
     ),
     error: Joi.object({
         error: Joi.string(),
     }),
 }
 
-
 const validators = {
     params: Joi.object({ profile_id: Joi.number(), target_id: Joi.number() }),
-    query: Joi.object({ include_profile:Joi.bool(), reinsert: Joi.boolean() }),
+    query: Joi.object({ include_profile: Joi.bool(), reinsert: Joi.boolean() }),
 }
 
 module.exports = {
         handler: async function (request, h) {
             const { profile_id, target_id } = request.params
             const { include_profile, reinsert } = request.query
-            const { profileService, matchQueueService } = request.server.services()
+            const { profileService, matchQueueService } =
+                request.server.services()
             const updatedQueue = await matchQueueService.markAsDeleted(
                 profile_id,
                 target_id,
                 reinsert,
             )
             const queueIds = updatedQueue.map(entry => entry.target_id)
-            const res =  {
-                ok:true,
+            const res = {
+                ok: true,
                 handler: pluginConfig.handlerType,
-                data: queueIds
+                data: queueIds,
             }
-            if(include_profile) {
+            if (include_profile) {
                 res.data = await profileService.getProfilesFor(queueIds)
             }
             try {
                 return h.response(res).code(200)
             } catch (err) {
-                return h.response({
-                    ok:false,
-                    handler: pluginConfig.handlerType,
-                    data: { error: `${err}`}
-                }).code(409)
-
+                return h
+                    .response({
+                        ok: false,
+                        handler: pluginConfig.handlerType,
+                        data: { error: `${err}` },
+                    })
+                    .code(409)
             }
         },
         /** Validate based on validators object */

backend/tests/matchqueue.spec.js

 'use strict'
 
 const test = require('ava')
-const { stub } = require('sinon')
+const { stub, mock } = require('sinon')
 const Hapi = require('@hapi/hapi')
 
 const plugin = require('../lib/plugins/profile')
 
 const MatchQueue = require('../lib/models/matchqueue')
-
+/**
+ * Route parameters
+ */
+const params = {
+    profile_id: 1,
+    target_id: 2,
+    reinsert: true,
+    include_profile: false,
+}
+const mockReturn = {
+    queue: [
+        { mocked_profile_id: 1, target_id: 2, is_deleted: false },
+        { mocked_profile_id: 2, target_id: 3, is_deleted: false },
+        { mocked_profile_id: 3, target_id: 1, is_deleted: false },
+    ],
+}
 test('path / should return ok on GET', async t => {
     /**
      * Create a new server and register services,
      * Schwifty at runtime.
      */
     const server = Hapi.server()
+    /**
+     * Overload so we don't register any models
+     * using the plugin call (see plugins/profile.js)
+     * and Manually load the model we need for the test
+     */
     server.registerModel = () => {}
     server.models = () => ({ MatchQueue })
-    await plugin.register(server)
-
     /**
-     * Route parameters
+     * Register Routes and Services as usual
      */
-    const profile_id = 1
-    const target_id = 2
-    const reinsert = true
-
+    await plugin.register(server)
     /**
      * Replace Objection model methods with our own custom functions
      * !: Kinda janky - might be better to temp knex sqlite instance
             }),
         }),
         insert: queueRecord => {
-            t.is(queueRecord.profile_id, profile_id)
-            t.is(queueRecord.target_id, target_id)
-            t.is(queueRecord.is_deleted, !reinsert)
+            t.is(queueRecord.profile_id, params.profile_id)
+            t.is(queueRecord.target_id, params.target_id)
+            t.is(queueRecord.is_deleted, !params.reinsert)
         },
         // Mocked for getQueue()
         where: () => ({
-            andWhere: (cmd, val) => {
-                return [
-                    { mocked_profile_id: 1, is_deleted: val },
-                    { mocked_profile_id: 2, is_deleted: val },
-                    { mocked_profile_id: 3, is_deleted: val },
-                ]
-            },
+            andWhere: (cmd, val) => mockReturn.queue,
         }),
     })
 
      */
     const { payload } = await server.inject({
         method: 'PATCH',
-        url: `/${profile_id}/queue/${target_id}/delete?reinsert=${reinsert}`,
+        url: `/${params.profile_id}/queue/${params.target_id}/delete?include_profile=${params.include_profile}&reinsert=${params.reinsert}`,
     })
     const res = JSON.parse(payload)
-
-    t.deepEqual(res, [
-        { mocked_profile_id: 1, is_deleted: false },
-        { mocked_profile_id: 2, is_deleted: false },
-        { mocked_profile_id: 3, is_deleted: false },
-    ])
+    t.deepEqual(res.ok, true)
+    t.deepEqual(
+        res.data,
+        mockReturn.queue.map(entry => entry.target_id),
+    )
 })