gpii-universal/gpii/node_modules/flowManager/test/PrefsServerDataSourceTests.js

Cross platform, core components of the GPII personalization infrastructure.

/*!
GPII Preferences Server Data Source Tests

Copyright 2018 OCAD University

Licensed under the New BSD license. You may not use this file except in
compliance with this License.

You may obtain a copy of the License at
https://github.com/GPII/universal/blob/master/LICENSE.txt
*/

"use strict";

var fluid = require("infusion"),
    gpii = fluid.registerNamespace("gpii"),
    kettle = require("kettle"),
    nock = require("nock");

require("flowManager");

fluid.require("%gpii-universal/gpii/node_modules/testing/src/NockUtils.js");

kettle.loadTestingSupport();

fluid.registerNamespace("gpii.tests.prefsServerDataSource");

gpii.tests.prefsServerDataSource.hostname = "http://gpii.net";
gpii.tests.prefsServerDataSource.preferencesUrl = "/preferences/%gpiiKey?merge=%merge";
gpii.tests.prefsServerDataSource.readyUrl = "/ready";
gpii.tests.prefsServerDataSource.gpiiKey = "gpii-key-test";
gpii.tests.prefsServerDataSource.preferences = {
    "http://registry.gpii.net/common/fontSize": 24
};

gpii.tests.prefsServerDataSource.nockConfig = {
    preferencesGet: {
        url: fluid.stringTemplate(gpii.tests.prefsServerDataSource.preferencesUrl, {
            gpiiKey: gpii.tests.prefsServerDataSource.gpiiKey
        }),
        status: 200,
        response: {
            preferences: "user preferences received successfully"
        }
    },
    preferencesPut: {
        url: fluid.stringTemplate(gpii.tests.prefsServerDataSource.preferencesUrl, {
            gpiiKey: gpii.tests.prefsServerDataSource.gpiiKey,
            merge: "true"
        }),
        preferences: gpii.tests.prefsServerDataSource.preferences,
        status: 200,
        response: {
            preferences: "saved successfully",
            merge: true
        }
    },
    preferencesPost: {
        url: fluid.stringTemplate(gpii.tests.prefsServerDataSource.preferencesUrl),
        preferences: gpii.tests.prefsServerDataSource.preferences,
        status: 200,
        response: {
            preferences: "saved successfully"
        }
    },
    ready: {
        url: gpii.tests.prefsServerDataSource.readyUrl,
        status: 200,
        response: {
            isReady: true
        }
    }
};

// Set up mock ajax responses
gpii.tests.prefsServerDataSource.setUpNock = function (config) {
    var cloudMock = nock(gpii.tests.prefsServerDataSource.hostname);

    // log nock matches
    cloudMock.log(console.log);

    // mock GET requests to "/preferences"
    cloudMock.get(config.preferencesGet.url)
        .reply(config.preferencesGet.status, config.preferencesGet.response);

    // mock PUT requests to "/preferences"
    cloudMock.put(config.preferencesPut.url, gpii.tests.prefsServerDataSource.preferences)
        .reply(config.preferencesPut.status, config.preferencesPut.response);

    // mock POST requests to "/preferences"
    cloudMock.post(config.preferencesPost.url, gpii.tests.prefsServerDataSource.preferences)
        .reply(config.preferencesPost.status, config.preferencesPost.response);

    // mock GET requests to "/ready"
    cloudMock.get(config.ready.url)
        .reply(config.ready.status, config.ready.response);
};

// The customized prefsServerDataSource component for tests
fluid.defaults("gpii.tests.prefsServerDataSource", {
    gradeNames: ["gpii.flowManager.prefsServerDataSource"],
    prefsServerURL: gpii.tests.prefsServerDataSource.hostname
});

fluid.defaults("gpii.tests.prefsServerDataSourceTests", {
    gradeNames: ["fluid.test.testEnvironment", "fluid.test.testCaseHolder", "gpii.test.testWithNock"],
    invokers: {
        setUpNock: {
            funcName: "gpii.tests.prefsServerDataSource.setUpNock",
            args: gpii.tests.prefsServerDataSource.nockConfig
        }
    },
    components: {
        prefsServerDataSource: {
            type: "gpii.tests.prefsServerDataSource"
        }
    },
    events: {
        onResponse: null,
        onError: null
    }
});

fluid.defaults("gpii.tests.prefsServerDataSourceTests.tests", {
    gradeNames: ["gpii.tests.prefsServerDataSourceTests"],
    modules: [
        {
            name: "Get preferences",
            tests: {
                name: "Test get()",
                expect: 1,
                sequence: [{
                    task: "{prefsServerDataSource}.get",
                    args: [gpii.tests.prefsServerDataSource.gpiiKey],
                    resolve: "jqUnit.assertValue",
                    resolveArgs: ["The user preferences are received", "{arguments}.0.preferences"]
                }]
            }
        },
        {
            name: "Update preferences",
            tests: {
                name: "Test update()",
                expect: 1,
                sequence: [{
                    task: "{prefsServerDataSource}.update",
                    args: [gpii.tests.prefsServerDataSource.gpiiKey, true, gpii.tests.prefsServerDataSource.preferences],
                    resolve: "jqUnit.assertTrue",
                    resolveArgs: ["The preferences are updated successfully", "{arguments}.0.merge"]
                }]
            }
        },
        {
            name: "Check the liveness of the preferences server",
            tests: {
                name: "Test isLive()",
                expect: 1,
                sequence: [{
                    task: "{prefsServerDataSource}.isLive",
                    args: [],
                    resolve: "jqUnit.assertTrue",
                    resolveArgs: ["The expected liveness flag is received", "{arguments}.0"]
                }]
            }
        }
    ]
});

fluid.test.runTests([
    "gpii.tests.prefsServerDataSourceTests.tests"
]);