The Tor Browser / file comparison
comparison: uriloader/exthandler/tests/unit/test_handlerService.js
uriloader/exthandler/tests/unit/test_handlerService.js
- branch
- TOR_BUG_3246
- changeset 4
- fc2d59ddac77
equal
deleted
inserted
replaced
| -1:000000000000 | 0:c44bdbf04562 |
|---|---|
| 1 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 2 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 4 | |
| 5 function run_test() { | |
| 6 //**************************************************************************// | |
| 7 // Constants | |
| 8 | |
| 9 const handlerSvc = Cc["@mozilla.org/uriloader/handler-service;1"]. | |
| 10 getService(Ci.nsIHandlerService); | |
| 11 | |
| 12 const mimeSvc = Cc["@mozilla.org/mime;1"]. | |
| 13 getService(Ci.nsIMIMEService); | |
| 14 | |
| 15 const protoSvc = Cc["@mozilla.org/uriloader/external-protocol-service;1"]. | |
| 16 getService(Ci.nsIExternalProtocolService); | |
| 17 | |
| 18 const prefSvc = Cc["@mozilla.org/preferences-service;1"]. | |
| 19 getService(Ci.nsIPrefService); | |
| 20 | |
| 21 const ioService = Cc["@mozilla.org/network/io-service;1"]. | |
| 22 getService(Ci.nsIIOService); | |
| 23 | |
| 24 const env = Cc["@mozilla.org/process/environment;1"]. | |
| 25 getService(Components.interfaces.nsIEnvironment); | |
| 26 | |
| 27 const rootPrefBranch = prefSvc.getBranch(""); | |
| 28 | |
| 29 let noMailto = false; | |
| 30 let isWindows = ("@mozilla.org/windows-registry-key;1" in Components.classes); | |
| 31 if (isWindows) { | |
| 32 // Check mailto handler from registry. | |
| 33 // If registry entry is nothing, no mailto handler | |
| 34 let regSvc = Cc["@mozilla.org/windows-registry-key;1"]. | |
| 35 createInstance(Ci.nsIWindowsRegKey); | |
| 36 try { | |
| 37 regSvc.open(regSvc.ROOT_KEY_CLASSES_ROOT, | |
| 38 "mailto", | |
| 39 regSvc.ACCESS_READ); | |
| 40 noMailto = false; | |
| 41 } catch (ex) { | |
| 42 noMailto = true; | |
| 43 } | |
| 44 regSvc.close(); | |
| 45 } | |
| 46 | |
| 47 //**************************************************************************// | |
| 48 // Sample Data | |
| 49 | |
| 50 // It doesn't matter whether or not this nsIFile is actually executable, | |
| 51 // only that it has a path and exists. Since we don't know any executable | |
| 52 // that exists on all platforms (except possibly the application being | |
| 53 // tested, but there doesn't seem to be a way to get a reference to that | |
| 54 // from the directory service), we use the temporary directory itself. | |
| 55 var executable = HandlerServiceTest._dirSvc.get("TmpD", Ci.nsIFile); | |
| 56 // XXX We could, of course, create an actual executable in the directory: | |
| 57 //executable.append("localhandler"); | |
| 58 //if (!executable.exists()) | |
| 59 // executable.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0755); | |
| 60 | |
| 61 var localHandler = { | |
| 62 name: "Local Handler", | |
| 63 executable: executable, | |
| 64 interfaces: [Ci.nsIHandlerApp, Ci.nsILocalHandlerApp, Ci.nsISupports], | |
| 65 QueryInterface: function(iid) { | |
| 66 if (!this.interfaces.some( function(v) { return iid.equals(v) } )) | |
| 67 throw Cr.NS_ERROR_NO_INTERFACE; | |
| 68 return this; | |
| 69 } | |
| 70 }; | |
| 71 | |
| 72 var webHandler = Cc["@mozilla.org/uriloader/web-handler-app;1"]. | |
| 73 createInstance(Ci.nsIWebHandlerApp); | |
| 74 webHandler.name = "Web Handler"; | |
| 75 webHandler.uriTemplate = "http://www.example.com/?%s"; | |
| 76 | |
| 77 // FIXME: these tests create and manipulate enough variables that it would | |
| 78 // make sense to move each test into its own scope so we don't run the risk | |
| 79 // of one test stomping on another's data. | |
| 80 | |
| 81 | |
| 82 //**************************************************************************// | |
| 83 // Test Default Properties | |
| 84 | |
| 85 // Get a handler info for a MIME type that neither the application nor | |
| 86 // the OS knows about and make sure its properties are set to the proper | |
| 87 // default values. | |
| 88 | |
| 89 var handlerInfo = mimeSvc.getFromTypeAndExtension("nonexistent/type", null); | |
| 90 | |
| 91 // Make sure it's also an nsIHandlerInfo. | |
| 92 do_check_true(handlerInfo instanceof Ci.nsIHandlerInfo); | |
| 93 | |
| 94 do_check_eq(handlerInfo.type, "nonexistent/type"); | |
| 95 | |
| 96 // Deprecated property, but we should still make sure it's set correctly. | |
| 97 do_check_eq(handlerInfo.MIMEType, "nonexistent/type"); | |
| 98 | |
| 99 // These properties are the ones the handler service knows how to store. | |
| 100 do_check_eq(handlerInfo.preferredAction, Ci.nsIHandlerInfo.saveToDisk); | |
| 101 do_check_eq(handlerInfo.preferredApplicationHandler, null); | |
| 102 do_check_eq(handlerInfo.possibleApplicationHandlers.length, 0); | |
| 103 do_check_true(handlerInfo.alwaysAskBeforeHandling); | |
| 104 | |
| 105 // These properties are initialized to default values by the service, | |
| 106 // so we might as well make sure they're initialized to the right defaults. | |
| 107 do_check_eq(handlerInfo.description, ""); | |
| 108 do_check_eq(handlerInfo.hasDefaultHandler, false); | |
| 109 do_check_eq(handlerInfo.defaultDescription, ""); | |
| 110 | |
| 111 // test some default protocol info properties | |
| 112 var haveDefaultHandlersVersion = false; | |
| 113 try { | |
| 114 // If we have a defaultHandlersVersion pref, then assume that we're in the | |
| 115 // firefox tree and that we'll also have default handlers. | |
| 116 // Bug 395131 has been filed to make this test work more generically | |
| 117 // by providing our own prefs for this test rather than this icky | |
| 118 // special casing. | |
| 119 rootPrefBranch.getCharPref("gecko.handlerService.defaultHandlersVersion"); | |
| 120 haveDefaultHandlersVersion = true; | |
| 121 } catch (ex) {} | |
| 122 | |
| 123 const kExternalWarningDefault = | |
| 124 "network.protocol-handler.warn-external-default"; | |
| 125 prefSvc.setBoolPref(kExternalWarningDefault, true); | |
| 126 | |
| 127 // XXX add more thorough protocol info property checking | |
| 128 | |
| 129 // no OS default handler exists | |
| 130 var protoInfo = protoSvc.getProtocolHandlerInfo("x-moz-rheet"); | |
| 131 do_check_eq(protoInfo.preferredAction, protoInfo.alwaysAsk); | |
| 132 do_check_true(protoInfo.alwaysAskBeforeHandling); | |
| 133 | |
| 134 // OS default exists, injected default does not exist, | |
| 135 // explicit warning pref: false | |
| 136 const kExternalWarningPrefPrefix = "network.protocol-handler.warn-external."; | |
| 137 prefSvc.setBoolPref(kExternalWarningPrefPrefix + "http", false); | |
| 138 protoInfo = protoSvc.getProtocolHandlerInfo("http"); | |
| 139 do_check_eq(0, protoInfo.possibleApplicationHandlers.length); | |
| 140 do_check_false(protoInfo.alwaysAskBeforeHandling); | |
| 141 | |
| 142 // OS default exists, injected default does not exist, | |
| 143 // explicit warning pref: true | |
| 144 prefSvc.setBoolPref(kExternalWarningPrefPrefix + "http", true); | |
| 145 protoInfo = protoSvc.getProtocolHandlerInfo("http"); | |
| 146 // OS handler isn't included in possibleApplicationHandlers, so length is 0 | |
| 147 // Once they become instances of nsILocalHandlerApp, this number will need | |
| 148 // to change. | |
| 149 do_check_eq(0, protoInfo.possibleApplicationHandlers.length); | |
| 150 do_check_true(protoInfo.alwaysAskBeforeHandling); | |
| 151 | |
| 152 // OS default exists, injected default exists, explicit warning pref: false | |
| 153 prefSvc.setBoolPref(kExternalWarningPrefPrefix + "mailto", false); | |
| 154 protoInfo = protoSvc.getProtocolHandlerInfo("mailto"); | |
| 155 if (haveDefaultHandlersVersion) | |
| 156 do_check_eq(2, protoInfo.possibleApplicationHandlers.length); | |
| 157 else | |
| 158 do_check_eq(0, protoInfo.possibleApplicationHandlers.length); | |
| 159 | |
| 160 // Win7+ might not have a default mailto: handler | |
| 161 if (noMailto) | |
| 162 do_check_true(protoInfo.alwaysAskBeforeHandling); | |
| 163 else | |
| 164 do_check_false(protoInfo.alwaysAskBeforeHandling); | |
| 165 | |
| 166 // OS default exists, injected default exists, explicit warning pref: true | |
| 167 prefSvc.setBoolPref(kExternalWarningPrefPrefix + "mailto", true); | |
| 168 protoInfo = protoSvc.getProtocolHandlerInfo("mailto"); | |
| 169 if (haveDefaultHandlersVersion) { | |
| 170 do_check_eq(2, protoInfo.possibleApplicationHandlers.length); | |
| 171 // Win7+ might not have a default mailto: handler, but on other platforms | |
| 172 // alwaysAskBeforeHandling is expected to be false here, because although | |
| 173 // the pref is true, the value in RDF is false. The injected mailto handler | |
| 174 // carried over the default pref value, and so when we set the pref above | |
| 175 // to true it's ignored. | |
| 176 if (noMailto) | |
| 177 do_check_true(protoInfo.alwaysAskBeforeHandling); | |
| 178 else | |
| 179 do_check_false(protoInfo.alwaysAskBeforeHandling); | |
| 180 | |
| 181 } else { | |
| 182 do_check_eq(0, protoInfo.possibleApplicationHandlers.length); | |
| 183 do_check_true(protoInfo.alwaysAskBeforeHandling); | |
| 184 } | |
| 185 | |
| 186 if (haveDefaultHandlersVersion) { | |
| 187 // Now set the value stored in RDF to true, and the pref to false, to make | |
| 188 // sure we still get the right value. (Basically, same thing as above but | |
| 189 // with the values reversed.) | |
| 190 prefSvc.setBoolPref(kExternalWarningPrefPrefix + "mailto", false); | |
| 191 protoInfo.alwaysAskBeforeHandling = true; | |
| 192 handlerSvc.store(protoInfo); | |
| 193 protoInfo = protoSvc.getProtocolHandlerInfo("mailto"); | |
| 194 do_check_eq(2, protoInfo.possibleApplicationHandlers.length); | |
| 195 do_check_true(protoInfo.alwaysAskBeforeHandling); | |
| 196 } | |
| 197 | |
| 198 | |
| 199 //**************************************************************************// | |
| 200 // Test Round-Trip Data Integrity | |
| 201 | |
| 202 // Test round-trip data integrity by setting the properties of the handler | |
| 203 // info object to different values, telling the handler service to store the | |
| 204 // object, and then retrieving a new info object for the same type and making | |
| 205 // sure its properties are identical. | |
| 206 | |
| 207 handlerInfo.preferredAction = Ci.nsIHandlerInfo.useHelperApp; | |
| 208 handlerInfo.preferredApplicationHandler = localHandler; | |
| 209 handlerInfo.alwaysAskBeforeHandling = false; | |
| 210 | |
| 211 handlerSvc.store(handlerInfo); | |
| 212 | |
| 213 handlerInfo = mimeSvc.getFromTypeAndExtension("nonexistent/type", null); | |
| 214 | |
| 215 do_check_eq(handlerInfo.preferredAction, Ci.nsIHandlerInfo.useHelperApp); | |
| 216 | |
| 217 do_check_neq(handlerInfo.preferredApplicationHandler, null); | |
| 218 var preferredHandler = handlerInfo.preferredApplicationHandler; | |
| 219 do_check_eq(typeof preferredHandler, "object"); | |
| 220 do_check_eq(preferredHandler.name, "Local Handler"); | |
| 221 do_check_true(preferredHandler instanceof Ci.nsILocalHandlerApp); | |
| 222 preferredHandler.QueryInterface(Ci.nsILocalHandlerApp); | |
| 223 do_check_eq(preferredHandler.executable.path, localHandler.executable.path); | |
| 224 | |
| 225 do_check_false(handlerInfo.alwaysAskBeforeHandling); | |
| 226 | |
| 227 // Make sure the handler service's enumerate method lists all known handlers. | |
| 228 var handlerInfo2 = mimeSvc.getFromTypeAndExtension("nonexistent/type2", null); | |
| 229 handlerSvc.store(handlerInfo2); | |
| 230 var handlerTypes = ["nonexistent/type", "nonexistent/type2"]; | |
| 231 if (haveDefaultHandlersVersion) { | |
| 232 handlerTypes.push("webcal"); | |
| 233 handlerTypes.push("mailto"); | |
| 234 handlerTypes.push("irc"); | |
| 235 handlerTypes.push("ircs"); | |
| 236 } | |
| 237 var handlers = handlerSvc.enumerate(); | |
| 238 while (handlers.hasMoreElements()) { | |
| 239 var handler = handlers.getNext().QueryInterface(Ci.nsIHandlerInfo); | |
| 240 do_check_neq(handlerTypes.indexOf(handler.type), -1); | |
| 241 handlerTypes.splice(handlerTypes.indexOf(handler.type), 1); | |
| 242 } | |
| 243 do_check_eq(handlerTypes.length, 0); | |
| 244 | |
| 245 // Make sure the handler service's remove method removes a handler record. | |
| 246 handlerSvc.remove(handlerInfo2); | |
| 247 handlers = handlerSvc.enumerate(); | |
| 248 while (handlers.hasMoreElements()) | |
| 249 do_check_neq(handlers.getNext().QueryInterface(Ci.nsIHandlerInfo).type, | |
| 250 handlerInfo2.type); | |
| 251 | |
| 252 // Make sure we can store and retrieve a handler info object with no preferred | |
| 253 // handler. | |
| 254 var noPreferredHandlerInfo = | |
| 255 mimeSvc.getFromTypeAndExtension("nonexistent/no-preferred-handler", null); | |
| 256 handlerSvc.store(noPreferredHandlerInfo); | |
| 257 noPreferredHandlerInfo = | |
| 258 mimeSvc.getFromTypeAndExtension("nonexistent/no-preferred-handler", null); | |
| 259 do_check_eq(noPreferredHandlerInfo.preferredApplicationHandler, null); | |
| 260 | |
| 261 // Make sure that the handler service removes an existing handler record | |
| 262 // if we store a handler info object with no preferred handler. | |
| 263 var removePreferredHandlerInfo = | |
| 264 mimeSvc.getFromTypeAndExtension("nonexistent/rem-preferred-handler", null); | |
| 265 removePreferredHandlerInfo.preferredApplicationHandler = localHandler; | |
| 266 handlerSvc.store(removePreferredHandlerInfo); | |
| 267 removePreferredHandlerInfo = | |
| 268 mimeSvc.getFromTypeAndExtension("nonexistent/rem-preferred-handler", null); | |
| 269 removePreferredHandlerInfo.preferredApplicationHandler = null; | |
| 270 handlerSvc.store(removePreferredHandlerInfo); | |
| 271 removePreferredHandlerInfo = | |
| 272 mimeSvc.getFromTypeAndExtension("nonexistent/rem-preferred-handler", null); | |
| 273 do_check_eq(removePreferredHandlerInfo.preferredApplicationHandler, null); | |
| 274 | |
| 275 // Make sure we can store and retrieve a handler info object with possible | |
| 276 // handlers. We test both adding and removing handlers. | |
| 277 | |
| 278 // Get a handler info and make sure it has no possible handlers. | |
| 279 var possibleHandlersInfo = | |
| 280 mimeSvc.getFromTypeAndExtension("nonexistent/possible-handlers", null); | |
| 281 do_check_eq(possibleHandlersInfo.possibleApplicationHandlers.length, 0); | |
| 282 | |
| 283 // Store and re-retrieve the handler and make sure it still has no possible | |
| 284 // handlers. | |
| 285 handlerSvc.store(possibleHandlersInfo); | |
| 286 possibleHandlersInfo = | |
| 287 mimeSvc.getFromTypeAndExtension("nonexistent/possible-handlers", null); | |
| 288 do_check_eq(possibleHandlersInfo.possibleApplicationHandlers.length, 0); | |
| 289 | |
| 290 // Add two handlers, store the object, re-retrieve it, and make sure it has | |
| 291 // two handlers. | |
| 292 possibleHandlersInfo.possibleApplicationHandlers.appendElement(localHandler, | |
| 293 false); | |
| 294 possibleHandlersInfo.possibleApplicationHandlers.appendElement(webHandler, | |
| 295 false); | |
| 296 handlerSvc.store(possibleHandlersInfo); | |
| 297 possibleHandlersInfo = | |
| 298 mimeSvc.getFromTypeAndExtension("nonexistent/possible-handlers", null); | |
| 299 do_check_eq(possibleHandlersInfo.possibleApplicationHandlers.length, 2); | |
| 300 | |
| 301 // Figure out which is the local and which is the web handler and the index | |
| 302 // in the array of the local handler, which is the one we're going to remove | |
| 303 // to test removal of a handler. | |
| 304 var handler1 = possibleHandlersInfo.possibleApplicationHandlers. | |
| 305 queryElementAt(0, Ci.nsIHandlerApp); | |
| 306 var handler2 = possibleHandlersInfo.possibleApplicationHandlers. | |
| 307 queryElementAt(1, Ci.nsIHandlerApp); | |
| 308 var localPossibleHandler, webPossibleHandler, localIndex; | |
| 309 if (handler1 instanceof Ci.nsILocalHandlerApp) | |
| 310 [localPossibleHandler, webPossibleHandler, localIndex] = [handler1, | |
| 311 handler2, | |
| 312 0]; | |
| 313 else | |
| 314 [localPossibleHandler, webPossibleHandler, localIndex] = [handler2, | |
| 315 handler1, | |
| 316 1]; | |
| 317 localPossibleHandler.QueryInterface(Ci.nsILocalHandlerApp); | |
| 318 webPossibleHandler.QueryInterface(Ci.nsIWebHandlerApp); | |
| 319 | |
| 320 // Make sure the two handlers are the ones we stored. | |
| 321 do_check_eq(localPossibleHandler.name, localHandler.name); | |
| 322 do_check_true(localPossibleHandler.equals(localHandler)); | |
| 323 do_check_eq(webPossibleHandler.name, webHandler.name); | |
| 324 do_check_true(webPossibleHandler.equals(webHandler)); | |
| 325 | |
| 326 // Remove a handler, store the object, re-retrieve it, and make sure | |
| 327 // it only has one handler. | |
| 328 possibleHandlersInfo.possibleApplicationHandlers.removeElementAt(localIndex); | |
| 329 handlerSvc.store(possibleHandlersInfo); | |
| 330 possibleHandlersInfo = | |
| 331 mimeSvc.getFromTypeAndExtension("nonexistent/possible-handlers", null); | |
| 332 do_check_eq(possibleHandlersInfo.possibleApplicationHandlers.length, 1); | |
| 333 | |
| 334 // Make sure the handler is the one we didn't remove. | |
| 335 webPossibleHandler = possibleHandlersInfo.possibleApplicationHandlers. | |
| 336 queryElementAt(0, Ci.nsIWebHandlerApp); | |
| 337 do_check_eq(webPossibleHandler.name, webHandler.name); | |
| 338 do_check_true(webPossibleHandler.equals(webHandler)); | |
| 339 | |
| 340 ////////////////////////////////////////////////////// | |
| 341 // handler info command line parameters and equality | |
| 342 var localApp = Cc["@mozilla.org/uriloader/local-handler-app;1"]. | |
| 343 createInstance(Ci.nsILocalHandlerApp); | |
| 344 var handlerApp = localApp.QueryInterface(Ci.nsIHandlerApp); | |
| 345 | |
| 346 do_check_true(handlerApp.equals(localApp)); | |
| 347 | |
| 348 localApp.executable = executable; | |
| 349 | |
| 350 do_check_eq(0, localApp.parameterCount); | |
| 351 localApp.appendParameter("-test1"); | |
| 352 do_check_eq(1, localApp.parameterCount); | |
| 353 localApp.appendParameter("-test2"); | |
| 354 do_check_eq(2, localApp.parameterCount); | |
| 355 do_check_true(localApp.parameterExists("-test1")); | |
| 356 do_check_true(localApp.parameterExists("-test2")); | |
| 357 do_check_false(localApp.parameterExists("-false")); | |
| 358 localApp.clearParameters(); | |
| 359 do_check_eq(0, localApp.parameterCount); | |
| 360 | |
| 361 var localApp2 = Cc["@mozilla.org/uriloader/local-handler-app;1"]. | |
| 362 createInstance(Ci.nsILocalHandlerApp); | |
| 363 | |
| 364 localApp2.executable = executable; | |
| 365 | |
| 366 localApp.clearParameters(); | |
| 367 do_check_true(localApp.equals(localApp2)); | |
| 368 | |
| 369 // equal: | |
| 370 // cut -d 1 -f 2 | |
| 371 // cut -d 1 -f 2 | |
| 372 | |
| 373 localApp.appendParameter("-test1"); | |
| 374 localApp.appendParameter("-test2"); | |
| 375 localApp.appendParameter("-test3"); | |
| 376 localApp2.appendParameter("-test1"); | |
| 377 localApp2.appendParameter("-test2"); | |
| 378 localApp2.appendParameter("-test3"); | |
| 379 do_check_true(localApp.equals(localApp2)); | |
| 380 | |
| 381 // not equal: | |
| 382 // cut -d 1 -f 2 | |
| 383 // cut -f 1 -d 2 | |
| 384 | |
| 385 localApp.clearParameters(); | |
| 386 localApp2.clearParameters(); | |
| 387 | |
| 388 localApp.appendParameter("-test1"); | |
| 389 localApp.appendParameter("-test2"); | |
| 390 localApp.appendParameter("-test3"); | |
| 391 localApp2.appendParameter("-test2"); | |
| 392 localApp2.appendParameter("-test1"); | |
| 393 localApp2.appendParameter("-test3"); | |
| 394 do_check_false(localApp2.equals(localApp)); | |
| 395 | |
| 396 var str; | |
| 397 str = localApp.getParameter(0) | |
| 398 do_check_eq(str, "-test1"); | |
| 399 str = localApp.getParameter(1) | |
| 400 do_check_eq(str, "-test2"); | |
| 401 str = localApp.getParameter(2) | |
| 402 do_check_eq(str, "-test3"); | |
| 403 | |
| 404 // FIXME: test round trip integrity for a protocol. | |
| 405 // FIXME: test round trip integrity for a handler info with a web handler. | |
| 406 | |
| 407 //**************************************************************************// | |
| 408 // getTypeFromExtension tests | |
| 409 | |
| 410 // test nonexistent extension | |
| 411 var lolType = handlerSvc.getTypeFromExtension("lolcat"); | |
| 412 do_check_eq(lolType, ""); | |
| 413 | |
| 414 | |
| 415 // add a handler for the extension | |
| 416 var lolHandler = mimeSvc.getFromTypeAndExtension("application/lolcat", null); | |
| 417 | |
| 418 do_check_false(lolHandler.extensionExists("lolcat")); | |
| 419 lolHandler.preferredAction = Ci.nsIHandlerInfo.useHelperApp; | |
| 420 lolHandler.preferredApplicationHandler = localHandler; | |
| 421 lolHandler.alwaysAskBeforeHandling = false; | |
| 422 | |
| 423 // store the handler | |
| 424 do_check_false(handlerSvc.exists(lolHandler)); | |
| 425 handlerSvc.store(lolHandler); | |
| 426 do_check_true(handlerSvc.exists(lolHandler)); | |
| 427 | |
| 428 // Get a file:// string pointing to mimeTypes.rdf | |
| 429 var rdfFile = HandlerServiceTest._dirSvc.get("UMimTyp", Ci.nsIFile); | |
| 430 var fileHandler = ioService.getProtocolHandler("file").QueryInterface(Ci.nsIFileProtocolHandler); | |
| 431 var rdfFileURI = fileHandler.getURLSpecFromFile(rdfFile); | |
| 432 | |
| 433 // Assign a file extenstion to the handler. handlerSvc.store() doesn't | |
| 434 // actually store any file extensions added with setFileExtensions(), you | |
| 435 // have to wade into RDF muck to do so. | |
| 436 | |
| 437 // Based on toolkit/mozapps/downloads/content/helperApps.js :: addExtension() | |
| 438 var gRDF = Cc["@mozilla.org/rdf/rdf-service;1"].getService(Ci.nsIRDFService); | |
| 439 var mimeSource = gRDF.GetUnicodeResource("urn:mimetype:application/lolcat"); | |
| 440 var valueProperty = gRDF.GetUnicodeResource("http://home.netscape.com/NC-rdf#fileExtensions"); | |
| 441 var mimeLiteral = gRDF.GetLiteral("lolcat"); | |
| 442 | |
| 443 var DS = gRDF.GetDataSourceBlocking(rdfFileURI); | |
| 444 DS.Assert(mimeSource, valueProperty, mimeLiteral, true); | |
| 445 | |
| 446 | |
| 447 // test now-existent extension | |
| 448 lolType = handlerSvc.getTypeFromExtension("lolcat"); | |
| 449 do_check_eq(lolType, "application/lolcat"); | |
| 450 | |
| 451 if (env.get("PERSONAL_MAILCAP")) { | |
| 452 handlerInfo = mimeSvc.getFromTypeAndExtension("text/plain", null); | |
| 453 do_check_eq(handlerInfo.preferredAction, Ci.nsIHandlerInfo.useSystemDefault); | |
| 454 do_check_eq(handlerInfo.defaultDescription, "sed"); | |
| 455 } | |
| 456 } |
