Promote stopExpiringSessions to public API method (#66)

* docs(readme): promote `stopExpiringSessions` to public API method
* test: use `stopExpiringSessions` instead of negative interval
* test: #stopExpiringSessions
* docs(readme): add missing syntax highlighting to other snippets
* chore: add `after`, `afterEach` to global pragma for linter

Author: glebec

README.md

@@ -61,22 +61,22 @@ app.use(session({
   store: new SequelizeStore({
     db: sequelize
   }),
-  resave: false, // we support the touch method so per the express-session docs this should be set to false 
+  resave: false, // we support the touch method so per the express-session docs this should be set to false
   proxy: true // if you do SSL outside of node.
 }))
 // continue as normal
 ```
 
 If you want SequelizeStore to create/sync the database table for you, you can call `sync()` against an instance of `SequelizeStore` - this will run a sequelize `sync()` operation on the model for an initialized SequelizeStore object:
 
-```
+```javascript
 var myStore = new SequelizeStore({
     db: sequelize
-}) 
+})
 app.use(session({
     secret: 'keyboard cat',
     store: myStore,
-    resave: false, 
+    resave: false,
     proxy: true
 }))
 
@@ -87,14 +87,30 @@ myStore.sync();
 
 Session records are automatically expired and removed from the database on an interval. The `cookie.expires` property is used to set session expiry time. If that property doesn't exist, a default expiry of 24 hours is used. Expired session are removed from the database every 15 minutes by default. That interval as well as the default expiry time can be set as store options:
 
-```
+```javascript
 new SequelizeStore({
   ...
   checkExpirationInterval: 15 * 60 * 1000, // The interval at which to cleanup expired sessions in milliseconds.
   expiration: 24 * 60 * 60 * 1000  // The maximum age (in milliseconds) of a valid session.
 });
 ```
 
+## Expiration interval cleanup: `stopExpiringSessions`
+
+As expirations are checked on an interval timer, `connect-session-sequelize` can keep your process from exiting. This can be problematic e.g. in testing when it is known that the application code will no longer be used, but the test script never terminates. If you know that the process will no longer be used, you can manually clean up the interval by calling the `stopExpiringSessions` method:
+
+```js
+// assuming you have set up a typical session store, for example:
+var myStore = new SequelizeStore({
+  db: sequelize
+});
+
+// you can stop expiring sessions (cancel the interval). Example using Mocha:
+after('clean up resources', () => {
+  myStore.stopExpiringSessions();
+});
+```
+
 # Add custom field(s) as a column
 
 The `extendDefaultFields` can be used to add custom fields to the session table. These fields will be read-only as they will be inserted only when the session is first created as `defaults`. Make sure to return an object which contains unmodified `data` and `expires` properties, or else the module functionality will be broken:

lib/connect-session-sequelize.js

@@ -158,6 +158,8 @@ module.exports = function SequelizeSessionInit (Store) {
   SequelizeStore.prototype.stopExpiringSessions = function stopExpiringSessions () {
     if (this._expirationInterval) {
       clearInterval(this._expirationInterval)
+      // added as a sanity check for testing
+      this._expirationInterval = null
     }
   }
 

test/test.js

@@ -1,4 +1,4 @@
-/* global describe,before,beforeEach,it */
+/* global describe,before,beforeEach,after,afterEach,it */
 
 var assert = require('assert')
 var session = require('express-session')
@@ -14,12 +14,16 @@ var db = new Sequelize('session_test', 'test', '12345', {
 })
 var store = new SequelizeStore({
   db: db,
-  // disable expiration interval otherwise tests don't finish
-  checkExpirationInterval: -1
+  // the expiration check interval is removed up in an `after` block
+  checkExpirationInterval: 100
 })
 var sessionId = '1234a'
 var sessionData = {foo: 'bar', 'baz': 42}
 
+after('clean up resources, allowing tests to terminate', function () {
+  store.stopExpiringSessions()
+})
+
 describe('store', function () {
   before(function () {
     return store.sync()
@@ -217,3 +221,29 @@ describe('#clearExpiredSessions()', function () {
     })
   })
 })
+
+describe('#stopExpiringSessions()', function () {
+  var store
+  beforeEach(function () {
+    var db = new Sequelize(
+      'session_test',
+      'test',
+      '12345',
+      { dialect: 'sqlite', logging: false }
+    )
+    db.import(path.join(__dirname, 'resources/model'))
+    store = new SequelizeStore({
+      db: db,
+      table: 'TestSession',
+      checkExpirationInterval: 100
+    })
+  })
+  afterEach('clean up resources', function () {
+    store.stopExpiringSessions()
+  })
+  it('should cancel the session check timer', function () {
+    assert.ok(store._expirationInterval, 'missing timeout object')
+    store.stopExpiringSessions()
+    assert.equal(store._expirationInterval, null, 'expiration interval not nullified')
+  })
+})