gecko/js/xpconnect/tests/chrome/test_cows.xul

<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
<?xml-stylesheet href="chrome://mochikit/content/tests/SimpleTest/test.css"
                 type="text/css"?>
<!--
https://bugzilla.mozilla.org/show_bug.cgi?id=500931
-->
<window title="Mozilla Bug 522764"
  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
  <script type="application/javascript"
          src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>

  <!-- test results are displayed in the html:body -->
  <body xmlns="http://www.w3.org/1999/xhtml">
  <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=522764 "
     target="_blank">Mozilla Bug 522764 </a>
  </body>

  <!-- test code goes here -->
  <script type="application/javascript"><![CDATA[
const Ci = Components.interfaces;
const Cu = Components.utils;

var sandbox = new Cu.Sandbox("about:blank");

var test_utils = window.QueryInterface(Ci.nsIInterfaceRequestor).
                 getInterface(Ci.nsIDOMWindowUtils);

function getCOW(x) {
  var rval = {};
  if (typeof x == "function")
    rval = eval(uneval(x));
  for (var i in x) {
    if (x.__lookupGetter__(i))
      rval.__defineGetter__(i, eval(uneval(x.__lookupGetter__(i))))
    else
      rval[i] = x[i];
  }
  return rval;
}

// Give the sandbox a way to create ChromeObjectWrapped objects.
sandbox.getCOW = getCOW;

// Define test API functions in the sandbox.
const TEST_API = ['is', 'isnot', 'ok', 'todo_is', 'todo_isnot', 'todo'];
TEST_API.forEach(function(name) { sandbox[name] = window[name]; });

sandbox.alienObject = {
  __exposedProps__: {funProp: 'r'},
  funProp: function foo(x) {
    return x + 1;
  }
};

sandbox.chromeGet = function (obj, prop) { return obj[prop]; };

function COWTests() {
    // This function is actually decompiled and run inside a
    // sandbox with content privileges.

    // TODO: This could use some refactoring; creating helper
    // functions like assertIsWritable(myObj, 'someproperty') might
    // be useful.

    function isProp(obj, propName, value, desc) {
      try {
          is(obj[propName], value, "getting " + propName + " on " + desc);
          ok(propName in obj,
             propName + " on " + desc + " should exist");
          //ok(Object.hasOwnProperty.call(obj, propName),
          //   propName + " on " + desc + " should exist");
      } catch (e) {
          ok(false, "getting " + propName + " on " + desc + " threw " + e);
      }
    }
    function isPropHidden(obj, propName, desc) {
      try {
          is(obj[propName], undefined,
             "getting " + propName + " on " + desc + " should return undefined");
          ok(!(propName in obj),
             propName + " on " + desc + " should act as if it doesn't exist");
          //ok(!Object.hasOwnProperty.call(obj, propName),
          //   propName + " on " + desc + " should act as if it doesn't exist");
      } catch (e) {
          ok(false, "getting " + propName + " on " + desc + " threw " + e);
      }
    }

    //var cow = getCOW({ foo: "fooval", __exposedProps__: {}});
    //Math.sin(1);
    //is(cow.foo, undefined, "one test to rule them all");
    //return;

    const PROPS_TO_TEST = ['foo', 'bar', '__proto__', 'prototype', 'constructor'];

    var empty = {};
    // Once we flip the default for __exposedProps__, this should behave
    // the same as for function objects below.
    is(getCOW(empty).foo, undefined,
       "shouldn't throw when accessing exposed properties that doesn't exist");

    // Test function objects without __exposedProps__
    var func = function(x) { return 42; };
    func.foo = "foo property";
    var funcCOW = getCOW(func);
    PROPS_TO_TEST.forEach(function(name) {
        isPropHidden(funcCOW, name, "function without exposedProps");
    });
    is([name for (name in funcCOW)].length, 0,
       "function without exposedProps shouldn't have any properties");
    is(funcCOW(), 42, "COW without exposedProps should still be callable");

    // Test function objects with __exposedProps__
    var func = function(x) { return 42; };
    func.foo = "foo property";
    func.__exposedProps__ = { foo: "r" };
    var funcCOWr = getCOW(func);
    PROPS_TO_TEST.forEach(function(name) {
        if (name == "foo") {
            isProp(funcCOWr, name, "foo property",
                   "function with exposedProps");
        }
        else {
            isPropHidden(funcCOWr, name, "function with exposedProps");
        }
    });
    is([name for (name in funcCOWr)].length, 1,
       "function with exposedProps should only enumerate exposed props");
    is([name for (name in funcCOWr)][0], "foo",
       "function with exposedProps should only enumerate exposed props");
    is(funcCOWr(), 42, "COW with exposedProps should be callable");

    // Test function objects with __exposedProps__
    var func = function(x) { return 42; };
    func.foo = "foo property";
    func.__exposedProps__ = { foo: "r", bar: "r" };
    var funcCOWr2 = getCOW(func);
    PROPS_TO_TEST.forEach(function(name) {
        if (name == "foo") {
            isProp(funcCOWr2, name, "foo property",
                   "function with more exposedProps");
        }
        else {
            isPropHidden(funcCOWr2, name, "function with more exposedProps");
        }
    });
    is([name for (name in funcCOWr2)].length, 1,
       "function with exposedProps should only enumerate exposed props");
    is([name for (name in funcCOWr2)][0], "foo",
       "function with exposedProps should only enumerate exposed props");

    // Test object with empty exposedProps
    var strict = { __exposedProps__: {}, foo: "foo property" };
    var strictCOW = getCOW(strict);
    PROPS_TO_TEST.forEach(function(name) {
        isPropHidden(strictCOW, name, "object with empty exposedProps");
    });
    is([name for (name in strictCOW)].length, 0,
       "object with empty exposedProps shouldn't have any properties");

    // Test object with one exposed property
    var strict = { __exposedProps__: { foo: "r" }, foo: "foo property" };
    var strictCOWr = getCOW(strict);
    PROPS_TO_TEST.forEach(function(name) {
        if (name == "foo") {
            isProp(strictCOWr, name, "foo property",
                   "object with exposed 'foo'");
        }
        else {
            isPropHidden(strictCOW, name, "object with exposed 'foo'");
        }
    });
    is([name for (name in strictCOWr)].length, 1,
       "object with exposedProps only enumerate exposed props");
    is([name for (name in strictCOWr)][0], "foo",
       "object with exposedProps only enumerate exposed props");

    // Test writable property
    var writable = getCOW({ __exposedProps__: {foo: 'w'}});
    try {
        Math.sin("foo" in writable);
        ok(!("foo" in writable),
           "non-existing write-only property shouldn't exist");
        writable.foo = 5;
        is(chromeGet(writable, "foo"), 5, "writing to a write-only exposed prop works");
        todo("foo" in writable,
             "existing write-only property should exist");
    } catch (e) {
        ok(false, "writing to a write-only exposed prop shouldn't throw " + e);
    }
    try {
        writable.foo;
        todo(false, "reading from a write-only exposed prop should throw");
    } catch (e) {
        todo(/Permission denied/.test(e),
             "reading from a write-only exposed prop should throw");
    }
    try {
        delete writable.foo;
        is(chromeGet(writable, "foo"), undefined,
           "deleting a write-only exposed prop works");
    } catch (e) {
        ok(false, "deleting a write-only exposed prop shouldn't throw " + e);
    }

    // Test readable property
    var readable = { __exposedProps__: {foo: 'r'},
                     foo: 5,
                     bar: 6 };
    try {
        isProp(getCOW(readable), "foo", 5,
               "reading from a readable exposed prop works");
    } catch (e) {
        ok(false, "reading from a readable exposed prop shouldn't throw " + e);
    }
    try {
        getCOW(readable).foo = 1;
        ok(false, "writing to a read-only exposed prop should fail");
    } catch (e) {
        ok(/Permission denied/.test(e),
           "writing to a read-only exposed prop should fail");
    }
    try {
        delete getCOW(readable).foo;
        ok(false, "deleting a read-only exposed prop shouldn't work");
    } catch (e) {
        ok(/Permission denied/.test(e),
           "deleting a read-only exposed prop should throw error");
    }

    try {
        var props = [name for (name in getCOW(readable))];
        is(props.length, 1, "COW w/ one exposed prop should enumerate once");
        is(props[0], 'foo', "COW w/ one exposed prop should enumerate it");
        props = [value for each (value in getCOW(readable))];
        is(props[0], 5, "for-each over COWs works");
    } catch (e) {
        ok(false, "COW w/ a readable prop should not raise exc " +
                  "on enumeration: " + e);
    }

    // Test read/write property
    var readwrite = getCOW({ __exposedProps__: {foo: 'rw'}});
    try {
        ok(!("foo" in readwrite),
           "non-existing readwrite property shouldn't exist");
        readwrite.foo = 5;
        is(readwrite.foo, 5, "writing to a readwrite exposed prop looks like it worked");
        is(chromeGet(readwrite, "foo"), 5, "writing to a readwrite exposed prop works");
        ok("foo" in readwrite,
           "existing readwrite property should exist");
    } catch (e) {
        ok(false, "writing to a readwrite exposed prop shouldn't throw " + e);
    }
    try {
        delete readwrite.foo;
        is(readwrite.foo, undefined, "deleting readwrite prop looks like it worked");
        ok(!("foo" in readwrite), "deleting readwrite prop looks like it really worked");
        is(chromeGet(readwrite, "foo"), undefined,
           "deleting a readwrite exposed prop works");
    } catch (e) {
        ok(false, "deleting a readwrite exposed prop shouldn't throw " + e);
    }

    // Readables and functions
    try {
        var COWFunc = getCOW((function() { return 5; }));
        is(COWFunc(), 5, "COWed functions should be callable");
    } catch (e) {
        todo(false, "COWed functions should not raise " + e);
    }
    try {
        var objWithFunc = {__exposedProps__: {foo: 'r'},
                           foo: function foo() { return 5; }};
        is(getCOW((objWithFunc)).foo(), 5,
           "Readable function exposed props should be callable");
    } catch (e) {
        ok(false, "Readable function exposed props should be callable" + e);
    }

    // Readables with getters
    var obj = {
       get prop() { return { __exposedProps__: {}, test: "FAIL" } }
    };
    is(getCOW(obj).prop.test, undefined, "getting prop.test shouldn't return anything");
    ok(!("test" in getCOW(obj).prop), "getting prop.test shouldn't return anything");

    // Alien objects
    try {
        is(alienObject.funProp(1), 2,
           "COWs wrapping objects from different principals should work");
    } catch (e) {
        ok(false, "COWs wrapping objs from different principals " +
                  "shouldn't throw " + e);
    }

    try {
        is(alienObject.funProp(1), 2,
           "COWs wrapping objs from different principals should work twice");
    } catch (e) {
        ok(false, "COWs wrapping objs from different principals " +
                  "shouldn't throw on second access but not first: " + e);
    }
}

// Decompile the COW test suite, re-evaluate it in the sandbox and execute it.
Cu.evalInSandbox('(' + uneval(COWTests) + ')()', sandbox);

// Test that COWed objects passing from content to chrome get unwrapped.
function returnCOW() {
    return getCOW({__exposedProps__: {},
                  bar: 6});
}

var unwrapped = Cu.evalInSandbox(
    '(' + uneval(returnCOW) + ')()',
    sandbox
);

try {
    is(unwrapped.bar, 6,
       "COWs should be unwrapped when entering chrome space");
} catch (e) {
    todo(false, "COWs should be unwrapped when entering chrome space, " +
                "not raise " + e);
}
  ]]></script>
</window>