testLanguage.js

/*
 * Tests for Windows Language
 *
 * Copyright 2018 Raising the Floor - International
 *
 * Licensed under the New BSD license. You may not use this file except in
 * compliance with this License.
 *
 * The R&D leading to these results received funding from the
 * Department of Education - Grant H421A150005 (GPII-APCP). However,
 * these results do not necessarily represent the policy of the
 * Department of Education, and you should not assume endorsement by the
 * Federal Government.
 *
 * You may obtain a copy of the License at
 * https://github.com/GPII/universal/blob/master/LICENSE.txt
 */

"use strict";

var fluid = require("gpii-universal");
var jqUnit = fluid.require("node-jqunit");
var gpii = fluid.registerNamespace("gpii");

require("../src/language.js");

fluid.registerNamespace("gpii.tests.windows.language");

jqUnit.module("Language tests");

// Tests for getLanguageNames();
// Language code casing tests (from https://tools.ietf.org/html/rfc5646#appendix-A)
// expected => [inputs]
gpii.tests.windows.language.codeCaseTests = fluid.freezeRecursive({
    fullCodes: [
        "bg-BG",
        "ko-KR",
        "TE-in",
        "PL-PL"
    ],
    tests: {
        // Simple language subtag, without region (expanded using fullCode):
        "bg-BG": ["bg", "BG"],
        "ko-KR": ["ko", "KO"],
        "te-IN": ["te", "TE"],
        "pl-PL": ["pl", "pl"],
        // Unknown languages
        "": ["xx", "XX", "xx-YY", "XX-yy"],

        // Actual language packs for Windows
        "az-Latn-AZ": ["az-Latn-az", "AZ-Latn-AZ"],
        "bs-Latn-BA": ["bs-Latn-ba", "BS-Latn-BA"],
        "ku-Arab-IQ": ["ku-ARAB-iq", "KU-ARAB-IQ"],
        "chr-Cher-US": ["chr-CHER-us", "CHR-CHER-US"],
        "prs-AF": ["prs-af", "PRS-AF"],
        "fil-PH": ["fil-ph", "FIL-PH"],
        "ha-Latn-NG": ["ha-Latn-ng", "HA-Latn-NG"],
        "iu-Latn-CA": ["iu-Latn-ca", "IU-Latn-CA"],
        "quc-Latn-GT": ["quc-Latn-gt", "QUC-Latn-GT", "qut-gt", "QUT-GT"],
        "kok-IN": ["kok-in", "KOK-IN"],
        "pa-Arab-PK": ["pa-Arab-pk", "PA-Arab-PK"],
        "quz-PE": ["quz-pe", "QUZ-PE"],
        "sr-Cyrl-BA": ["sr-Cyrl-ba", "SR-Cyrl-BA"],
        "sr-Cyrl-CS": ["sr-Cyrl-cs", "SR-Cyrl-CS"],
        "sr-Cyrl-RS": ["sr-Cyrl-rs", "SR-Cyrl-RS"],
        "nso-ZA": ["nso-za", "NSO-ZA"],
        "sd-Arab-PK": ["sd-Arab-pk", "SD-Arab-PK"],
        "tg-Cyrl-TJ": ["tg-Cyrl-tj", "TG-Cyrl-TJ"],
        "uz-Latn-UZ": ["uz-Latn-uz", "UZ-Latn-UZ"],
        "ca-ES-valencia": ["ca-ES-valencia", "CA-ES-valencia"]
    }
});

