src/chrome/test/data/extensions/api_test/cookies/api/tab.js

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 var TEST_DOMAIN = 'cookies.com';
   6 var TEST_PATH = '/auth';
   7 var TEST_HOST = 'www.chrome_extensions.' + TEST_DOMAIN;
   8 var TEST_URL = 'http://' + TEST_HOST + '/foobar.html?arg=toolbar&param=true';
   9 var TEST_URL2 = 'http://chromium.' + TEST_DOMAIN + '/index.html';
  10 var TEST_URL3 = 'https://' + TEST_HOST + '/content.html';
  11 var TEST_URL4 = 'https://' + TEST_HOST + TEST_PATH + '/content.html';
  12 var TEST_URL5 = 'http://' + TEST_HOST + TEST_PATH + '/content.html';
  13 var TEST_EXPIRATION_DATE = 12345678900;
  14 var TEST_ODD_DOMAIN = '.strange stuff!!.com';
  15 var TEST_ODD_PATH = '/hello = world';
  16 var TEST_ODD_URL = 'http://' + TEST_ODD_DOMAIN + TEST_ODD_PATH + '/index.html';
  17 var TEST_UNPERMITTED_URL = 'http://illegal.' + TEST_DOMAIN + '/';
  18
  19 var TEST_BASIC_COOKIE = {
  20   url: TEST_URL,
  21   name: 'api_test_cookie',
  22   value: 'helloworld'
  23 };
  24 var TEST_DOMAIN_COOKIE = {
  25   url: TEST_URL,
  26   name: 'TEST_domain',
  27   value: '32849395FFDSAA**##@@@',
  28   domain: TEST_DOMAIN,
  29   expirationDate: TEST_EXPIRATION_DATE
  30 };
  31 var TEST_SECURE_COOKIE = {
  32   url: TEST_URL5,
  33   name: 'SECRETCOOKIE',
  34   value: 'foobar_password',
  35   secure: true,
  36   httpOnly: true
  37 };
  38 var TEST_BASIC_EXPIRED_COOKIE = {
  39   url: TEST_BASIC_COOKIE.url,
  40   name: TEST_BASIC_COOKIE.name,
  41   value: TEST_BASIC_COOKIE.value,
  42   expirationDate: 0
  43 };
  44
  45 function readCookie(name) {
  46   var nameEQ = name + '=';
  47   var cookies = document.cookie.split(';');
  48   for(var i=0; i < cookies.length; i++) {
  49     var c = cookies[i];
  50     while (c.charAt(0)==' ') {
  51       c = c.substring(1);
  52     }
  53     if (c.indexOf(nameEQ) == 0) {
  54       return c.substring(nameEQ.length);
  55     }
  56   }
  57   return null;
  58 }
  59
  60 function expectValidCookie(cookie) {
  61   chrome.test.assertTrue(cookie != null, 'Expected cookie not set.');
  62 }
  63
  64 function expectNullCookie(cookie) {
  65   chrome.test.assertEq(null, cookie);
  66 }
  67
  68 function expectUndefinedCookie(cookie) {
  69   chrome.test.assertEq(undefined, cookie);
  70 }
  71
  72 function removeTestCookies() {
  73   chrome.cookies.remove(
  74       {url: TEST_URL, name: TEST_BASIC_COOKIE.name});
  75   chrome.cookies.remove(
  76       {url: TEST_URL, name: TEST_DOMAIN_COOKIE.name});
  77   chrome.cookies.remove(
  78       {url: TEST_URL4, name: TEST_SECURE_COOKIE.name});
  79   chrome.cookies.remove({url: TEST_URL, name: 'abcd'});
  80   chrome.cookies.remove({url: TEST_ODD_URL, name: 'abcd'});
  81 }
  82
  83 var pass = chrome.test.callbackPass;
  84 var fail = chrome.test.callbackFail;
  85
  86 chrome.test.runTests([
  87   function readCookies() {
  88     chrome.test.assertEq('1', readCookie('a'));
  89     chrome.test.assertEq('2', readCookie('b'));
  90     chrome.test.assertEq('3', readCookie('c'));
  91     chrome.test.assertEq(null, readCookie('nonexistent'));
  92     // Invalid schemes don't work with the cookie API.
  93     chrome.cookies.get(
  94         {url: document.location.href, name: 'a'},
  95         fail('No host permissions for cookies at url: "' +
  96              document.location.href + '".'));
  97   },
  98   function getBasicCookie() {
  99     removeTestCookies();
 100     chrome.cookies.set(TEST_BASIC_COOKIE, pass(function () {
 101       // Domain doesn't match.
 102       chrome.cookies.get(
 103           {url: TEST_URL2, name: TEST_BASIC_COOKIE.name},
 104           pass(expectNullCookie));
 105       // URL invalid.
 106       chrome.cookies.get(
 107           {url: 'invalid url', name: TEST_BASIC_COOKIE.name},
 108           fail('Invalid url: "invalid url".'));
 109       // URL lacking permissions.
 110       chrome.cookies.get(
 111           {url: TEST_UNPERMITTED_URL, name: TEST_BASIC_COOKIE.name},
 112           fail('No host permissions for cookies at url: "' +
 113                TEST_UNPERMITTED_URL + '".'));
 114       // Store ID invalid.
 115       chrome.cookies.get({
 116         url: TEST_BASIC_COOKIE.url,
 117         name: TEST_BASIC_COOKIE.name,
 118         storeId: 'invalid'
 119       }, fail('Invalid cookie store id: "invalid".'));
 120       chrome.cookies.get(
 121           {url: TEST_BASIC_COOKIE.url, name: TEST_BASIC_COOKIE.name},
 122           pass(function(cookie) {
 123             expectValidCookie(cookie);
 124             chrome.test.assertEq(TEST_BASIC_COOKIE.name, cookie.name);
 125             chrome.test.assertEq(TEST_BASIC_COOKIE.value, cookie.value);
 126             chrome.test.assertEq(TEST_HOST, cookie.domain);
 127             chrome.test.assertEq(true, cookie.hostOnly);
 128             chrome.test.assertEq('/', cookie.path);
 129             chrome.test.assertEq(false, cookie.secure);
 130             chrome.test.assertEq(false, cookie.httpOnly);
 131             chrome.test.assertEq(true, cookie.session);
 132             chrome.test.assertTrue(typeof cookie.expirationDate === 'undefined',
 133                 'Session cookie should not have expirationDate property.');
 134             chrome.test.assertTrue(typeof cookie.storeId !== 'undefined',
 135                                    'Cookie store ID not provided.');
 136           }));
 137     }));
 138   },
 139   function getDomainCookie() {
 140     removeTestCookies();
 141     chrome.cookies.set(TEST_DOMAIN_COOKIE, pass(function () {
 142       chrome.cookies.get(
 143           {url: TEST_URL2, name: TEST_DOMAIN_COOKIE.name},
 144           pass(function(cookie) {
 145             expectValidCookie(cookie);
 146             chrome.test.assertEq(TEST_DOMAIN_COOKIE.name, cookie.name);
 147             chrome.test.assertEq(TEST_DOMAIN_COOKIE.value, cookie.value);
 148             chrome.test.assertEq('.' + TEST_DOMAIN, cookie.domain);
 149             chrome.test.assertEq(false, cookie.hostOnly);
 150             chrome.test.assertEq('/', cookie.path);
 151             chrome.test.assertEq(false, cookie.secure);
 152             chrome.test.assertEq(false, cookie.httpOnly);
 153             chrome.test.assertEq(false, cookie.session);
 154             chrome.test.assertEq(TEST_EXPIRATION_DATE, cookie.expirationDate);
 155           }));
 156     }));
 157   },
 158   function getSecureCookie() {
 159     removeTestCookies();
 160     chrome.cookies.set(TEST_SECURE_COOKIE, pass(function () {
 161       // Original URL doesn't work because scheme isn't secure.
 162       chrome.cookies.get(
 163           {url: TEST_SECURE_COOKIE.url, name: TEST_SECURE_COOKIE.name},
 164           pass(expectNullCookie));
 165       // Path doesn't match.
 166       chrome.cookies.get(
 167           {url: TEST_URL3, name: TEST_SECURE_COOKIE.name},
 168           pass(expectNullCookie));
 169       chrome.cookies.get(
 170           {url: TEST_URL4, name: TEST_SECURE_COOKIE.name},
 171           pass(function(cookie) {
 172             expectValidCookie(cookie);
 173             chrome.test.assertEq(TEST_SECURE_COOKIE.name, cookie.name);
 174             chrome.test.assertEq(TEST_SECURE_COOKIE.value, cookie.value);
 175             chrome.test.assertEq(TEST_HOST, cookie.domain);
 176             chrome.test.assertEq(true, cookie.hostOnly);
 177             chrome.test.assertEq(TEST_PATH, cookie.path);
 178             chrome.test.assertEq(true, cookie.secure);
 179             chrome.test.assertEq(true, cookie.httpOnly);
 180             chrome.test.assertEq(true, cookie.session);
 181           }));
 182     }));
 183   },
 184   function setOddCookies() {
 185     removeTestCookies();
 186     // URL lacking permissions.
 187     chrome.cookies.set(
 188         {url: TEST_UNPERMITTED_URL, name: 'abcd', domain: TEST_DOMAIN},
 189         fail('No host permissions for cookies at url: "' +
 190             TEST_UNPERMITTED_URL + '".',
 191             function () {
 192               chrome.cookies.get({url: TEST_URL, name: 'abcd'},
 193                 pass(expectNullCookie));
 194             }));
 195     // Attribute values containing invalid characters are disallowed.
 196     chrome.cookies.set({url: TEST_URL, name: 'abcd=efg'}, fail(
 197         'Failed to parse or set cookie named "abcd=efg".',
 198         function() {
 199           chrome.cookies.get({url: TEST_URL, name: 'abcd'},
 200               pass(expectNullCookie));
 201         }));
 202     chrome.cookies.set(
 203         {url: TEST_URL, name: 'abcd', value: 'HI;LO'},
 204         fail(
 205           'Failed to parse or set cookie named "abcd".',
 206           function () {
 207             chrome.cookies.get({url: TEST_URL, name: 'abcd'},
 208                 pass(expectNullCookie));
 209           }));
 210     chrome.cookies.set(
 211         {url: TEST_URL, name: 'abcd', domain: 'cookies.com\r'},
 212         fail(
 213           'Failed to parse or set cookie named "abcd".',
 214           function () {
 215             chrome.cookies.get({url: TEST_URL, name: 'abcd'},
 216                 pass(expectNullCookie));
 217           }));
 218     chrome.cookies.set(
 219         {url: TEST_URL, name: 'abcd', domain: 'somedomain.com'},
 220         fail(
 221           'Failed to parse or set cookie named "abcd".',
 222           function () {
 223             chrome.cookies.get({url: TEST_URL, name: 'abcd'},
 224                 pass(expectNullCookie));
 225           }));
 226     chrome.cookies.set({
 227       url: TEST_ODD_URL,
 228       name: 'abcd',
 229       domain: TEST_ODD_DOMAIN,
 230       path: TEST_ODD_PATH
 231     }, pass(function () {
 232       chrome.cookies.get({url: TEST_ODD_URL, name: 'abcd'},
 233           pass(function(cookie) {
 234             expectValidCookie(cookie);
 235             chrome.test.assertEq(TEST_ODD_DOMAIN, unescape(cookie.domain));
 236             chrome.test.assertEq(TEST_ODD_PATH, unescape(cookie.path));
 237           }));
 238     }));
 239   },
 240   function setCookiesWithCallbacks() {
 241     removeTestCookies();
 242     // Basics.
 243     chrome.cookies.set(
 244         TEST_BASIC_COOKIE,
 245         pass(function(cookie) {
 246           expectValidCookie(cookie);
 247           chrome.test.assertEq(TEST_BASIC_COOKIE.name, cookie.name);
 248           chrome.test.assertEq(TEST_BASIC_COOKIE.value, cookie.value);
 249           chrome.test.assertEq(TEST_HOST, cookie.domain);
 250           chrome.test.assertEq(true, cookie.hostOnly);
 251           chrome.test.assertEq('/', cookie.path);
 252           chrome.test.assertEq(false, cookie.secure);
 253           chrome.test.assertEq(false, cookie.httpOnly);
 254           chrome.test.assertEq(true, cookie.session);
 255           chrome.test.assertTrue(typeof cookie.expirationDate === 'undefined',
 256               'Session cookie should not have expirationDate property.');
 257           chrome.test.assertTrue(typeof cookie.storeId !== 'undefined',
 258                                  'Cookie store ID not provided.');
 259         }));
 260     // Invalid values generate callback with no arguments, and error messages
 261     chrome.cookies.set(
 262         {url: TEST_UNPERMITTED_URL, name: 'abcd', domain: TEST_DOMAIN},
 263         fail(
 264             'No host permissions for cookies at url: "'
 265                 + TEST_UNPERMITTED_URL + '".',
 266              expectUndefinedCookie));
 267     chrome.cookies.set(
 268         {url: TEST_URL, name: 'abcd=efg'},
 269         fail('Failed to parse or set cookie named "abcd=efg".',
 270              expectUndefinedCookie));
 271     chrome.cookies.set(
 272         {url: TEST_URL, name: 'abcd', value: 'HI;LO'},
 273         fail('Failed to parse or set cookie named "abcd".',
 274              expectUndefinedCookie));
 275     chrome.cookies.set(
 276         {url: TEST_URL, name: 'abcd', domain: 'cookies.com\r'},
 277         fail('Failed to parse or set cookie named "abcd".',
 278              expectUndefinedCookie));
 279     chrome.cookies.set(
 280         {url: TEST_URL, name: 'abcd', domain: 'somedomain.com'},
 281         fail('Failed to parse or set cookie named "abcd".',
 282             expectUndefinedCookie));
 283     // Expired cookies generate callback with "null" cookie
 284     chrome.cookies.set(TEST_BASIC_EXPIRED_COOKIE, pass(expectUndefinedCookie));
 285     // Odd (but valid!) URLs get callbacks too!
 286     chrome.cookies.set({
 287       url: TEST_ODD_URL,
 288       name: 'abcd',
 289       domain: TEST_ODD_DOMAIN,
 290       path: TEST_ODD_PATH
 291     }, pass(function(cookie) {
 292       expectValidCookie(cookie);
 293       chrome.test.assertEq(TEST_ODD_DOMAIN, unescape(cookie.domain));
 294       chrome.test.assertEq(TEST_ODD_PATH, unescape(cookie.path));
 295     }));
 296   },
 297   function removeCookie() {
 298     removeTestCookies();
 299     chrome.cookies.set(TEST_BASIC_COOKIE, pass(function () {
 300       chrome.cookies.get(
 301           {url: TEST_URL, name: TEST_BASIC_COOKIE.name},
 302           pass(function (c) {
 303             expectValidCookie(c);
 304
 305             // Removal with any domain-matching URL will do.
 306             chrome.cookies.remove(
 307                 {url: TEST_URL4, name: TEST_BASIC_COOKIE.name},
 308                 pass(function () {
 309                   chrome.cookies.get(
 310                       {url: TEST_URL, name: TEST_BASIC_COOKIE.name},
 311                       pass(expectNullCookie));
 312                   }));
 313           }));
 314     }));
 315     // Set with an expired date should also remove the cookie.
 316     chrome.cookies.set(TEST_BASIC_COOKIE, pass(function () {
 317       chrome.cookies.get(
 318           {url: TEST_URL, name: TEST_BASIC_COOKIE.name},
 319           pass(expectValidCookie));
 320       chrome.cookies.set(TEST_BASIC_EXPIRED_COOKIE, pass(function () {
 321         chrome.cookies.get(
 322             {url: TEST_URL, name: TEST_BASIC_COOKIE.name},
 323             pass(expectNullCookie));
 324       }));
 325     }));
 326     // Removal with a disallowed URL shouldn't do anything.
 327     chrome.cookies.set(TEST_DOMAIN_COOKIE, pass(function () {
 328       chrome.cookies.get(
 329           {url: TEST_URL2, name: TEST_DOMAIN_COOKIE.name},
 330           pass(function (c) {
 331             expectValidCookie(c);
 332             chrome.cookies.remove(
 333               {url: TEST_UNPERMITTED_URL, name: TEST_DOMAIN_COOKIE.name},
 334               fail(
 335                   'No host permissions for cookies at url: "'
 336                       + TEST_UNPERMITTED_URL + '".',
 337                   function () {
 338                   chrome.cookies.get(
 339                       {url: TEST_URL2, name: TEST_DOMAIN_COOKIE.name},
 340                       pass(expectValidCookie));
 341                   }));
 342               }));
 343     }));
 344   },
 345   function removeCookiesWithCallbacks() {
 346     removeTestCookies();
 347     chrome.cookies.set(TEST_BASIC_COOKIE, pass(function () {
 348       chrome.cookies.get(
 349           {url: TEST_URL, name: TEST_BASIC_COOKIE.name},
 350           pass(expectValidCookie));
 351       // Removal with any domain-matching URL will trigger callback with the
 352       // removed cookie's "url" and "name" fields.
 353       chrome.cookies.remove(
 354           {url: TEST_URL4, name: TEST_BASIC_COOKIE.name},
 355           pass(function(data) {
 356             chrome.test.assertEq(TEST_URL4, data.url);
 357             chrome.test.assertEq(TEST_BASIC_COOKIE.name, data.name);
 358             chrome.test.assertTrue(typeof data.storeId !== 'undefined',
 359                                    'Cookie store ID not provided.');
 360           }));
 361     }));
 362     // Removal with a disallowed URL should trigger the callback with no
 363     // arguments, and a set error message.
 364     chrome.cookies.set(TEST_DOMAIN_COOKIE, pass(function () {
 365       chrome.cookies.remove(
 366           {url: TEST_UNPERMITTED_URL, name: TEST_DOMAIN_COOKIE.name},
 367           fail(
 368               'No host permissions for cookies at url: "'
 369                 + TEST_UNPERMITTED_URL + '".',
 370               expectUndefinedCookie));
 371     }));
 372   },
 373   function getAllCookies() {
 374     removeTestCookies();
 375     chrome.cookies.getAll({}, pass(function(cookies) {
 376       chrome.test.assertEq(0, cookies.length);
 377     }));
 378     chrome.cookies.set(TEST_BASIC_COOKIE, pass(function () {
 379       chrome.cookies.set(TEST_SECURE_COOKIE, pass(function () {
 380         chrome.cookies.getAll(
 381             {domain: TEST_DOMAIN}, pass(function(cookies) {
 382           chrome.test.assertEq(2, cookies.length);
 383           chrome.test.assertEq(TEST_SECURE_COOKIE.name, cookies[0].name);
 384           chrome.test.assertEq(TEST_BASIC_COOKIE.name, cookies[1].name);
 385         }));
 386         chrome.cookies.getAll({
 387           name: TEST_BASIC_COOKIE.name
 388         }, pass(function(cookies) {
 389           chrome.test.assertEq(1, cookies.length);
 390           chrome.test.assertEq(TEST_BASIC_COOKIE.name, cookies[0].name);
 391         }));
 392         chrome.cookies.getAll({
 393           secure: true
 394         }, pass(function(cookies) {
 395           chrome.test.assertEq(1, cookies.length);
 396           chrome.test.assertEq(TEST_SECURE_COOKIE.name, cookies[0].name);
 397         }));
 398         chrome.cookies.getAll({
 399           url: 'invalid url'
 400         }, fail('Invalid url: "invalid url".'));
 401         chrome.cookies.getAll({
 402           url: TEST_URL,
 403         }, pass(function(cookies) {
 404           chrome.test.assertEq(1, cookies.length);
 405           chrome.test.assertEq(TEST_BASIC_COOKIE.name, cookies[0].name);
 406         }));
 407       }));
 408     }));
 409   },
 410   function getAllCookieStores() {
 411     removeTestCookies();
 412     chrome.cookies.getAllCookieStores(
 413         pass(function(cookieStores) {
 414           chrome.test.assertEq(1, cookieStores.length);
 415           chrome.cookies.set(TEST_BASIC_COOKIE, pass(function () {
 416             chrome.cookies.get(
 417                 {url: TEST_URL, name: TEST_BASIC_COOKIE.name},
 418                 pass(function(cookie) {
 419                   chrome.test.assertEq(cookieStores[0].id, cookie.storeId);
 420                 }));
 421             chrome.cookies.getAll(
 422                 {storeId: cookieStores[0].id},
 423                 pass(function(cookies) {
 424                   chrome.test.assertEq(1, cookies.length);
 425                   chrome.test.assertEq(TEST_BASIC_COOKIE.name, cookies[0].name);
 426                 }));
 427           }));
 428         }));
 429   }
 430 ]);