gecko/addon-sdk/source/test/test-xpcom.js

224 lines
7.1 KiB
JavaScript

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
const xpcom = require("sdk/platform/xpcom");
const { Cc, Ci, Cm, Cr } = require("chrome");
const { isCIDRegistered } = Cm.QueryInterface(Ci.nsIComponentRegistrar);
const { Class } = require("sdk/core/heritage");
const { Loader } = require("sdk/test/loader");
exports['test Unknown implements nsISupports'] = function(assert) {
let actual = xpcom.Unknown();
assert.equal(actual.QueryInterface(Ci.nsISupports),
actual,
'component implements nsISupports');
};
exports['test implement xpcom interfaces'] = function(assert) {
let WeakReference = Class({
extends: xpcom.Unknown,
interfaces: [ 'nsIWeakReference' ],
QueryReferent: function() {}
});
let weakReference = WeakReference()
assert.equal(weakReference.QueryInterface(Ci.nsISupports),
weakReference,
'component implements nsISupports');
assert.equal(weakReference.QueryInterface(Ci.nsIWeakReference),
weakReference,
'component implements specified interface');
assert.throws(function() {
component.QueryInterface(Ci.nsIObserver);
}, "component does not implements interface");
let Observer = Class({
extends: WeakReference,
interfaces: [ 'nsIObserver', 'nsIRequestObserver' ],
observe: function() {},
onStartRequest: function() {},
onStopRequest: function() {}
});
let observer = Observer()
assert.equal(observer.QueryInterface(Ci.nsISupports),
observer,
'derived component implements nsISupports');
assert.equal(observer.QueryInterface(Ci.nsIWeakReference),
observer,
'derived component implements supers interface');
assert.equal(observer.QueryInterface(Ci.nsIObserver),
observer.QueryInterface(Ci.nsIRequestObserver),
'derived component implements specified interfaces');
};
exports['test implement factory without contract'] = function(assert) {
let actual = xpcom.Factory({
get wrappedJSObject() this,
});
assert.ok(isCIDRegistered(actual.id), 'factory is regiseterd');
xpcom.unregister(actual);
assert.ok(!isCIDRegistered(actual.id), 'factory is unregistered');
};
exports['test implement xpcom factory'] = function(assert) {
let Component = Class({
extends: xpcom.Unknown,
interfaces: [ 'nsIObserver' ],
get wrappedJSObject() this,
observe: function() {}
});
let factory = xpcom.Factory({
register: false,
contract: '@jetpack/test/factory;1',
Component: Component
});
assert.ok(!isCIDRegistered(factory.id), 'factory is not registered');
xpcom.register(factory);
assert.ok(isCIDRegistered(factory.id), 'factory is registered');
let actual = Cc[factory.contract].createInstance(Ci.nsIObserver);
assert.ok(actual.wrappedJSObject instanceof Component,
"createInstance returnes wrapped factory instances");
assert.notEqual(Cc[factory.contract].createInstance(Ci.nsIObserver),
Cc[factory.contract].createInstance(Ci.nsIObserver),
"createInstance returns new instance each time");
};
exports['test implement xpcom service'] = function(assert) {
let actual = xpcom.Service({
contract: '@jetpack/test/service;1',
register: false,
Component: Class({
extends: xpcom.Unknown,
interfaces: [ 'nsIObserver'],
get wrappedJSObject() this,
observe: function() {},
name: 'my-service'
})
});
assert.ok(!isCIDRegistered(actual.id), 'component is not registered');
xpcom.register(actual);
assert.ok(isCIDRegistered(actual.id), 'service is regiseterd');
assert.ok(Cc[actual.contract].getService(Ci.nsIObserver).observe,
'service can be accessed via get service');
assert.equal(Cc[actual.contract].getService(Ci.nsIObserver).wrappedJSObject,
actual.component,
'wrappedJSObject is an actual component');
xpcom.unregister(actual);
assert.ok(!isCIDRegistered(actual.id), 'service is unregistered');
};
function testRegister(assert, text) {
const service = xpcom.Service({
description: 'test about:boop page',
contract: '@mozilla.org/network/protocol/about;1?what=boop',
register: false,
Component: Class({
extends: xpcom.Unknown,
get wrappedJSObject() this,
interfaces: [ 'nsIAboutModule' ],
newChannel : function(aURI) {
var ios = Cc["@mozilla.org/network/io-service;1"].
getService(Ci.nsIIOService);
var channel = ios.newChannel(
"data:text/plain;charset=utf-8," + text,
null,
null
);
channel.originalURI = aURI;
return channel;
},
getURIFlags: function(aURI) {
return Ci.nsIAboutModule.ALLOW_SCRIPT;
}
})
});
xpcom.register(service);
assert.equal(isCIDRegistered(service.id), true);
var aboutFactory = xpcom.factoryByContract(service.contract);
var about = aboutFactory.createInstance(Ci.nsIAboutModule);
var ios = Cc["@mozilla.org/network/io-service;1"].
getService(Ci.nsIIOService);
assert.equal(
about.getURIFlags(ios.newURI("http://foo.com", null, null)),
Ci.nsIAboutModule.ALLOW_SCRIPT
);
var aboutURI = ios.newURI("about:boop", null, null);
var channel = ios.newChannelFromURI(aboutURI);
var iStream = channel.open();
var siStream = Cc['@mozilla.org/scriptableinputstream;1']
.createInstance(Ci.nsIScriptableInputStream);
siStream.init(iStream);
var data = new String();
data += siStream.read(-1);
siStream.close();
iStream.close();
assert.equal(data, text);
xpcom.unregister(service);
assert.equal(isCIDRegistered(service.id), false);
}
exports["test register"] = function(assert) {
testRegister(assert, "hai2u");
};
exports["test re-register"] = function(assert) {
testRegister(assert, "hai2u again");
};
exports["test unload"] = function(assert) {
let loader = Loader(module);
let sbxpcom = loader.require("sdk/platform/xpcom");
let auto = sbxpcom.Factory({
contract: "@mozilla.org/test/auto-unload;1",
description: "test auto",
name: "auto"
});
let manual = sbxpcom.Factory({
contract: "@mozilla.org/test/manual-unload;1",
description: "test manual",
register: false,
unregister: false,
name: "manual"
});
assert.equal(isCIDRegistered(auto.id), true, 'component registered');
assert.equal(isCIDRegistered(manual.id), false, 'component not registered');
sbxpcom.register(manual)
assert.equal(isCIDRegistered(manual.id), true,
'component was automatically registered on first instance');
loader.unload();
assert.equal(isCIDRegistered(auto.id), false,
'component was atumatically unregistered on unload');
assert.equal(isCIDRegistered(manual.id), true,
'component was not automatically unregistered on unload');
sbxpcom.unregister(manual);
assert.equal(isCIDRegistered(manual.id), false,
'component was manually unregistered on unload');
};
require("test").run(exports);