tough-cookie 0.12.1 → 0.13.0

package/lib/memstore.js

@@ -1,8 +1,38 @@
+/*!
+ * Copyright (c) 2015, Salesforce.com, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of Salesforce.com nor the names of its contributors may
+ * be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
 'use strict';
 var tough = require('./cookie');
 var Store = require('./store').Store;
 var permuteDomain = tough.permuteDomain;
-var permutePath = tough.permutePath;
+var pathMatch = tough.pathMatch;
 var util = require('util');
 
 function MemoryCookieStore() {
@@ -37,7 +67,7 @@ MemoryCookieStore.prototype.findCookies = function(domain, path, cb) {
 
   var pathMatcher;
   if (!path) {
-    // null or '/' means "all paths"
+    // null means "all paths"
     pathMatcher = function matchAll(domainIndex) {
       for (var curPath in domainIndex) {
         var pathIndex = domainIndex[curPath];
@@ -47,30 +77,20 @@ MemoryCookieStore.prototype.findCookies = function(domain, path, cb) {
       }
     };
 
-  } else if (path === '/') {
-    pathMatcher = function matchSlash(domainIndex) {
-      var pathIndex = domainIndex['/'];
-      if (!pathIndex) {
-        return;
-      }
-      for (var key in pathIndex) {
-        results.push(pathIndex[key]);
-      }
-    };
-
   } else {
-    var paths = permutePath(path) || [path];
     pathMatcher = function matchRFC(domainIndex) {
-      paths.forEach(function(curPath) {
-        var pathIndex = domainIndex[curPath];
-        if (!pathIndex) {
-          return;
-        }
-        for (var key in pathIndex) {
-          results.push(pathIndex[key]);
-        }
-      });
-    };
+       //NOTE: we should use path-match algorithm from S5.1.4 here
+       //(see : https://github.com/ChromiumWebApps/chromium/blob/b3d3b4da8bb94c1b2e061600df106d590fda3620/net/cookies/canonical_cookie.cc#L299)
+       Object.keys(domainIndex).forEach(function (cookiePath) {
+         if (pathMatch(path, cookiePath)) {
+           var pathIndex = domainIndex[cookiePath];
+
+           for (var key in pathIndex) {
+             results.push(pathIndex[key]);
+           }
+         }
+       });
+     };
   }
 
   var domains = permuteDomain(domain) || [domain];

package/lib/pubsuffix.js

@@ -4,25 +4,35 @@
  ****************************************************/
 
 module.exports.getPublicSuffix = function getPublicSuffix(domain) {
-  /*
-   * Copyright GoInstant, Inc. and other contributors. All rights reserved.
-   * Permission is hereby granted, free of charge, to any person obtaining a copy
-   * of this software and associated documentation files (the "Software"), to
-   * deal in the Software without restriction, including without limitation the
-   * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-   * sell copies of the Software, and to permit persons to whom the Software is
-   * furnished to do so, subject to the following conditions:
+  /*!
+   * Copyright (c) 2015, Salesforce.com, Inc.
+   * All rights reserved.
    *
-   * The above copyright notice and this permission notice shall be included in
-   * all copies or substantial portions of the Software.
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
    *
-   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-   * IN THE SOFTWARE.
+   * 1. Redistributions of source code must retain the above copyright notice,
+   * this list of conditions and the following disclaimer.
+   *
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   * this list of conditions and the following disclaimer in the documentation
+   * and/or other materials provided with the distribution.
+   *
+   * 3. Neither the name of Salesforce.com nor the names of its contributors may
+   * be used to endorse or promote products derived from this software without
+   * specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+   * POSSIBILITY OF SUCH DAMAGE.
    */
   if (!domain) return null;
   if (domain.match(/^\./)) return null;

package/lib/store.js

@@ -1,3 +1,33 @@
+/*!
+ * Copyright (c) 2015, Salesforce.com, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of Salesforce.com nor the names of its contributors may
+ * be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
 'use strict';
 /*jshint unused:false */
 

package/package.json

@@ -1,6 +1,6 @@
 {
-  "author": "GoInstant Inc., a salesforce.com company",
-  "license": "MIT",
+  "author": "Jeremy Stashewsky <jstashewsky@salesforce.com>",
+  "license": "BSD-3-Clause",
   "name": "tough-cookie",
   "description": "RFC6265 Cookies and Cookie Jar for node.js",
   "keywords": [
@@ -13,7 +13,7 @@
     "RFC6265",
     "RFC2965"
   ],
-  "version": "0.12.1",
+  "version": "0.13.0",
   "homepage": "https://github.com/goinstant/tough-cookie",
   "repository": {
     "type": "git",
@@ -24,7 +24,7 @@
   },
   "main": "./lib/cookie",
   "scripts": {
-    "test": "vows test.js"
+    "test": "vows test/*_test.js"
   },
   "engines": {
     "node": ">=0.4.12"

package/test/api_test.js

@@ -0,0 +1,388 @@
+/*!
+ * Copyright (c) 2015, Salesforce.com, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of Salesforce.com nor the names of its contributors may
+ * be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+'use strict';
+var vows = require('vows');
+var assert = require('assert');
+var async = require('async');
+var tough = require('../lib/cookie');
+var Cookie = tough.Cookie;
+var CookieJar = tough.CookieJar;
+
+
+var atNow = Date.now();
+
+function at(offset) {
+  return {now: new Date(atNow + offset)};
+}
+
+vows
+  .describe('API')
+  .addBatch({
+    "All defined": function () {
+      assert.ok(Cookie);
+      assert.ok(CookieJar);
+    }
+  })
+  .addBatch({
+    "Constructor": {
+      topic: function () {
+        return new Cookie({
+          key: 'test',
+          value: 'b',
+          maxAge: 60
+        });
+      },
+      'check for key property': function (c) {
+        assert.ok(c);
+        assert.equal(c.key, 'test');
+      },
+      'check for value property': function (c) {
+        assert.equal(c.value, 'b');
+      },
+      'check for maxAge': function (c) {
+        assert.equal(c.maxAge, 60);
+      },
+      'check for default values for unspecified properties': function (c) {
+        assert.equal(c.expires, "Infinity");
+        assert.equal(c.secure, false);
+        assert.equal(c.httpOnly, false);
+      }
+    }
+  })
+  .addBatch({
+    "expiry option": {
+      topic: function () {
+        var cb = this.callback;
+        var cj = new CookieJar();
+        cj.setCookie('near=expiry; Domain=example.com; Path=/; Max-Age=1', 'http://www.example.com', at(-1), function (err, cookie) {
+
+          cb(err, {cj: cj, cookie: cookie});
+        });
+      },
+      "set the cookie": function (t) {
+        assert.ok(t.cookie, "didn't set?!");
+        assert.equal(t.cookie.key, 'near');
+      },
+      "then, retrieving": {
+        topic: function (t) {
+          var cb = this.callback;
+          setTimeout(function () {
+            t.cj.getCookies('http://www.example.com', {http: true, expire: false}, function (err, cookies) {
+              t.cookies = cookies;
+              cb(err, t);
+            });
+          }, 2000);
+        },
+        "got the cookie": function (t) {
+          assert.lengthOf(t.cookies, 1);
+          assert.equal(t.cookies[0].key, 'near');
+        }
+      }
+    }
+  })
+  .addBatch({
+    "allPaths option": {
+      topic: function () {
+        var cj = new CookieJar();
+        var tasks = [];
+        tasks.push(cj.setCookie.bind(cj, 'nopath_dom=qq; Path=/; Domain=example.com', 'http://example.com', {}));
+        tasks.push(cj.setCookie.bind(cj, 'path_dom=qq; Path=/foo; Domain=example.com', 'http://example.com', {}));
+        tasks.push(cj.setCookie.bind(cj, 'nopath_host=qq; Path=/', 'http://www.example.com', {}));
+        tasks.push(cj.setCookie.bind(cj, 'path_host=qq; Path=/foo', 'http://www.example.com', {}));
+        tasks.push(cj.setCookie.bind(cj, 'other=qq; Path=/', 'http://other.example.com/', {}));
+        tasks.push(cj.setCookie.bind(cj, 'other2=qq; Path=/foo', 'http://other.example.com/foo', {}));
+        var cb = this.callback;
+        async.parallel(tasks, function (err, results) {
+          cb(err, {cj: cj, cookies: results});
+        });
+      },
+      "all set": function (t) {
+        assert.equal(t.cookies.length, 6);
+        assert.ok(t.cookies.every(function (c) {
+          return !!c
+        }));
+      },
+      "getting without allPaths": {
+        topic: function (t) {
+          var cb = this.callback;
+          var cj = t.cj;
+          cj.getCookies('http://www.example.com/', {}, function (err, cookies) {
+            cb(err, {cj: cj, cookies: cookies});
+          });
+        },
+        "found just two cookies": function (t) {
+          assert.equal(t.cookies.length, 2);
+        },
+        "all are path=/": function (t) {
+          assert.ok(t.cookies.every(function (c) {
+            return c.path === '/'
+          }));
+        },
+        "no 'other' cookies": function (t) {
+          assert.ok(!t.cookies.some(function (c) {
+            return (/^other/).test(c.name)
+          }));
+        }
+      },
+      "getting without allPaths for /foo": {
+        topic: function (t) {
+          var cb = this.callback;
+          var cj = t.cj;
+          cj.getCookies('http://www.example.com/foo', {}, function (err, cookies) {
+            cb(err, {cj: cj, cookies: cookies});
+          });
+        },
+        "found four cookies": function (t) {
+          assert.equal(t.cookies.length, 4);
+        },
+        "no 'other' cookies": function (t) {
+          assert.ok(!t.cookies.some(function (c) {
+            return (/^other/).test(c.name)
+          }));
+        }
+      },
+      "getting with allPaths:true": {
+        topic: function (t) {
+          var cb = this.callback;
+          var cj = t.cj;
+          cj.getCookies('http://www.example.com/', {allPaths: true}, function (err, cookies) {
+            cb(err, {cj: cj, cookies: cookies});
+          });
+        },
+        "found four cookies": function (t) {
+          assert.equal(t.cookies.length, 4);
+        },
+        "no 'other' cookies": function (t) {
+          assert.ok(!t.cookies.some(function (c) {
+            return (/^other/).test(c.name)
+          }));
+        }
+      }
+    }
+  })
+  .addBatch({
+    "Remove cookies": {
+      topic: function () {
+        var jar = new CookieJar();
+        var cookie = Cookie.parse("a=b; Domain=example.com; Path=/");
+        var cookie2 = Cookie.parse("a=b; Domain=foo.com; Path=/");
+        var cookie3 = Cookie.parse("foo=bar; Domain=foo.com; Path=/");
+        jar.setCookie(cookie, 'http://example.com/index.html', function () {
+        });
+        jar.setCookie(cookie2, 'http://foo.com/index.html', function () {
+        });
+        jar.setCookie(cookie3, 'http://foo.com/index.html', function () {
+        });
+        return jar;
+      },
+      "all from matching domain": function (jar) {
+        jar.store.removeCookies('example.com', null, function (err) {
+          assert(err == null);
+
+          jar.store.findCookies('example.com', null, function (err, cookies) {
+            assert(err == null);
+            assert(cookies != null);
+            assert(cookies.length === 0, 'cookie was not removed');
+          });
+
+          jar.store.findCookies('foo.com', null, function (err, cookies) {
+            assert(err == null);
+            assert(cookies != null);
+            assert(cookies.length === 2, 'cookies should not have been removed');
+          });
+        });
+      },
+      "from cookie store matching domain and key": function (jar) {
+        jar.store.removeCookie('foo.com', '/', 'foo', function (err) {
+          assert(err == null);
+
+          jar.store.findCookies('foo.com', null, function (err, cookies) {
+            assert(err == null);
+            assert(cookies != null);
+            assert(cookies.length === 1, 'cookie was not removed correctly');
+            assert(cookies[0].key === 'a', 'wrong cookie was removed');
+          });
+        });
+      }
+    }
+  })
+  .addBatch({
+    "Synchronous CookieJar": {
+      "setCookieSync": {
+        topic: function () {
+          var jar = new CookieJar();
+          var cookie = Cookie.parse("a=b; Domain=example.com; Path=/");
+          cookie = jar.setCookieSync(cookie, 'http://example.com/index.html');
+          return cookie;
+        },
+        "returns a copy of the cookie": function (cookie) {
+          assert.instanceOf(cookie, Cookie);
+        }
+      },
+      "setCookieSync strict parse error": {
+        topic: function () {
+          var jar = new CookieJar();
+          var opts = {strict: true};
+          try {
+            jar.setCookieSync("farbe=weiß", 'http://example.com/index.html', opts);
+            return false;
+          } catch (e) {
+            return e;
+          }
+        },
+        "throws the error": function (err) {
+          assert.instanceOf(err, Error);
+          assert.equal(err.message, "Cookie failed to parse");
+        }
+      },
+      "getCookiesSync": {
+        topic: function () {
+          var jar = new CookieJar();
+          var url = 'http://example.com/index.html';
+          jar.setCookieSync("a=b; Domain=example.com; Path=/", url);
+          jar.setCookieSync("c=d; Domain=example.com; Path=/", url);
+          return jar.getCookiesSync(url);
+        },
+        "returns the cookie array": function (err, cookies) {
+          assert.ok(!err);
+          assert.ok(Array.isArray(cookies));
+          assert.lengthOf(cookies, 2);
+          cookies.forEach(function (cookie) {
+            assert.instanceOf(cookie, Cookie);
+          });
+        }
+      },
+
+      "getCookieStringSync": {
+        topic: function () {
+          var jar = new CookieJar();
+          var url = 'http://example.com/index.html';
+          jar.setCookieSync("a=b; Domain=example.com; Path=/", url);
+          jar.setCookieSync("c=d; Domain=example.com; Path=/", url);
+          return jar.getCookieStringSync(url);
+        },
+        "returns the cookie header string": function (err, str) {
+          assert.ok(!err);
+          assert.typeOf(str, 'string');
+        }
+      },
+
+      "getSetCookieStringsSync": {
+        topic: function () {
+          var jar = new CookieJar();
+          var url = 'http://example.com/index.html';
+          jar.setCookieSync("a=b; Domain=example.com; Path=/", url);
+          jar.setCookieSync("c=d; Domain=example.com; Path=/", url);
+          return jar.getSetCookieStringsSync(url);
+        },
+        "returns the cookie header string": function (err, headers) {
+          assert.ok(!err);
+          assert.ok(Array.isArray(headers));
+          assert.lengthOf(headers, 2);
+          headers.forEach(function (header) {
+            assert.typeOf(header, 'string');
+          });
+        }
+      }
+    }
+  })
+  .addBatch({
+    "Synchronous API on async CookieJar": {
+      topic: function () {
+        return new tough.Store();
+      },
+      "setCookieSync": {
+        topic: function (store) {
+          var jar = new CookieJar(store);
+          try {
+            jar.setCookieSync("a=b", 'http://example.com/index.html');
+            return false;
+          } catch (e) {
+            return e;
+          }
+        },
+        "fails": function (err) {
+          assert.instanceOf(err, Error);
+          assert.equal(err.message,
+            'CookieJar store is not synchronous; use async API instead.');
+        }
+      },
+      "getCookiesSync": {
+        topic: function (store) {
+          var jar = new CookieJar(store);
+          try {
+            jar.getCookiesSync('http://example.com/index.html');
+            return false;
+          } catch (e) {
+            return e;
+          }
+        },
+        "fails": function (err) {
+          assert.instanceOf(err, Error);
+          assert.equal(err.message,
+            'CookieJar store is not synchronous; use async API instead.');
+        }
+      },
+      "getCookieStringSync": {
+        topic: function (store) {
+          var jar = new CookieJar(store);
+          try {
+            jar.getCookieStringSync('http://example.com/index.html');
+            return false;
+          } catch (e) {
+            return e;
+          }
+        },
+        "fails": function (err) {
+          assert.instanceOf(err, Error);
+          assert.equal(err.message,
+            'CookieJar store is not synchronous; use async API instead.');
+        }
+      },
+      "getSetCookieStringsSync": {
+        topic: function (store) {
+          var jar = new CookieJar(store);
+          try {
+            jar.getSetCookieStringsSync('http://example.com/index.html');
+            return false;
+          } catch (e) {
+            return e;
+          }
+        },
+        "fails": function (err) {
+          assert.instanceOf(err, Error);
+          assert.equal(err.message,
+            'CookieJar store is not synchronous; use async API instead.');
+        }
+      }
+    }
+  })
+  .export(module);