Add in-memory cache for tokens, to avoid CacheService replication issues within the same execution.

Author: Eric Koleda

gulpfile.js

@@ -27,7 +27,7 @@ gulp.task('clean', function() {
 });
 
 gulp.task('lint', function() {
-  return gulp.src('src/*.gs')
+  return gulp.src(['src/*.gs', 'test/**/*.js'])
     .pipe(jshint())
     .pipe(jshint.reporter(stylish));
 });

package.json

@@ -13,7 +13,9 @@
   },
   "homepage": "https://github.com/googlesamples/apps-script-oauth2",
   "devDependencies": {
+    "chai": "^4.1.2",
     "del": "^1.2.1",
+    "gas-local": "^1.3.0",
     "gulp": "^3.9.0",
     "gulp-bump": "^0.3.1",
     "gulp-clean": "^0.3.1",
@@ -24,7 +26,8 @@
     "gulp-rename": "^1.2.2",
     "gulp-strip-line": "0.0.1",
     "jsdoc": "^3.5.5",
-    "jshint-stylish": "^2.0.1"
+    "jshint-stylish": "^2.0.1",
+    "mocha": "^4.0.1"
   },
   "dependencies": {
     "underscore": "^1.8.3"
@@ -33,6 +36,7 @@
     "postversion": "gulp dist",
     "dist": "gulp dist",
     "lint": "gulp lint",
-    "doc": "jsdoc -c jsdoc.json src/*.gs README.md"
+    "doc": "jsdoc -c jsdoc.json src/*.gs README.md",
+    "test": "mocha"
   }
 }

src/Service.gs

@@ -373,11 +373,12 @@ Service_.prototype.reset = function() {
   validate_({
     'Property store': this.propertyStore_
   });
-  var key = this.getPropertyKey_(this.serviceName_);
+  var key = this.getPropertyKey_();
   this.propertyStore_.deleteProperty(key);
   if (this.cache_) {
     this.cache_.remove(key);
   }
+  this.token_ = null;
 };
 
 /**
@@ -504,12 +505,13 @@ Service_.prototype.saveToken_ = function(token) {
   validate_({
     'Property store': this.propertyStore_
   });
-  var key = this.getPropertyKey_(this.serviceName_);
+  var key = this.getPropertyKey_();
   var value = JSON.stringify(token);
   this.propertyStore_.setProperty(key, value);
   if (this.cache_) {
     this.cache_.put(key, value, 21600);
   }
+  this.token_ = token;
 };
 
 /**
@@ -520,22 +522,34 @@ Service_.prototype.getToken = function() {
   validate_({
     'Property store': this.propertyStore_
   });
-  var key = this.getPropertyKey_(this.serviceName_);
-  var token;
-  if (this.cache_) {
-    token = this.cache_.get(key);
+
+  // Check in-memory cache.
+  if (this.token_) {
+    return this.token_;
   }
-  if (!token) {
-    token = this.propertyStore_.getProperty(key);
+
+  var key = this.getPropertyKey_();
+  var token;
+
+  // Check CacheService cache.
+  if (this.cache_ && (token = this.cache_.get(key))) {
+    token = JSON.parse(token);
+    this.token_ = token;
+    return token;
   }
-  if (token) {
+
+  // Check PropertiesService store.
+  if ((token = this.propertyStore_.getProperty(key))) {
     if (this.cache_) {
       this.cache_.put(key, token, 21600);
     }
-    return JSON.parse(token);
-  } else {
-    return null;
+    token = JSON.parse(token);
+    this.token_ = token;
+    return token;
   }
+
+  // Not found.
+  return null;
 };
 
 /**
@@ -544,8 +558,8 @@ Service_.prototype.getToken = function() {
  * @return {string} The property key.
  * @private
  */
