The Tor Browser: comparison toolkit/components/url-classifier/tests/unit/head_urlclassifier.js

comparison: toolkit/components/url-classifier/tests/unit/head_urlclassifier.js

toolkit/components/url-classifier/tests/unit/head_urlclassifier.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:6bae522d78ae
+//* -*- Mode: Javascript; tab-width: 8; indent-tabs-mode: nil; js-indent-level: 2 -*- *
+function dumpn(s) {
+dump(s + "\n");
+}
+const NS_APP_USER_PROFILE_50_DIR = "ProfD";
+const NS_APP_USER_PROFILE_LOCAL_50_DIR = "ProfLD";
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+const Cr = Components.results;
+Cu.import("resource://testing-common/httpd.js");
+do_get_profile();
+var dirSvc = Cc["@mozilla.org/file/directory_service;1"].getService(Ci.nsIProperties);
+var iosvc = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
+var secMan = Cc["@mozilla.org/scriptsecuritymanager;1"]
+.getService(Ci.nsIScriptSecurityManager);
+// Disable hashcompleter noise for tests
+var prefBranch = Cc["@mozilla.org/preferences-service;1"].
+getService(Ci.nsIPrefBranch);
+prefBranch.setIntPref("urlclassifier.gethashnoise", 0);
+// Enable malware/phishing checking for tests
+prefBranch.setBoolPref("browser.safebrowsing.malware.enabled", true);
+prefBranch.setBoolPref("browser.safebrowsing.enabled", true);
+// Enable all completions for tests
+prefBranch.setCharPref("urlclassifier.disallow_completions", "");
+function delFile(name) {
+try {
+// Delete a previously created sqlite file
+var file = dirSvc.get('ProfLD', Ci.nsIFile);
+file.append(name);
+if (file.exists())
+file.remove(false);
+} catch(e) {
+}
+}
+function cleanUp() {
+delFile("urlclassifier3.sqlite");
+delFile("safebrowsing/classifier.hashkey");
+delFile("safebrowsing/test-phish-simple.sbstore");
+delFile("safebrowsing/test-malware-simple.sbstore");
+delFile("safebrowsing/test-phish-simple.cache");
+delFile("safebrowsing/test-malware-simple.cache");
+delFile("safebrowsing/test-phish-simple.pset");
+delFile("safebrowsing/test-malware-simple.pset");
+}
+var allTables = "test-phish-simple,test-malware-simple";
+var dbservice = Cc["@mozilla.org/url-classifier/dbservice;1"].getService(Ci.nsIUrlClassifierDBService);
+var streamUpdater = Cc["@mozilla.org/url-classifier/streamupdater;1"]
+.getService(Ci.nsIUrlClassifierStreamUpdater);
+/*
+* Builds an update from an object that looks like:
+*{ "test-phish-simple" : [{
+*    "chunkType" : "a",  // 'a' is assumed if not specified
+*    "chunkNum" : 1,     // numerically-increasing chunk numbers are assumed
+*                        // if not specified
+*    "urls" : [ "foo.com/a", "foo.com/b", "bar.com/" ]
+* }
+*/
+function buildUpdate(update, hashSize) {
+if (!hashSize) {
+hashSize = 32;
+}
+var updateStr = "n:1000\n";
+for (var tableName in update) {
+if (tableName != "")
+updateStr += "i:" + tableName + "\n";
+var chunks = update[tableName];
+for (var j = 0; j < chunks.length; j++) {
+var chunk = chunks[j];
+var chunkType = chunk.chunkType ? chunk.chunkType : 'a';
+var chunkNum = chunk.chunkNum ? chunk.chunkNum : j;
+updateStr += chunkType + ':' + chunkNum + ':' + hashSize;
+if (chunk.urls) {
+var chunkData = chunk.urls.join("\n");
+updateStr += ":" + chunkData.length + "\n" + chunkData;
+}
+updateStr += "\n";
+}
+}
+return updateStr;
+}
+function buildPhishingUpdate(chunks, hashSize) {
+return buildUpdate({"test-phish-simple" : chunks}, hashSize);
+}
+function buildMalwareUpdate(chunks, hashSize) {
+return buildUpdate({"test-malware-simple" : chunks}, hashSize);
+}
+function buildBareUpdate(chunks, hashSize) {
+return buildUpdate({"" : chunks}, hashSize);
+}
+/**
+* Performs an update of the dbservice manually, bypassing the stream updater
+*/
+function doSimpleUpdate(updateText, success, failure) {
+var listener = {
+QueryInterface: function(iid)
+{
+if (iid.equals(Ci.nsISupports) ||
+iid.equals(Ci.nsIUrlClassifierUpdateObserver))
+return this;
+throw Cr.NS_ERROR_NO_INTERFACE;
+},
+updateUrlRequested: function(url) { },
+streamFinished: function(status) { },
+updateError: function(errorCode) { failure(errorCode); },
+updateSuccess: function(requestedTimeout) { success(requestedTimeout); }
+};
+dbservice.beginUpdate(listener,
+"test-phish-simple,test-malware-simple");
+dbservice.beginStream("", "");
+dbservice.updateStream(updateText);
+dbservice.finishStream();
+dbservice.finishUpdate();
+}
+/**
+* Simulates a failed database update.
+*/
+function doErrorUpdate(tables, success, failure) {
+var listener = {
+QueryInterface: function(iid)
+{
+if (iid.equals(Ci.nsISupports) ||
+iid.equals(Ci.nsIUrlClassifierUpdateObserver))
+return this;
+throw Cr.NS_ERROR_NO_INTERFACE;
+},
+updateUrlRequested: function(url) { },
+streamFinished: function(status) { },
+updateError: function(errorCode) { success(errorCode); },
+updateSuccess: function(requestedTimeout) { failure(requestedTimeout); }
+};
+dbservice.beginUpdate(listener, tables, null);
+dbservice.beginStream("", "");
+dbservice.cancelUpdate();
+}
+/**
+* Performs an update of the dbservice using the stream updater and a
+* data: uri
+*/
+function doStreamUpdate(updateText, success, failure, downloadFailure) {
+var dataUpdate = "data:," + encodeURIComponent(updateText);
+if (!downloadFailure)
+downloadFailure = failure;
+streamUpdater.updateUrl = dataUpdate;
+streamUpdater.downloadUpdates("test-phish-simple,test-malware-simple", "",
+success, failure, downloadFailure);
+}
+var gAssertions = {
+tableData : function(expectedTables, cb)
+{
+dbservice.getTables(function(tables) {
+// rebuild the tables in a predictable order.
+var parts = tables.split("\n");
+while (parts[parts.length - 1] == '') {
+parts.pop();
+}
+parts.sort();
+tables = parts.join("\n");
+do_check_eq(tables, expectedTables);
+cb();
+});
+},
+checkUrls: function(urls, expected, cb)
+{
+// work with a copy of the list.
+urls = urls.slice(0);
+var doLookup = function() {
+if (urls.length > 0) {
+var fragment = urls.shift();
+var principal = secMan.getNoAppCodebasePrincipal(iosvc.newURI("http://" + fragment, null, null));
+dbservice.lookup(principal, allTables,
+function(arg) {
+do_check_eq(expected, arg);
+doLookup();
+}, true);
+} else {
+cb();
+}
+};
+doLookup();
+},
+urlsDontExist: function(urls, cb)
+{
+this.checkUrls(urls, '', cb);
+},
+urlsExist: function(urls, cb)
+{
+this.checkUrls(urls, 'test-phish-simple', cb);
+},
+malwareUrlsExist: function(urls, cb)
+{
+this.checkUrls(urls, 'test-malware-simple', cb);
+},
+subsDontExist: function(urls, cb)
+{
+// XXX: there's no interface for checking items in the subs table
+cb();
+},
+subsExist: function(urls, cb)
+{
+// XXX: there's no interface for checking items in the subs table
+cb();
+}
+};
+/**
+* Check a set of assertions against the gAssertions table.
+*/
+function checkAssertions(assertions, doneCallback)
+{
+var checkAssertion = function() {
+for (var i in assertions) {
+var data = assertions[i];
+delete assertions[i];
+gAssertions[i](data, checkAssertion);
+return;
+}
+doneCallback();
+}
+checkAssertion();
+}
+function updateError(arg)
+{
+do_throw(arg);
+}
+// Runs a set of updates, and then checks a set of assertions.
+function doUpdateTest(updates, assertions, successCallback, errorCallback) {
+var errorUpdate = function() {
+checkAssertions(assertions, errorCallback);
+}
+var runUpdate = function() {
+if (updates.length > 0) {
+var update = updates.shift();
+doStreamUpdate(update, runUpdate, errorUpdate, null);
+} else {
+checkAssertions(assertions, successCallback);
+}
+}
+runUpdate();
+}
+var gTests;
+var gNextTest = 0;
+function runNextTest()
+{
+if (gNextTest >= gTests.length) {
+do_test_finished();
+return;
+}
+dbservice.resetDatabase();
+dbservice.setHashCompleter('test-phish-simple', null);
+let test = gTests[gNextTest++];
+dump("running " + test.name + "\n");
+test();
+}
+function runTests(tests)
+{
+gTests = tests;
+runNextTest();
+}
+var timerArray = [];
+function Timer(delay, cb) {
+this.cb = cb;
+var timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+timer.initWithCallback(this, delay, timer.TYPE_ONE_SHOT);
+timerArray.push(timer);
+}
+Timer.prototype = {
+QueryInterface: function(iid) {
+if (!iid.equals(Ci.nsISupports) && !iid.equals(Ci.nsITimerCallback)) {
+throw Cr.NS_ERROR_NO_INTERFACE;
+}
+return this;
+},
+notify: function(timer) {
+this.cb();
+}
+}
+// LFSRgenerator is a 32-bit linear feedback shift register random number
+// generator. It is highly predictable and is not intended to be used for
+// cryptography but rather to allow easier debugging than a test that uses
+// Math.random().
+function LFSRgenerator(seed) {
+// Force |seed| to be a number.
+seed = +seed;
+// LFSR generators do not work with a value of 0.
+if (seed == 0)
+seed = 1;
+this._value = seed;
+}
+LFSRgenerator.prototype = {
+// nextNum returns a random unsigned integer of in the range [0,2^|bits|].
+nextNum: function(bits) {
+if (!bits)
+bits = 32;
+let val = this._value;
+// Taps are 32, 22, 2 and 1.
+let bit = ((val >>> 0) ^ (val >>> 10) ^ (val >>> 30) ^ (val >>> 31)) & 1;
+val = (val >>> 1) | (bit << 31);
+this._value = val;
+return (val >>> (32 - bits));
+},
+};
+cleanUp();