:recycle: fix-up all backend tests

backend/lib/routes/membership/join.js

          */
         handler: async function (request, h) {
             try {
-                console.log('---')
                 const { membershipService } = request.server.services()
 
                 /** Grab payload info */

backend/lib/services/profile/index.js

         // taking the info from profilesEntries
         // to repack into completeProfiles
         // in same order as profileIdArray
-        return profiler.makeOrderedCompleteProfiles(
+        const ordered = profiler.makeOrderedCompleteProfiles(
             profileIdArray,
             profilesEntries,
             type,
             this.tagLookup,
         )
+        return ordered
     }
 
     /**
     }
 
     async calcProfileDistances(matchPool, distanceUnit, userZip) {
-        await Promise.all(
+        return await Promise.all(
             matchPool.map(async profile => {
                 const targetZip = zipcoder.getZipCodeFromProfile(profile)
                 if (!userZip || !targetZip)

backend/lib/services/profile/profiler.js

     }
 }
 const _makeCompleteProfile = (profileEntry, type, tagLookup) => {
-    profileEntry.tags = profileEntry.tags.map(tag => tagLookup[tag.tag_id])
+    // remap tags
+    if (profileEntry && profileEntry.tags.length) {
+        profileEntry.tags = profileEntry?.tags.map(tag => tagLookup[tag.tag_id])
+    }
     const complete = new CompleteProfile(profileEntry, type)
     return complete
 }

backend/tests/matchqueue.spec.js

      */
     server.registerModel = () => {}
     server.models = () => ({ Aspect, AspectLabel, MatchQueue, Profile })
+
+    /**
+     * Register mock authentication just for testing
+     * -
+     * Profile plugin does not do this
+     */
+    server.auth.scheme('jwt', () => ({
+        authenticate: (req, h) => h.authenticated({ credentials: {} }),
+    }))
+    server.auth.strategy('default_jwt', 'jwt')
+
     /**
      * Register Routes and Services as usual
      */

backend/tests/membership-join.spec.js

         Grouping,
         Membership,
     })
+
+    /**
+     * Register mock authentication just for testing
+     * -
+     * Profile plugin does not do this
+     */
+    server.auth.scheme('jwt', () => ({
+        authenticate: (req, h) => h.authenticated({ credentials: {} }),
+    }))
+    server.auth.strategy('default_jwt', 'jwt')
+
     await plugin.register(server)
+
     server.services()['profileService'] = new ProfileService(server)
     /**
      * TODO: adjust stubs to mock joinGrouping more closely

backend/tests/membership.spec.js

 const test = require('ava')
 const { stub } = require('sinon')
 const Hapi = require('@hapi/hapi')
+const Objection = require('objection')
 
 const plugin = require('../lib/plugins/membership')
 
 const ProfileService = require('../lib/services/profile')
-const MembershipService = require('../lib/services/membership')
+const UserService = require('../lib/services/user')
 
 const Profile = require('../lib/models/profile')
 const Grouping = require('../lib/models/grouping')
 const Membership = require('../lib/models/membership')
 const Tag = require('../lib/models/tag')
-const ZipCode = require('../lib/models/zip-code')
 const Aspect = require('../lib/models/aspect')
 const AspectLabel = require('../lib/models/aspect_label')
 
 const mockReturn = {
     profile: {
         profile_id: 99,
-        user_id: 99,
         user: {
-            user_email: '',
-            user_name: 'bob',
+            user_id: 22,
+            user_email: 'jill@mail',
+            user_name: 'jill',
         },
         responses: [],
         tags: [],
                 { val: 'foo', response_key_id: 11 },
                 { val: 'foo', response_key_id: 12 },
             ],
-            user: { user_name: 'phil' },
+            user: { user_id: 11, user_name: 'phil' },
         },
         {
             profile_id: 2,
                 { val: 'foo', response_key_id: 11 },
                 { val: 'foo', response_key_id: 12 },
             ],
-            user: { user_name: 'gil' },
+            user: { user_id: 30, user_name: 'gil' },
         },
         {
             profile_id: 99,
                 { val: 'foo', response_key_id: 11 },
                 { val: 'foo', response_key_id: 12 },
             ],
-            user: { user_name: 'jill' },
+            user: { user_id: 22, user_name: 'jill', user_email: 'jill@mail' },
         },
     ],
     tags: [],
         Tag,
     })
 
-    // server.registerService(ProfileService)
+    /**
+     * Register mock authentication just for testing
+     * -
+     * Profile plugin does not do this
+     */
+    server.auth.scheme('jwt', () => ({
+        authenticate: (req, h) => h.authenticated({ credentials: {} }),
+    }))
+    server.auth.strategy('default_jwt', 'jwt')
+
+    // stub(Objection, 'transaction').returns({})
+
     /**
      * Register Routes and Services as usual
      */
      * !: Janky - might be better to temp knex sqlite instance
      */
     server.services()['profileService'] = new ProfileService(server)
