siimee/backend/tests/score.spec.js

'use strict'

const test = require('ava')
const { stub } = require('sinon')
const Hapi = require('@hapi/hapi')

const plugin = require('../lib/plugins/profile')

const Profile = require('../lib/models/profile')
const ZipCode = require('../lib/models/zip-code')
const MatchQueue = require('../lib/models/matchqueue')
const Aspect = require('../lib/models/aspect')
const AspectLabel = require('../lib/models/aspect_label')

// !: Must match the key set in servives/profile.js
const zipcodeKey = 7

/**
 * Route parameters
 */
const params = {
    profile_id: 1,
    max_distance: 1000,
}
const mockReturn = {
    user: [
        {
            profile_id: 1,
            user: { is_poster: 1 },
            responses: [
                { 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: [
                { 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: [
                { response_key_id: 1, val: '200' },
                { response_key_id: 2, val: '200' },
                { response_key_id: zipcodeKey, val: '96741' },
            ],
        },
    ],
    labels: [
        { aspect_id: 1, a: 100, b: 100 },
        { aspect_id: 2, a: 100, b: 200 },
        { aspect_id: 3, a: 200, b: 200 },
        { aspect_id: 4, a: 200, b: 100 },
    ],
    aspects: [
        { aspect_id: 1, 1: 111, 2: 112, 3: 113, 4: 114 },
        { aspect_id: 2, 1: 222, 2: 222, 3: 333, 4: 222 },
        { aspect_id: 3, 1: 111, 2: 112, 3: 113, 4: 114 },
        { aspect_id: 4, 1: 111, 2: 111, 3: 111, 4: 111 },
    ],
}
const pathToTest = {
    method: 'GET',
    url: `/${params.profile_id}/score?max_distance=${params.max_distance}`,
}

test(`path ${pathToTest.url} should return ok on GET`, async t => {
    /**
     * Create a new server and register services,
     * models and routes for testing
     * -
     * NOTE: We use a mocked registerModel() and register
     * models manually. Normally this is handled by
     * 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 = () => ({
        Aspect,
        AspectLabel,
        MatchQueue,
        Profile,
        ZipCode,
    })
    /**
     * 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
     */
    stub(server.models()['Profile'], 'query').returns({
        // Mocked for pathToTest(), scoreProfilesFor()
        findOne: () => ({
            withGraphFetched: () => ({
                withGraphFetched: () => mockReturn.user[0],
            }),
        }),
        // Mocked for scoreProfilesFor()
        withGraphFetched: () => ({
            withGraphFetched: () => [mockReturn.user[1], mockReturn.user[2]],
        }),
        // Mocked for _getProfileIdsForUserId()
        where: () => ({}),
        // Mocked for getCompleteProfilesFor(), getProfilesFor()
        whereIn: () => ({
            withGraphFetched: () => ({}),
        }),
        // Mocked for deleteProfile()
        delete: () => ({
            where: () => ({}),
        }),
    })
    stub(server.models()['AspectLabel'], 'query').returns(mockReturn.labels)
    stub(server.models()['Aspect'], 'query').returns(mockReturn.aspects)
    stub(server.models()['ZipCode'], 'query').returns({
        // Mocked for _latLonForZip()
        findOne: () => ({
            latitude: 38.0 + Math.random(),
            longitude: -121.0 + Math.random(),
        }),
    })
    stub(server.models()['MatchQueue'], 'query').returns({
        patch: () => ({
            where: () => ({}),
        }),
        insert: () => ({}),
        where: () => ({
            where: () => {
                return { profile_id: 99 }
            },
        }),
    })

    /**
     * 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.is(res.data.length, 2)
    t.is(res.data[0].profile_id, 3)
    server.stop()
})