module-namespace.js

//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------

// ES6 Module syntax tests -- verifies syntax of import and export statements

WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js");

function testModuleScript(source, message, shouldFail = false) {
    let testfunc = () => testRunner.LoadModule(source, undefined, shouldFail);

    if (shouldFail) {
        let caught = false;

        // We can't use assert.throws here because the SyntaxError used to construct the thrown error
        // is from a different context so it won't be strictly equal to our SyntaxError.
        try {
            testfunc();
        } catch(e) {
            caught = true;

            // Compare toString output of SyntaxError and other context SyntaxError constructor.
            assert.areEqual(e.constructor.toString(), SyntaxError.toString(), message);
        }

        assert.isTrue(caught, `Expected error not thrown: ${message}`);
    } else {
        assert.doesNotThrow(testfunc, message);
    }
}

var tests = [
    {
        name: "Issue3249: Namespace object's property attributes",
        body: function () {
            testModuleScript(`
            function verifyPropertyDesc(obj, prop, desc, propName) {
                var actualDesc = Object.getOwnPropertyDescriptor(obj, prop);
                if (typeof propName === "undefined") { propName = prop; }
                assert.areEqual(desc.configurable, actualDesc.configurable, propName+"'s attribute: configurable");
                assert.areEqual(desc.enumerable, actualDesc.enumerable, propName+"'s attribute: enumerable");
                assert.areEqual(desc.writable, actualDesc.writable, propName+"'s attribute: writable");
            }

            import * as foo from "ValidExportStatements.js";
            assert.areEqual("Module", foo[Symbol.toStringTag], "@@toStringTag is the String value'Module'");
            verifyPropertyDesc(foo, Symbol.toStringTag, {configurable:false, enumerable: false, writable: false}, "Symbol.toStringTag");
            verifyPropertyDesc(foo, "default", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "var7", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "var6", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "var4", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "var3", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "var2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "var1", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "foo4", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "bar2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "foobar", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "foo3", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "baz2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "foo2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "baz", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "bar", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "foo", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "const6", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "const5", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "const4", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "const3", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "const2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "let7", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "let6", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "let5", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "let4", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "let2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "let1", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "cl2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "cl1", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "gn2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "gn1", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "fn2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo, "fn1", {configurable:false, enumerable: true, writable: true});

            import * as foo1 from "ValidReExportStatements.js";
            verifyPropertyDesc(foo1, "foo", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo1, "bar", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo1, "baz", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo1, "foo2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo1, "bar2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo1, "foo3", {configurable:false, enumerable: true, writable: true});

            import * as foo2 from "ModuleComplexReexports.js";
            verifyPropertyDesc(foo2, "ModuleComplexReexports_foo", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo2, "bar2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo2, "localfoo2", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo2, "bar", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo2, "localfoo", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo2, "baz", {configurable:false, enumerable: true, writable: true});
            verifyPropertyDesc(foo2, "foo", {configurable:false, enumerable: true, writable: true});
            `, '', false);
        }
    },
    {
        name: "Basic import namespace",
        body: function () {
            testModuleScript(`
            import * as foo from "ValidExportStatements.js";
            assert.areEqual("default", foo.default, "default");
            assert.areEqual(undefined, foo.var7, "var7");
            assert.areEqual(undefined, foo.var6, "var6");
            assert.areEqual(undefined, foo.var5, "var5");
            assert.areEqual(undefined, foo.var4, "var4");
            assert.areEqual(5, foo.var3, "var3");
            assert.areEqual(undefined, foo.var2, "var2");
            assert.areEqual("string", foo.var1, "var1");
            assert.areEqual("function foo() { }", foo.foo4.toString(), "foo4");
            assert.areEqual("class bar { }", foo.bar2.toString(), "bar2");
            assert.areEqual("function foobar() { }", foo.foobar.toString(), "foobar");
            assert.areEqual("function foo() { }", foo.foo3.toString(), "foo3");
            assert.areEqual("function* baz() { }", foo.baz2.toString(), "baz2");
            assert.areEqual("function foo() { }", foo.foo2.toString(), "foo2");
            assert.areEqual("function* baz() { }", foo.baz.toString(), "baz");
            assert.areEqual("class bar { }", foo.bar.toString(), "bar");
            assert.areEqual("function foo() { }", foo.foo.toString(), "foo");
            assert.areEqual([], foo.const6, "const6");
            assert.areEqual({}, foo.const5, "const5");
            assert.areEqual(4, foo.const4, "const4");
            assert.areEqual(3, foo.const3, "const3");
            assert.areEqual("str", foo.const2, "const2");
            assert.areEqual([], foo.let7, "let7");
            assert.areEqual({}, foo.let6, "let6");
            assert.areEqual(undefined, foo.let5, "let5");
            assert.areEqual(undefined, foo.let4, "let4");
            assert.areEqual(undefined, foo.let3, "let3");
            assert.areEqual(2, foo.let2, "let2");
            assert.areEqual(undefined, foo.let1, "let1");
            assert.areEqual("class cl2 { }", foo.cl2.toString(), "cl2");
            assert.areEqual("class cl1 { }", foo.cl1.toString(), "cl1");
            assert.areEqual("function* gn2 () { }", foo.gn2.toString(), "gn2");
            assert.areEqual("function* gn1 () { }", foo.gn1.toString(), "gn1");
            assert.areEqual("function fn2 () { }", foo.fn2.toString(), "fn2");
            assert.areEqual("function fn1 () { }", foo.fn1.toString(), "fn1");
            `, '', false);
        }
    },
    {
        name: "import namespace with verification",
        body: function () {
            testModuleScript(`
            import * as foo from "moduleExport1.js";
            assert.areEqual("default", foo.default, "default");
            assert.areEqual(undefined, foo.var7, "var7");
            assert.areEqual(undefined, foo.var6, "var6");
            assert.areEqual(undefined, foo.var5, "var5");
            assert.areEqual(undefined, foo.var4, "var4");
            assert.areEqual(5, foo.var3, "var3");
            assert.areEqual(undefined, foo.var2, "var2");
            assert.areEqual("string", foo.var1, "var1");
            assert.areEqual("function foo() { }", foo.foo4.toString(), "foo4");
            assert.areEqual("class bar { }", foo.bar2.toString(), "bar2");
            assert.areEqual("function foobar() { }", foo.foobar.toString(), "foobar");
            assert.areEqual("function foo() { }", foo.foo3.toString(), "foo3");
            assert.areEqual("function* baz() { }", foo.baz2.toString(), "baz2");
            assert.areEqual("function foo() { }", foo.foo2.toString(), "foo2");
            assert.areEqual("function* baz() { }", foo.baz.toString(), "baz");
            assert.areEqual("class bar { }", foo.bar.toString(), "bar");
            assert.areEqual("function foo() { }", foo.foo.toString(), "foo");
            assert.areEqual([], foo.const6, "const6");
            assert.areEqual({}, foo.const5, "const5");
            assert.areEqual(4, foo.const4, "const4");
            assert.areEqual(3, foo.const3, "const3");
            assert.areEqual("str", foo.const2, "const2");
            assert.areEqual([], foo.let7, "let7");
            assert.areEqual({}, foo.let6, "let6");
            assert.areEqual(undefined, foo.let5, "let5");
            assert.areEqual(undefined, foo.let4, "let4");
            assert.areEqual(undefined, foo.let3, "let3");
            assert.areEqual(2, foo.let2, "let2");
            assert.areEqual(undefined, foo.let1, "let1");
            assert.areEqual("class cl2 { }", foo.cl2.toString(), "cl2");
            assert.areEqual("class cl1 { }", foo.cl1.toString(), "cl1");
            assert.areEqual("function* gn2 () { }", foo.gn2.toString(), "gn2");
            assert.areEqual("function* gn1 () { }", foo.gn1.toString(), "gn1");
            assert.areEqual("function fn2 () { }", foo.fn2.toString(), "fn2");
            assert.areEqual("function fn1 () { }", foo.fn1.toString(), "fn1");
            foo.verifyNamespace(foo);
            foo.changeContext();
            foo.verifyNamespace(foo);
            `, '', false);
        }
    },
    {
        name: "reexport only",
        body: function () {
            testModuleScript(`
            import * as foo from "ValidReExportStatements.js";
            assert.areEqual("function foo() { }", foo.foo.toString(), "foo");
            assert.areEqual("class bar { }", foo.bar.toString(), "bar");
            assert.areEqual("function* baz() { }", foo.baz.toString(), "baz");
            assert.areEqual("function foo() { }", foo.foo2.toString(), "foo2");
            assert.areEqual("class bar { }", foo.bar2.toString(), "bar2");
            assert.areEqual("function foo() { }", foo.foo3.toString(), "foo3");
            `, '', false);
        }
    },
    {
        name: "complex reexport",
        body: function () {
            testModuleScript(`import * as fooComplex from "ModuleComplexReexports.js";
            assert.areEqual("function bar() { return 'bar'; }", fooComplex.ModuleComplexReexports_foo.toString(), "ModuleComplexReexports_foo");
            assert.areEqual(undefined, fooComplex.switch, "switch");
            assert.areEqual("function foo() { return 'foo'; }", fooComplex.bar2.toString(), "bar2");
            assert.areEqual("function foo() { return 'foo'; }", fooComplex.localfoo2.toString(), "localfoo2");
            assert.areEqual("function foo() { return 'foo'; }", fooComplex.bar.toString(), "bar");
            assert.areEqual("function foo() { return 'foo'; }", fooComplex.localfoo.toString(), "localfoo");
            assert.areEqual("function foo() { return 'foo'; }", fooComplex.baz.toString(), "baz");
            assert.areEqual("function foo() { return 'foo'; }", fooComplex.foo.toString(), "foo");
            `, '', false);
        }
    },
    {
        name: "namespace as prototype",
        body: function () {
            testModuleScript(`import * as foo from "ValidExportStatements.js";
            var childObj = Object.create(foo);
            assert.areEqual("default", childObj.default, "default");
            assert.areEqual(undefined, childObj.var7, "var7");
            assert.areEqual(undefined, childObj.var6, "var6");
            assert.areEqual(undefined, childObj.var5, "var5");
            assert.areEqual(undefined, childObj.var4, "var4");
            assert.areEqual(5, childObj.var3, "var3");
            assert.areEqual(undefined, childObj.var2, "var2");
            assert.areEqual("string", childObj.var1, "var1");
            assert.areEqual("function foo() { }", childObj.foo4.toString(), "foo4");
            assert.areEqual("class bar { }", childObj.bar2.toString(), "bar2");
            assert.areEqual("function foobar() { }", childObj.foobar.toString(), "foobar");
            assert.areEqual("function foo() { }", childObj.foo3.toString(), "foo3");
            assert.areEqual("function* baz() { }", childObj.baz2.toString(), "baz2");
            assert.areEqual("function foo() { }", childObj.foo2.toString(), "foo2");
            assert.areEqual("function* baz() { }", childObj.baz.toString(), "baz");
            assert.areEqual("class bar { }", childObj.bar.toString(), "bar");
            assert.areEqual("function foo() { }", childObj.foo.toString(), "foo");
            assert.areEqual([], childObj.const6, "const6");
            assert.areEqual({}, childObj.const5, "const5");
            assert.areEqual(4, childObj.const4, "const4");
            assert.areEqual(3, childObj.const3, "const3");
            assert.areEqual("str", childObj.const2, "const2");
            assert.areEqual([], childObj.let7, "let7");
            assert.areEqual({}, childObj.let6, "let6");
            assert.areEqual(undefined, childObj.let5, "let5");
            assert.areEqual(undefined, childObj.let4, "let4");
            assert.areEqual(undefined, childObj.let3, "let3");
            assert.areEqual(2, childObj.let2, "let2");
            assert.areEqual(undefined, childObj.let1, "let1");
            assert.areEqual("class cl2 { }", childObj.cl2.toString(), "cl2");
            assert.areEqual("class cl1 { }", childObj.cl1.toString(), "cl1");
            assert.areEqual("function* gn2 () { }", childObj.gn2.toString(), "gn2");
            assert.areEqual("function* gn1 () { }", childObj.gn1.toString(), "gn1");
            assert.areEqual("function fn2 () { }", childObj.fn2.toString(), "fn2");
            assert.areEqual("function fn1 () { }", childObj.fn1.toString(), "fn1");
            `, '', false);
       }
    },
    {
        name: "namespace internal operations",
        body: function () {
            let functionBody =
                `import * as foo from "ValidExportStatements.js";
                assert.areEqual(null, Object.getPrototypeOf(foo), 'namespace prototype is null');
                assert.areEqual(false, Object.isExtensible(foo), 'namespace is not extensible');
                assert.areEqual(false, Reflect.set(foo, "non_existing", 20), '[[set]] returns false ');
                assert.areEqual(undefined, foo.non_existing, 'namespace object is immutable');
                assert.areEqual(false, Reflect.set(foo, "4", 20), 'cannot set item in namespace obect');
                assert.areEqual(undefined, foo[4], 'cannot export item in namespace obect');
                assert.areEqual(false, Reflect.deleteProperty(foo, "var1"), 'cannot delete export in namespace obect');
                assert.areEqual(true, Reflect.deleteProperty(foo, "nonevar"), 'cannot delete export in namespace obect');
                assert.areEqual(undefined, foo[6], 'cannot get item in namespace obect');
                assert.areEqual(false, Reflect.set(foo, Symbol.species, 20), 'no species property');
                assert.areEqual(undefined, foo[Symbol.species], 'namespace is not contructor');
                assert.areEqual("Module", foo[Symbol.toStringTag], 'namespace toStringTag');
                assert.areEqual("[object Module]", Object.prototype.toString.call(foo), 'Object.prototype.toString uses the module namespace @@toStringTag value');
                var symbols = Object.getOwnPropertySymbols(foo);
                assert.areEqual(1, symbols.length, "one symbol");
                assert.areEqual(symbols[0], Symbol.toStringTag, "first symbol is toStringTag");
                assert.isFalse(Object.prototype.hasOwnProperty.call(foo, Symbol.iterator), "Module namespace object should not have Symbol.iterator property");
                assert.throws( function() {Object.setPrototypeOf(foo, Object)}, TypeError, 'Cannot create property for a non-extensible object');
                assert.areEqual(true, Reflect.preventExtensions(foo), '[[PreventExtensions]] for namespace object returns true');`;
            testModuleScript(functionBody, "Test importing as different binding identifiers", false);
       }
    },
    {
        name: "Issue3246: namespace property names are sorted",
        body: function () {
            let functionBody =
                `
                import * as ns from 'ValidExportStatements2.js';
                var p = new Proxy(ns, {});
                var names = ["sym0","default","$","$$","_","\u03bb","aa","A","a","zz","z","\u03bc","Z","za","__","az","\u03c0"].sort();

                var verifyNamespaceOwnProperty = function(obj, objKind) {
                    assert.areEqual(names, Object.getOwnPropertyNames(obj), objKind+" getOwnPropertyNames()");

                    var propDesc = Object.getOwnPropertyDescriptors(obj);
                    assert.areEqual('{"value":"Module","writable":false,"enumerable":false,"configurable":false}', JSON.stringify(propDesc[Symbol.toStringTag]),
                        objKind+" getOwnPropertyDescriptors() @@toStringTag");
                    assert.areEqual(names, Object.keys(propDesc), "ModuleNamespace", objKind+" getOwnPropertyDescriptors()");
                };

                verifyNamespaceOwnProperty(ns, "ModuleNamespace");
                verifyNamespaceOwnProperty(p, "Proxy");

                var propEn = [];
                for (var k in ns) { propEn.push(k); }
                assert.areEqual(names, propEn, "ModuleNamespace enumerator");
                `;
            testModuleScript(functionBody, "Test importing as different binding identifiers", false);
       }
    },
];

testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" });