:recycle: fixing all tests | finishing grouping and membership join test

backend/lib/routes/profile/score.js

                 maxDistanceMiles,
                 distanceUnit,
             )
-
             try {
                 if (!scoredProfiles) {
                     throw new RangeError('Unable to score profiles')

backend/lib/services/membership.js

             profileId,
             targetId,
         )
-
         if (matchingGroupingIds.length) {
             /** Grab all memberships associated with groupingIds */
             let memberships = await Membership.query().whereIn(
                 membership_type: role,
                 can_edit: false,
             }
-
             const userMembership = await Membership.query(txn).insert({
                 profile_id: profileId,
                 ...membershipDetailsInCommon,
                 is_active: true,
             })
-
             const targetMembership = await Membership.query(txn).insert({
                 profile_id: targetId,
                 ...membershipDetailsInCommon,
                 is_active: false,
             })
-
             return {
                 memberships: [userMembership, targetMembership],
                 groupings: [],

backend/lib/services/profile/index.js

         if (scoring._isScorableResponse(responseToSave.response_key_id)) {
             // Convert -3 to 0, 0 to 3, 3 to 6
             const offset = (config.scoreVals.length - 1) / 2
-            const indexFromInput = parseInt(responseToSave.val) + offset
-            convertedResponse.val = config.scoreVals[indexFromInput].toString()
+            const scoreFromInput = parseInt(responseToSave.val) + offset
+            const scoreFromConfig = config.scoreVals.indexOf(scoreFromInput)
+            if (scoreFromConfig < 0) {
+                console.error('score not found in possible config responses')
+            }
+            convertedResponse.val = scoreFromConfig.toString()
         }
 
         await Response.query().insert(convertedResponse)
         let profileIdsOfOppositeType = await Profile.query()
             .withGraphFetched('responses')
             .withGraphFetched('user')
-
         // TODO: Let Objection optimize this
         const isPosterOpposite = userProfile.user.is_poster == 1 ? 0 : 1
         profileIdsOfOppositeType = profileIdsOfOppositeType
                 }
             }),
         )
+
         const distanceFilteredProfiles = zipcoder.filterByDistance(
             profilePlusDistance,
             maxDistance,
             userProfile,
             this.scoreLookup,
         )
-
         // Order by score
         return scoredProfilesWithDistance.sort(
             (a, b) => b.score.total - a.score.total,

backend/lib/services/profile/scorer.js

         return {
             error: `complete responses for profile: ${seeker.profile_id} unqeual to profile: ${potentialMatch.profile_id} | ${seeker.responses.length}:${potentialMatch.responses.length}`,
         }
-
     const aRes = seeker.responses.filter(res =>
         _isScorableResponse(res.response_key_id),
     )

backend/tests/matchqueue.spec.js

     stub(server.models()['AspectLabel'], 'query').returns(mockReturn.labels)
     stub(server.models()['Aspect'], 'query').returns(mockReturn.aspects)
     stub(server.models()['MatchQueue'], 'query').returns({
-        // Mocked for markAsDeleted()
-        patch: () => ({
-            where: () => ({
-                andWhere: () => ({
-                    first: () => ({ patch: 'bop' }),
-                }),
-            }),
-        }),
         insert: queueRecord => {
             t.is(queueRecord.profile_id, params.profile_id)
             t.is(queueRecord.target_id, params.target_id)
             where: (cmd, val) => {
                 return mockReturn.queue
             },
+            // Mocked for markAsDeleted()
+            andWhere: () => ({
+                patch: () => ({
+                    first: () => ({
+                        patch: 'bop',
+                    }),
+                }),
+            }),
         }),
     })
 
      */
     const { payload } = await server.inject(pathToTest)
     const res = JSON.parse(payload)
