Merge branch 'membership-join-test' of fyindr/siimee into dev

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

+'use strict'
+
+const test = require('ava')
+const { stub } = require('sinon')
+const Hapi = require('@hapi/hapi')
+
+const plugin = require('../lib/plugins/membership')
+
+const Grouping = require('../lib/models/grouping')
+const Membership = require('../lib/models/membership')
+
+const ProfileService = require('../lib/services/profile')
+
+const params = {
+    profile_id: 3,
+}
+const mockReturn = {
+    memberships: [
+        {
+            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: false,
+    groupings: [],
+}
+const pathToTest = {
+    method: 'POST',
+    url: `/${params.profile_id}/join`,
+    payload: {
+        grouping_id: 3,
+        grouping_name: 'test_match',
+        grouping_type: 'test_group',
+        target_id: 1,
+        role: 'participant',
+    },
+}
+
+let membership_id = 4
+test(`path ${pathToTest.url} should return two memberships`, async t => {
+    const server = Hapi.server()
+    server.registerModel = () => {}
+    server.models = () => ({
+        Grouping,
+        Membership,
+    })
+    await plugin.register(server)
+    server.services()['profileService'] = new ProfileService(server)
+    /**
+     * TODO: adjust stubs to mock joinGrouping more closely
+     */
+    stub(server.models()['Grouping'], 'query').returns({
+        whereIn: () => mockReturn.groupings,
+    })
+    stub(server.models()['Membership'], 'query').returns({
+        where: pid => {
+            if (pid == 'membership_id') {
+                return {
+                    where: () => ({
+                        patch: () => {},
+                    }),
+                }
+            }
+            return mockReturn.memberships.filter(
+                membership => membership.profile_id == pid.profile_id,
+            )
+        },
+        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)
+    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' },
             ],
         },