-Service_.prototype.getPropertyKey_ = function(serviceName) {
-  return 'oauth2.' + serviceName;
+Service_.prototype.getPropertyKey_ = function() {
+  return 'oauth2.' + this.serviceName_;
 };
 
 /**

test/mocks/cache.js

@@ -0,0 +1,17 @@
+var MockCache = function(opt_store) {
+  this.store = opt_store || {};
+};
+
+MockCache.prototype.get = function(key) {
+  return this.store[key];
+};
+
+MockCache.prototype.put = function(key, value) {
+  this.store[key] = value;
+};
+
+MockCache.prototype.remove = function(key) {
+  delete this.store[key];
+};
+
+module.exports = MockCache;

test/mocks/properties.js

@@ -0,0 +1,17 @@
+var MockProperties = function() {
+  this.store = {};
+};
+
+MockProperties.prototype.getProperty = function(key) {
+  return this.store[key];
+};
+
+MockProperties.prototype.setProperty = function(key, value) {
+  this.store[key] = value;
+};
+
+MockProperties.prototype.deleteProperty = function(key) {
+  delete this.store[key];
+};
+
+module.exports = MockProperties;

test/test.js

@@ -0,0 +1,118 @@
+var assert = require('chai').assert;
+var _ = require('underscore');
+var gas = require('gas-local');
+var MockProperties = require('./mocks/properties');
+var MockCache = require('./mocks/cache');
+
+var mocks = {
+  Underscore: {
+    load: function() {
+      return _;
+    }
+  },
+  ScriptApp: {
+    getScriptId: function() {
+      return '12345';
+    }
+  }
+};
+var options = {
+  filter: function(f) {
+    return true;
+  }
+};
+var OAuth2 = gas.require('./src', mocks, options);
+
+
+describe('Service', function() {
+  describe('#getToken()', function() {
+    it('should load from the in-memory store', function() {
+      var service = OAuth2.createService('test')
+        .setPropertyStore(new MockProperties())
+        .setCache(new MockCache());
+      var token = {
+        access_token: 'foo'
+      };
+      service.token_ = token;
+
+      assert.deepEqual(service.getToken(), token);
+    });
+
+    it('should load from the cache and set the in-memory store', function() {
+      var cache = new MockCache();
+      var service = OAuth2.createService('test')
+        .setPropertyStore(new MockProperties())
+        .setCache(cache);
+      var token = {
+        access_token: 'foo'
+      };
+      cache.put(service.getPropertyKey_(), JSON.stringify(token));
+
+      assert.notExists(service.token_);
+      assert.deepEqual(service.getToken(), token);
+      assert.deepEqual(service.token_, token);
+    });
+
+    it('should load from the properties and set the cache and in-memory store', function() {
+      var cache = new MockCache();
+      var properties = new MockProperties();
+      var service = OAuth2.createService('test')
+        .setPropertyStore(properties)
+        .setCache(cache);
+      var token = {
+        access_token: 'foo'
+      };
+      var key = service.getPropertyKey_();
+      properties.setProperty(key, JSON.stringify(token));
+
+
+      assert.notExists(service.token_);
+      assert.deepEqual(service.getToken(), token);
+      assert.deepEqual(service.token_, token);
+      assert.deepEqual(JSON.parse(cache.get(key)), token);
+    });
+  });
+
+  describe('#saveToken_()', function() {
+    it('should save the token to the properties, cache, and in-memory store', function() {
+      var cache = new MockCache();
+      var properties = new MockProperties();
+      var service = OAuth2.createService('test')
+        .setPropertyStore(properties)
+        .setCache(cache);
+      var token = {
+        access_token: 'foo'
+      };
+
+      service.saveToken_(token);
+
+      var key = service.getPropertyKey_();
+      assert.deepEqual(service.token_, token);
+      assert.deepEqual(JSON.parse(cache.get(key)), token);
+      assert.deepEqual(JSON.parse(properties.getProperty(key)), token);
+    });
+  });
+
+  describe('#reset()', function() {
+    it('should delete the token from properties, cache, and in-memory store', function() {
+      var cache = new MockCache();
+      var properties = new MockProperties();
+      var service = OAuth2.createService('test')
+        .setPropertyStore(properties)
+        .setCache(cache);
+      var token = {
+        access_token: 'foo'
+      };
+      var key = service.getPropertyKey_();
+      properties.setProperty(key, JSON.stringify(token));
+      cache.put(key, JSON.stringify(token));
+      service.token_ = token;
+
+      service.reset();
+
+      assert.notExists(service.token_);
+      assert.notExists(cache.get(key));
+      assert.notExists(properties.getProperty(key));
+    });
+  });
+});