+    server.services()['profileService'].getTagsFor = () => []
+
+    // TODO: delete this and figure out stub for Profile
+    server.services()['profileService'].getProfilesFor = () =>
+        mockReturn.profiles
+
+    server.services()['userService'] = new UserService(server)
+    server.services()['userService'].findById = () => mockReturn.profile.user
+
     stub(server.models()['Tag'], 'query').returns(mockReturn.tags)
     stub(server.models()['AspectLabel'], 'query').returns(mockReturn.labels)
     stub(server.models()['Aspect'], 'query').returns(mockReturn.aspects)
     stub(server.models()['Grouping'], 'query').returns({
         whereIn: () => ({
-            withGraphFetched: () => {
-                return mockReturn.groupings
-            },
+            withGraphFetched: () => mockReturn.groupings,
         }),
     })
     stub(server.models()['Membership'], 'query').returns({
-        where: () => {
-            return mockReturn.memberships
-        },
-        whereIn: () => {
-            return mockReturn.memberships
-        },
+        where: () => mockReturn.memberships,
+        whereIn: () => mockReturn.memberships,
     })
     stub(server.models()['Profile'], 'query').returns({
         // Mocked for getProfile()

backend/tests/profile.spec.js

 'use strict'
-
 const test = require('ava')
 const { stub } = require('sinon')
 const Hapi = require('@hapi/hapi')
      * Schwifty at runtime.
      */
     const server = Hapi.server()
+
     /**
      * Overload so we don't register any models
      * using the plugin call (see plugins/profile.js)
      */
     server.registerModel = () => {}
     server.models = () => ({ Profile, Tag })
+
+    /**
+     * Register mock authentication just for testing
+     * -
+     * Profile plugin does not do this
+     */
+    server.auth.scheme('jwt', () => ({
+        authenticate: (req, h) => h.authenticated({ credentials: {} }),
+    }))
+    server.auth.strategy('default_jwt', 'jwt')
+
     /**
      * Register Routes and Services as usual
      */
     await plugin.register(server)
+
     /**
      * Replace Objection model methods with our own mock functions
      * !: Janky - might be better to temp knex sqlite instance

backend/tests/respond.spec.js

      */
     server.registerModel = () => {}
     server.models = () => ({ Response, ResponseKey })
+
+    /**
+     * Register mock authentication just for testing
+     * -
+     * Profile plugin does not do this
+     */
+    server.auth.scheme('jwt', () => ({
+        authenticate: (req, h) => h.authenticated({ credentials: {} }),
+    }))
+    server.auth.strategy('default_jwt', 'jwt')
+
     /**
      * Register Routes and Services as usual
      */

backend/tests/score.spec.js

 const AspectLabel = require('../lib/models/aspect_label')
 
 // !: Must match the key set in servives/profile.js
-const zipcodeKey = 7
+const zipcodeKey = 10
 
 /**
  * Route parameters
             responses: [
                 { response_key_id: 1, val: '100' },
                 { response_key_id: 2, val: '200' },
+                { response_key_id: 3, val: '200' },
+                { response_key_id: 4, val: '200' },
+                { response_key_id: 5, val: '200' },
+                { response_key_id: 6, val: '200' },
+                { response_key_id: 7, val: '200' },
+                { response_key_id: 8, val: '200' },
+                { response_key_id: 9, val: '200' },
                 { response_key_id: zipcodeKey, val: '90065' },
             ],
         },
             responses: [
                 { response_key_id: 1, val: '100' },
                 { response_key_id: 2, val: '200' },
+                { response_key_id: 3, val: '200' },
+                { response_key_id: 4, val: '200' },
+                { response_key_id: 5, val: '200' },
+                { response_key_id: 6, val: '200' },
+                { response_key_id: 7, val: '200' },
+                { response_key_id: 8, val: '200' },
+                { response_key_id: 9, val: '200' },
                 { response_key_id: zipcodeKey, val: '97002' },
             ],
         },
             responses: [
                 { response_key_id: 1, val: '200' },
                 { response_key_id: 2, val: '200' },
+                { response_key_id: 3, val: '200' },
+                { response_key_id: 4, val: '200' },
+                { response_key_id: 5, val: '200' },
+                { response_key_id: 6, val: '200' },
+                { response_key_id: 7, val: '200' },
+                { response_key_id: 8, val: '200' },
+                { response_key_id: 9, val: '200' },
                 { response_key_id: zipcodeKey, val: '96741' },
             ],
         },
         Profile,
         ZipCode,
     })
+
+    /**
+     * Register mock authentication just for testing
+     * -
+     * Profile plugin does not do this
+     */
+    server.auth.scheme('jwt', () => ({
+        authenticate: (req, h) => h.authenticated({ credentials: {} }),
+    }))
+    server.auth.strategy('default_jwt', 'jwt')
+
     /**
      * Register Routes and Services as usual
      */

backend/tests/update.spec.js

 
 const Response = require('../lib/models/response')
 const ResponseKey = require('../lib/models/response-key')
+const ProfileService = require('../lib/services/profile')
 /**
  * Route parameters
  */
      */
     server.registerModel = () => {}
     server.models = () => ({ Response, ResponseKey })
+
+    /**
+     * Register mock authentication just for testing
+     * -
+     * Profile plugin does not do this
+     */
+    server.auth.scheme('jwt', () => ({
+        authenticate: (req, h) => h.authenticated({ credentials: {} }),
+    }))
+    server.auth.strategy('default_jwt', 'jwt')
+
     /**
      * Register Routes and Services as usual
      */
     await plugin.register(server)
+
     /**
      * Replace Objection model methods with our own mock functions
      * !: Janky - might be better to temp knex sqlite instance