// Tests for getLanguageNames();
gpii.tests.windows.language.nameTests = fluid.freezeRecursive([
    {
        input: "en",
        expect: {
            "en": {
                "english": "English",
                "local": "English",
                "native": "English",
                "code": "en"
            }
        }
    },
    // Perform the tests in a single chunk, to save starting so many processes.
    {
        input: ["en-US", "eN-Gb", "eN-Gb", "es-ES", "es-MX", "fr", "bg", "bg-BG", "bg-GB", "ta-LK", "zh-DE", "en-xyz"],
        expect: {
            "en-US": {
                "english": "English (United States)",
                "local": "English (United States)",
                "native": "English (United States)",
                "code": "en-US",
                "current": true
            },
            "eN-Gb": {
                "english": "English (United Kingdom)",
                "local": "English (United Kingdom)",
                "native": "English (United Kingdom)",
                "code": "eN-Gb"
            },
            "es-ES": {
                "english": "Spanish (Spain)",
                "local": "Spanish (Spain)",
                "native": "Español (España)",
                "code": "es-ES"
            },
            "es-MX": {
                "english": "Spanish (Mexico)",
                "local": "Spanish (Mexico)",
                "native": "Español (México)",
                "code": "es-MX"
            },
            "fr": {
                "english": "French",
                "local": "French",
                "native": "français",
                "code": "fr"
            },
            "bg": {
                "english": "Bulgarian",
                "local": "Bulgarian",
                "native": "български",
                "code": "bg"
            },
            "bg-BG": {
                "english": "Bulgarian",
                "local": "Bulgarian",
                "native": "български",
                "code": "bg-BG"
            },
            "bg-GB": {
                "english": "Bulgarian (bg-GB)",
                "local": "Bulgarian (bg-GB)",
                "native": "български (bg-GB)",
                "code": "bg-GB"
            },
            "ta-LK": {
                "english": "Tamil (Sri Lanka)",
                "local": "Tamil (Sri Lanka)",
                "native": "தமிழ் (இலங்கை)",
                "code": "ta-LK"
            },
            "zh-DE": {
                "english": "Chinese (zh-DE)",
                "local": "",
                "native": "",
                "code": "zh-DE"
            },
            "en-xyz": {
                "english": "English (en-xyz)",
                "local": "English (en-xyz)",
                "native": "English (en-xyz)",
                "code": "en-xyz"
            }
        }
    },
    {
        input: ["zz-DE", "zz-AA", "zz", "", 1, "-", "a"],
        expect: {
            // Valid, but unknown
            "zz-DE": {"english": "", "local": "", "native": "", code: "zz-DE"},
            "zz-AA": {"english": "", "local": "", "native": "", code: "zz-AA"},
            "zz": {"english": "", "local": "", "native": "", code: "zz"},
            // Invalid
            "": {"english": null, "local": null, "native": null, code: ""},
            1: {"english": null, "local": null, "native": null, code: "1"},
            "-": {"english": null, "local": null, "native": null, code: "-"},
            "a": {"english": null, "local": null, "native": null, code: "a"}
        }
    }
]);

// If the GPII_IGNORE_LANGTEST environment variable is set, then ignore the test results that would be affected by the
// current language (but still run the code).
gpii.tests.windows.language.ignoreResults = !!process.env.GPII_IGNORE_LANGTEST;
if (gpii.tests.windows.language.ignoreResults) {
    fluid.log("SOFT-FAIL: GPII_IGNORE_LANGTEST is set - ignoring the results.");
}

jqUnit.test("Checking current language", function () {
    jqUnit.expect(gpii.tests.windows.language.ignoreResults ? 0 : 1);

    // Windows language identifier for en-US
    var englishUS = 1033;
    var lcid = gpii.windows.kernel32.GetThreadUILanguage();

    if (!gpii.tests.windows.language.ignoreResults) {
        // The tests expect the current language to be en-US. Fail in an obvious manner before attempting the tests.
        // Those brave enough to run the tests on a non-vagrant box are free to ignore these tests.
        jqUnit.assertEquals("The current language must be English (US) [en-US]. " +
            "Set GPII_IGNORE_LANGTEST to ignore the language failures.", englishUS, lcid);
    }
});

jqUnit.test("Test language code casing", function () {
    var tests = gpii.tests.windows.language.codeCaseTests.tests;
    var fullCodes = gpii.tests.windows.language.codeCaseTests.fullCodes;
    fluid.each(tests, function (inputs, langCode) {
        inputs = fluid.makeArray(inputs);
        inputs.push(langCode);

        fluid.each(inputs, function (input) {
            console.log(langCode, input);
            var result = gpii.windows.language.fixLangCode(input, fullCodes);
            jqUnit.assertEquals("Language case should be correct", langCode, result);
        });
    });

});