-
     t.deepEqual(res.ok, true)
     t.deepEqual(
         res.data,

backend/tests/membership-join.spec.js

 const ProfileService = require('../lib/services/profile')
 
 const params = {
-    profile_id: 3
+    profile_id: 3,
 }
 const mockReturn = {
     memberships: [
-        { membership_id: 1, grouping_id: 1, is_active: false, profile_id: 3},
-        { membership_id: 2, grouping_id: 2, is_active: false, profile_id: 1},
-        { membership_id: 4, grouping_id: 3, is_active: false, profile_id: 2},
+        {
+            membership_id: 4,
+            profile_id: 3,
+            grouping_id: 3,
+            membership_type: 'participant',
+            can_edit: false,
+            is_active: true,
+        },
+        {
+            membership_id: 5,
+            profile_id: 1,
+            grouping_id: 3,
+            membership_type: 'participant',
+            can_edit: false,
+            is_active: false,
+        },
     ],
-    hasMatch: true,
-    groupings: [
-        { grouping_id: 1, profiles: [{ profile_id: 1 }, { profile_id: 3 }] },
-        { grouping_id: 2, profiles: [{ profile_id: 2 }, { profile_id: 1 }] },
-    ]
+    hasMatch: false,
+    groupings: [],
 }
 const pathToTest = {
     method: 'POST',
         grouping_name: 'test_match',
         grouping_type: 'test_group',
         target_id: 1,
-        role: 'participant'
+        role: 'participant',
     },
 }
 
-test(`path ${pathToTest.url} should return ok on POST`, async t => {
-    console.log('-------------------------------\n')
+let membership_id = 4
+test(`path ${pathToTest.url} should return two memberships`, async t => {
     const server = Hapi.server()
     server.registerModel = () => {}
     server.models = () => ({
      * TODO: adjust stubs to mock joinGrouping more closely
      */
     stub(server.models()['Grouping'], 'query').returns({
-        whereIn: () => {
-            return mockReturn.groupings
-        },
+        whereIn: () => mockReturn.groupings,
     })
     stub(server.models()['Membership'], 'query').returns({
-        where: (pid) => {
-            console.log('pid', pid)
-            if(pid == 'membership_id') {
+        where: pid => {
+            if (pid == 'membership_id') {
                 return {
                     where: () => ({
-                        patch: () => {} 
-                    })
+                        patch: () => {},
+                    }),
                 }
             }
-            return mockReturn.memberships.filter(membership => {
-                return membership.profile_id == pid.profile_id
-            })
-        },
-        insert: () => {
-            mockReturn.memberships.push({ membership_id: 3, grouping_id: 3, is_active: true })
+            return mockReturn.memberships.filter(
+                membership => membership.profile_id == pid.profile_id,
+            )
         },
-        whereIn: () => {
-            return mockReturn.memberships
+        insert: toInsert => {
+            const membership = { membership_id, ...toInsert }
+            mockReturn.memberships.push(membership)
+            membership_id++
+            return membership
         },
+        whereIn: () => mockReturn.memberships,
     })
 
     /**
      * Test the server with registered models and services
      */
     const { payload } = await server.inject(pathToTest)
-    console.log('payload', payload)
     const res = JSON.parse(payload)
     t.deepEqual(res.ok, true)
     t.deepEqual(res.data, mockReturn)
     server.stop()
-})
+})

backend/tests/respond.spec.js

             response_id: 1,
             profile_id: 38,
             response_key_id: 6,
-            val: '400',
+            val: '2056',
         },
         {
             response_id: 2,
 }
 const pathToTest = {
     method: 'POST',
-    url: `/${params.profile_id}/respond?response_key_id=5&val=999`,
+    url: `/${params.profile_id}/respond?response_key_id=5&val=2053`,
 }
 
 test('path /<profile_id>/respond should return ok on POST', async t => {

backend/tests/score.spec.js

             profile_id: 1,
             user: { is_poster: 1 },
             responses: [
-                { val: '100' },
-                { val: '200' },
+                { response_key_id: 1, val: '100' },
+                { response_key_id: 2, val: '200' },
                 { response_key_id: zipcodeKey, val: '90065' },
             ],
         },
             profile_id: 2,
             user: { is_poster: 0 },
             responses: [
-                { val: '100' },
-                { val: '200' },
+                { response_key_id: 1, val: '100' },
+                { response_key_id: 2, val: '200' },
                 { response_key_id: zipcodeKey, val: '97002' },
             ],
         },
             profile_id: 3,
             user: { is_poster: 0 },
             responses: [
-                { val: '200' },
-                { val: '200' },
+                { response_key_id: 1, val: '200' },
+                { response_key_id: 2, val: '200' },
                 { response_key_id: zipcodeKey, val: '96741' },
             ],
         },