jqUnit.test("Test getting current display language", function () {
    jqUnit.expect(gpii.tests.windows.language.ignoreResults ? 1 : 2);

    var origLangCode = gpii.windows.readRegistryKey(
        "HKEY_CURRENT_USER", "Control Panel\\Desktop", "PreferredUILanguages", "REG_SZ").value;

    try {
        // Try it with a language in the registry
        var langCode = "nl-BE";
        gpii.windows.writeRegistryKey(
            "HKEY_CURRENT_USER", "Control Panel\\Desktop", "PreferredUILanguages", langCode, "REG_SZ");

        var result1 = gpii.windows.language.getDisplayLanguage();
        jqUnit.assertEquals("getDisplayLanguage must return what the registry was set to", langCode, result1);

        // Try without a language in the registry - it should be the thread's language.
        gpii.windows.writeRegistryKey(
            "HKEY_CURRENT_USER", "Control Panel\\Desktop", "PreferredUILanguages", undefined, "REG_SZ");

        var result2 = gpii.windows.language.getDisplayLanguage();
        if (!gpii.tests.windows.language.ignoreResults) {
            jqUnit.assertEquals("getDisplayLanguage must return what the registry was set to", result2, "en-US");
        }

    } finally {
        gpii.windows.writeRegistryKey(
            "HKEY_CURRENT_USER", "Control Panel\\Desktop", "PreferredUILanguages", origLangCode, "REG_SZ");
    }

});

jqUnit.asyncTest("Test getting language names", function () {
    var tests = gpii.tests.windows.language.nameTests;

    jqUnit.expect(Object.keys(tests).length * (gpii.tests.windows.language.ignoreResults ? 1 : 2));
    var language = gpii.windows.language({
        listeners: {
            "onCreate.update": fluid.identity
        }
    });

    var doTest = function (testIndex) {
        var test = tests[testIndex];
        if (test) {
            var p = language.getLanguageNames(test.input);
            jqUnit.assertTrue("getLanguageNames must return a promise", fluid.isPromise(p));

            p.then(function (result) {
                if (!gpii.tests.windows.language.ignoreResults) {
                    jqUnit.assertDeepEq("Language names for '" + test.input + "' should match the expected",
                        test.expect, result);
                }
                doTest(testIndex + 1);
            }, fluid.fail);
        } else {
            language.destroy();
            jqUnit.start();
        }
    };

    doTest(0);

});

jqUnit.asyncTest("Test getting installed languages", function () {
    jqUnit.expect(gpii.tests.windows.language.ignoreResults ? 6 : 7);

    var currentLanguage = gpii.windows.language.getDisplayLanguage();
    fluid.log("currentLanguage:" + currentLanguage);
    jqUnit.assertNotNull("getDisplayLanguage should return something", currentLanguage);


    // The expected value for the en-US field of the installed languages.
    var expect = {
        english: "English (United States)",
        local: "English (United States)",
        native: "English (United States)",
        code: "en-US",
        current: currentLanguage === "en-US"
    };

    var language = gpii.windows.language();

    // Check the model update
    language.applier.change("installedLanguages", {}, "DELETE");
    language.applier.modelChanged.addListener("installedLanguages", function (newValue) {
        if (gpii.tests.windows.language.ignoreResults) {
            jqUnit.assert("installedLanguages changed");
        } else {
            jqUnit.assertDeepEq("Model ", expect, newValue["en-US"]);
        }
    });

    var p = language.getInstalledLanguages();

    jqUnit.assertTrue("getInstalledLanguages should return a promise", fluid.isPromise(p));

    p.then(function (result) {
        jqUnit.assertTrue("getInstalledLanguages should return an object", fluid.isPlainObject(result, true));
        jqUnit.assertTrue("getInstalledLanguages result should have fields", Object.keys(result).length > 0);

        if (!gpii.tests.windows.language.ignoreResults) {
            var enUS = result["en-US"];
            jqUnit.assertDeepEq("getInstalledLanguages should return en-US", expect, enUS);
        }

        // Calling the second time, the list should be the same and will therefore resolve with null
        language.getInstalledLanguages().then(function (result2) {
            jqUnit.assertNull("Second call to getInstalledLanguages should resolve with null", result2);

            language.destroy();
            jqUnit.start();
        }, fluid.fail);
    }, fluid.fail);
});