Release 2.3.0

Upgrades cartodb-redis for `global` map stats

.jshintignore

@@ -0,0 +1,4 @@
+test/results/
+test/monkey/
+test/benchmark.js
+test/support/

Makefile

@@ -29,7 +29,7 @@ test: config/environments/test.js
 
 jshint:
 	@echo "***jshint***"
-	@./node_modules/.bin/jshint lib/ app.js
+	@./node_modules/.bin/jshint lib/ test/ app.js
 
 test-all: jshint test
 

NEWS.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 2.3.0
+
+Released 2015-05-18
+
+Announcements:
+ - Upgrades cartodb-redis for `global` map stats
+
+
+## 2.2.0
+
+Released 2015-04-29
+
+Enhancements:
+ - jshint is run against tests
+ - tests moved to mocha's `describe`
+
+New features:
+ - Fastly surrogate keys invalidation for named maps
+   * **New configuration entry**: `fastly`. Check example configurations for more information.
+ - `PgQueryRunner` extracted from `QueryTablesApi` so it can be reused in new `TablesExtentApi`
+ - New top level element, `view`, in templates that holds attributes to identify the map scene.
+ - Named maps static preview in /api/v1/map/static/named/:name/:width/:height.:format endpoint
+   * It will be invalidated if the named map changes
+   * But have a Cache-Control header with a 2 hours max-age, won't be invalidated on data changes
+
+
+## 2.1.3
+
+Released 2015-04-16
+
+Announcements:
+ - Upgrades windshaft to [0.42.2](https://github.com/CartoDB/Windshaft/releases/tag/0.42.2)
+
+
 ## 2.1.2
 
 Released 2015-04-15

config/environments/development.js.example

@@ -131,6 +131,7 @@ var config = {
           timeout: 2000, // the timeout in ms for a http tile request
           proxy: undefined, // the url for a proxy server
           whitelist: [ // the whitelist of urlTemplates that can be used
+              '.*', // will enable any URL
               'http://{s}.example.com/{z}/{x}/{y}.png'
           ],
           // image to use as placeholder when urlTemplate is not in the whitelist
@@ -180,6 +181,15 @@ var config = {
         ttl: 86400,
         layergroupTtl: 86400 // the max-age for cache-control header in layergroup responses
     }
+    // this [OPTIONAL] configuration enables invalidating by surrogate key in fastly
+    ,fastly: {
+        // whether the invalidation is enabled or not
+        enabled: false,
+        // the fastly api key
+        apiKey: 'wadus_api_key',
+        // the service that will get surrogate key invalidation
+        serviceId: 'wadus_service_id'
+    }
     // If useProfiler is true every response will be served with an
     // X-Tiler-Profile header containing elapsed timing for various 
     // steps taken for producing the response.

config/environments/production.js.example

@@ -125,6 +125,7 @@ var config = {
           timeout: 2000, // the timeout in ms for a http tile request
           proxy: undefined, // the url for a proxy server
           whitelist: [ // the whitelist of urlTemplates that can be used
+              '.*', // will enable any URL
               'http://{s}.example.com/{z}/{x}/{y}.png'
           ],
           // image to use as placeholder when urlTemplate is not in the whitelist
@@ -174,6 +175,15 @@ var config = {
         ttl: 86400,
         layergroupTtl: 86400 // the max-age for cache-control header in layergroup responses
     }
+    // this [OPTIONAL] configuration enables invalidating by surrogate key in fastly
+    ,fastly: {
+        // whether the invalidation is enabled or not
+        enabled: false,
+        // the fastly api key
+        apiKey: 'wadus_api_key',
+        // the service that will get surrogate key invalidation
+        serviceId: 'wadus_service_id'
+    }
     // If useProfiler is true every response will be served with an
     // X-Tiler-Profile header containing elapsed timing for various 
     // steps taken for producing the response.

config/environments/staging.js.example

@@ -125,6 +125,7 @@ var config = {
           timeout: 2000, // the timeout in ms for a http tile request
           proxy: undefined, // the url for a proxy server
           whitelist: [ // the whitelist of urlTemplates that can be used
+              '.*', // will enable any URL
               'http://{s}.example.com/{z}/{x}/{y}.png'
           ],
           // image to use as placeholder when urlTemplate is not in the whitelist
@@ -174,6 +175,15 @@ var config = {
         ttl: 86400,
         layergroupTtl: 86400 // the max-age for cache-control header in layergroup responses
     }
+    // this [OPTIONAL] configuration enables invalidating by surrogate key in fastly
+    ,fastly: {
+        // whether the invalidation is enabled or not
+        enabled: false,
+        // the fastly api key
+        apiKey: 'wadus_api_key',
+        // the service that will get surrogate key invalidation
+        serviceId: 'wadus_service_id'
+    }
     // If useProfiler is true every response will be served with an
     // X-Tiler-Profile header containing elapsed timing for various 
     // steps taken for producing the response.

config/environments/test.js.example

@@ -125,6 +125,7 @@ var config = {
           timeout: 2000, // the timeout in ms for a http tile request
           proxy: undefined, // the url for a proxy server
           whitelist: [ // the whitelist of urlTemplates that can be used
+              '.*', // will enable any URL
               'http://{s}.example.com/{z}/{x}/{y}.png',
               // for testing purposes
               'http://{s}.basemaps.cartocdn.com/dark_nolabels/{z}/{x}/{y}.png'
@@ -176,6 +177,15 @@ var config = {
         ttl: 86400,
         layergroupTtl: 86400 // the max-age for cache-control header in layergroup responses
     }
+    // this [OPTIONAL] configuration enables invalidating by surrogate key in fastly
+    ,fastly: {
+        // whether the invalidation is enabled or not
+        enabled: false,
+        // the fastly api key
+        apiKey: 'wadus_api_key',
+        // the service that will get surrogate key invalidation
+        serviceId: 'wadus_service_id'
+    }
     // If useProfiler is true every response will be served with an
     // X-Tiler-Profile header containing elapsed timing for various 
     // steps taken for producing the response.

docs/Map-API.md

@@ -812,7 +812,7 @@ For this map, the multiple layers, order, and stylings are defined by the MapCon
 
 ```javascript
 {
-  "version": "1.3.0-alpha",
+  "version": "1.3.0",
   "layers": [
     {
       "type": "http",

lib/cartodb/api/query_tables_api.js

@@ -1,9 +1,5 @@
-var PSQL = require('cartodb-psql');
-var step = require('step');
-
-function QueryTablesApi(pgConnection, metadataBackend) {
-    this.pgConnection = pgConnection;
-    this.metadataBackend = metadataBackend;
+function QueryTablesApi(pgQueryRunner) {
+    this.pgQueryRunner = pgQueryRunner;
 }
 
 var affectedTableRegexCache = {
@@ -20,7 +16,7 @@ QueryTablesApi.prototype.getAffectedTablesInQuery = function (username, sql, cal
 
     var query = 'SELECT CDB_QueryTables($windshaft$' + prepareSql(sql) + '$windshaft$)';
 
-    this.runQuery(username, query, handleAffectedTablesInQueryRows, callback);
+    this.pgQueryRunner.run(username, query, handleAffectedTablesInQueryRows, callback);
 };
 
 function handleAffectedTablesInQueryRows(err, rows, callback) {
@@ -46,7 +42,7 @@ QueryTablesApi.prototype.getAffectedTablesAndLastUpdatedTime = function (usernam
         'WHERE m.tabname = any ((SELECT tablenames from querytables)::regclass[])'
     ].join(' ');
 
-    this.runQuery(username, query, handleAffectedTablesAndLastUpdatedTimeRows, callback);
+    this.pgQueryRunner.run(username, query, handleAffectedTablesAndLastUpdatedTimeRows, callback);
 };
 
 function handleAffectedTablesAndLastUpdatedTimeRows(err, rows, callback) {
@@ -69,43 +65,6 @@ function handleAffectedTablesAndLastUpdatedTimeRows(err, rows, callback) {
     });
 }
 
-
-QueryTablesApi.prototype.runQuery = function(username, query, queryHandler, callback) {
-    var self = this;
-
-    var params = {};
-
-    step(
-        function setAuth() {
-            self.pgConnection.setDBAuth(username, params, this);
-        },
-        function setConn(err) {
-            if (err) {
-                throw err;
-            }
-            self.pgConnection.setDBConn(username, params, this);
-        },
-        function executeQuery(err) {
-            if (err) {
-                throw err;
-            }
-            var psql = new PSQL({
-                user: params.dbuser,
-                pass: params.dbpass,
-                host: params.dbhost,
-                port: params.dbport,
-                dbname: params.dbname
-            });
-            psql.query(query, function(err, resultSet) {
-                resultSet = resultSet || {};
-                var rows = resultSet.rows || [];
-                queryHandler(err, rows, callback);
-            });
-        }
-    );
-};
-
-
 function prepareSql(sql) {
     return sql
         .replace(affectedTableRegexCache.bbox, 'ST_MakeEnvelope(0,0,0,0)')

lib/cartodb/api/tables_extent_api.js

@@ -0,0 +1,54 @@
+function TablesExtentApi(pgQueryRunner) {
+    this.pgQueryRunner = pgQueryRunner;
+}
+
+module.exports = TablesExtentApi;
+
+/**
+ * Given a username and a list of tables it will return the estimated extent in SRID 4326 for all the tables based on
+ * the_geom_webmercator (SRID 3857) column.
+ *
+ * @param {String} username
+ * @param {Array} tableNames The named can be schema qualified, so this accepts both `schema_name.table_name` and
+ *  `table_name` format as valid input
+ * @param {Function} callback function(err, result) {Object} result with `west`, `south`, `east`, `north`
+ */
+TablesExtentApi.prototype.getBounds = function (username, tableNames, callback) {
+    var estimatedExtentSQLs = tableNames.map(function(tableName) {
+        var schemaTable = tableName.split('.');
+        if (schemaTable.length > 1) {
+            return "ST_EstimatedExtent('" + schemaTable[0] + "', '" + schemaTable[1] + "', 'the_geom_webmercator')";
+        }
+        return "ST_EstimatedExtent('" + schemaTable[0] + "', 'the_geom_webmercator')";
+    });
+
+    var query = [
+        "WITH ext as (" +
+            "SELECT ST_Transform(ST_SetSRID(ST_Extent(ST_Union(ARRAY[",
+                estimatedExtentSQLs.join(','),
+            "])), 3857), 4326) geom)",
+        "SELECT",
+            "ST_XMin(geom) west,",
+            "ST_YMin(geom) south,",
+            "ST_XMax(geom) east,",
+            "ST_YMax(geom) north",
+        "FROM ext"
+    ].join(' ');
+
+    this.pgQueryRunner.run(username, query, handleBoundsResult, callback);
+};
+
+function handleBoundsResult(err, rows, callback) {
+    if (err){
+        var msg = err.message ? err.message : err;
+        callback(new Error('could not fetch source tables: ' + msg));
+        return;
+    }
+    var result = null;
+    if (rows.length > 0) {
+        result = {
+            bounds: rows[0]
+        };
+    }
+    callback(null, result);
+}

lib/cartodb/backends/pg_query_runner.js

@@ -0,0 +1,44 @@
+var PSQL = require('cartodb-psql');
+var step = require('step');
+
+function PgQueryRunner(pgConnection) {
+    this.pgConnection = pgConnection;
+}
+
+module.exports = PgQueryRunner;
+
+
+PgQueryRunner.prototype.run = function(username, query, queryHandler, callback) {
+    var self = this;
+
+    var params = {};
+
+    step(
+        function setAuth() {
+            self.pgConnection.setDBAuth(username, params, this);
+        },
+        function setConn(err) {
+            if (err) {
+                throw err;
+            }
+            self.pgConnection.setDBConn(username, params, this);
+        },
+        function executeQuery(err) {
+            if (err) {
+                throw err;
+            }
+            var psql = new PSQL({
+                user: params.dbuser,
+                pass: params.dbpass,
+                host: params.dbhost,
+                port: params.dbport,
+                dbname: params.dbname
+            });
+            psql.query(query, function(err, resultSet) {
+                resultSet = resultSet || {};
+                var rows = resultSet.rows || [];
+                queryHandler(err, rows, callback);
+            });
+        }
+    );
+};

lib/cartodb/cache/backend/fastly.js

@@ -0,0 +1,18 @@
+var FastlyPurge = require('fastly-purge');
+
+function FastlyCacheBackend(apiKey, serviceId, softPurge) {
+    this.serviceId = serviceId;
+    this.fastlyPurge = new FastlyPurge(apiKey, { softPurge: softPurge || true });
+}
+
+module.exports = FastlyCacheBackend;
+
+/**
+ * @param cacheObject should respond to `key() -> String` method
+ * @param {Function} callback
+ */
+FastlyCacheBackend.prototype.invalidate = function(cacheObject, callback) {
+    this.fastlyPurge.key(this.serviceId, cacheObject.key(), callback);
+};
+
+module.exports = FastlyCacheBackend;

lib/cartodb/cache/surrogate_keys_cache.js

@@ -1,9 +1,11 @@
+var queue = require('queue-async');
+
 /**
- * @param cacheBackend should respond to `invalidate(cacheObject, callback)` method
+ * @param {Array|Object} cacheBackends each backend backend should respond to `invalidate(cacheObject, callback)` method
  * @constructor
  */
-function SurrogateKeysCache(cacheBackend) {
-    this.cacheBackend = cacheBackend;
+function SurrogateKeysCache(cacheBackends) {
+    this.cacheBackends = Array.isArray(cacheBackends) ? cacheBackends : [cacheBackends];
 }
 
 module.exports = SurrogateKeysCache;
@@ -22,5 +24,18 @@ SurrogateKeysCache.prototype.tag = function(response, cacheObject) {
  * @param {Function} callback
  */
 SurrogateKeysCache.prototype.invalidate = function(cacheObject, callback) {
-    this.cacheBackend.invalidate(cacheObject, callback);
+    var invalidationQueue = queue(this.cacheBackends.length);
+
+    this.cacheBackends.forEach(function(cacheBackend) {
+        invalidationQueue.defer(function(cacheBackend, done) {
+            cacheBackend.invalidate(cacheObject, done);
+        }, cacheBackend);
+    });
+
+    invalidationQueue.awaitAll(function(err, result) {
+        if (err) {
+            return callback(err);
+        }
+        callback(null, result);
+    });
 };

lib/cartodb/cartodb_windshaft.js

@@ -4,6 +4,11 @@ var Windshaft = require('windshaft');
 var os = require('os');
 var HealthCheck = require('./monitoring/health_check');
 
+var SurrogateKeysCache = require('./cache/surrogate_keys_cache');
+var NamedMapsCacheEntry = require('./cache/model/named_maps_entry');
+var VarnishHttpCacheBackend = require('./cache/backend/varnish_http');
+var FastlyCacheBackend = require('./cache/backend/fastly');
+
 if ( ! process.env.PGAPPNAME )
   process.env.PGAPPNAME='cartodb_tiler';
 
@@ -30,28 +35,41 @@ var CartodbWindshaft = function(serverOptions) {
     //
     var template_baseurl = global.environment.base_url_templated || '(?:/maps/named|/tiles/template)';
 
-    var SurrogateKeysCache = require('./cache/surrogate_keys_cache'),
-        NamedMapsCacheEntry = require('./cache/model/named_maps_entry'),
-        VarnishHttpCacheBackend = require('./cache/backend/varnish_http'),
-        varnishHttpCacheBackend = new VarnishHttpCacheBackend(
-            serverOptions.varnish_host,
-            serverOptions.varnish_http_port
-        ),
-        surrogateKeysCache = new SurrogateKeysCache(varnishHttpCacheBackend);
+    var surrogateKeysCacheBackends = [];
+
+    if (serverOptions.varnish_purge_enabled) {
+        surrogateKeysCacheBackends.push(
+            new VarnishHttpCacheBackend(serverOptions.varnish_host, serverOptions.varnish_http_port)
+        );
+    }
+
+    if (!!serverOptions.fastly.enabled && !!serverOptions.fastly.apiKey && !!serverOptions.fastly.serviceId) {
+        surrogateKeysCacheBackends.push(
+            new FastlyCacheBackend(serverOptions.fastly.apiKey, serverOptions.fastly.serviceId)
+        );
+    }
+
+    var surrogateKeysCache = new SurrogateKeysCache(surrogateKeysCacheBackends);
 
     function invalidateNamedMap (owner, templateName) {
+        var startTime = Date.now();
         surrogateKeysCache.invalidate(new NamedMapsCacheEntry(owner, templateName), function(err) {
+            var logMessage = JSON.stringify({
+                username: owner,
+                type: 'named_map_invalidation',
+                elapsed: Date.now() - startTime,
+                error: !!err ? JSON.stringify(err.message) : undefined
+            });
             if (err) {
-                console.warn('Cache: surrogate key invalidation failed');
+                console.warn(logMessage);
+            } else {
+                console.info(logMessage);
             }
         });
     }
-
-    if (serverOptions.varnish_purge_enabled) {
-        ['update', 'delete'].forEach(function(eventType) {
-            templateMaps.on(eventType, invalidateNamedMap);
-        });
-    }
+    ['update', 'delete'].forEach(function(eventType) {
+        templateMaps.on(eventType, invalidateNamedMap);
+    });
 
     // boot
     var ws = new Windshaft.Server(serverOptions);
@@ -72,6 +90,7 @@ var CartodbWindshaft = function(serverOptions) {
       '/version',
       // See https://github.com/CartoDB/Windshaft-cartodb/issues/176
       serverOptions.base_url_mapconfig,
+      serverOptions.base_url_mapconfig + '/static/named/:template_id/:width/:height.:format',
       template_baseurl,
       template_baseurl + '/:template_id',
       template_baseurl + '/:template_id/jsonp'
@@ -139,18 +158,30 @@ var CartodbWindshaft = function(serverOptions) {
      * Routing
      ******************************************************************************************************************/
 
-    var TemplateMapsController = require('./controllers/template_maps'),
-        templateMapsController = new TemplateMapsController(
+    var NamedMapsController = require('./controllers/named_maps'),
+        namedMapsController = new NamedMapsController(
             ws,
             serverOptions,
             templateMaps,
             cartoData,
             template_baseurl,
-            surrogateKeysCache,
-            NamedMapsCacheEntry,
-            serverOptions.pgConnection
+            surrogateKeysCache
         );
-    templateMapsController.register(ws);
+    namedMapsController.register(ws);
+
+    var TablesExtentApi = require('./api/tables_extent_api');
+    var tablesExtentApi = new TablesExtentApi(serverOptions.pgQueryRunner);
+
+    var NamedStaticMapsController = require('./controllers/named_static_maps');
+    var namedStaticMapsController = new NamedStaticMapsController(
+        ws,
+        serverOptions,
+        templateMaps,
+        ws.staticMapBackend,
+        surrogateKeysCache,
+        tablesExtentApi
+    );
+    namedStaticMapsController.register(ws);
 
     /*******************************************************************************************************************
      * END Routing

lib/cartodb/controllers/named_maps.js

@@ -1,24 +1,24 @@
 var step = require('step');
+var assert = require('assert');
 var _ = require('underscore');
+var templateName = require('../template_maps').templateName;
 var CdbRequest = require('../models/cdb_request');
+var NamedMapsCacheEntry = require('../cache/model/named_maps_entry');
 
-function TemplateMapsController(app, serverOptions, templateMaps, metadataBackend, templateBaseUrl, surrogateKeysCache,
-                                NamedMapsCacheEntry, pgConnection) {
+function NamedMapsController(app, serverOptions, templateMaps, metadataBackend, templateBaseUrl, surrogateKeysCache) {
     this.app = app;
     this.serverOptions = serverOptions;
     this.templateMaps = templateMaps;
     this.metadataBackend = metadataBackend;
     this.templateBaseUrl = templateBaseUrl;
     this.surrogateKeysCache = surrogateKeysCache;
-    this.NamedMapsCacheEntry = NamedMapsCacheEntry;
-    this.pgConnection = pgConnection;
 }
 
-module.exports = TemplateMapsController;
+module.exports = NamedMapsController;
 
 var cdbRequest = new CdbRequest();
 
-TemplateMapsController.prototype.register = function(app) {
+NamedMapsController.prototype.register = function(app) {
     app.get(this.templateBaseUrl + '/:template_id/jsonp', this.jsonp.bind(this));
     app.post(this.templateBaseUrl, this.create.bind(this));
     app.put(this.templateBaseUrl + '/:template_id', this.update.bind(this));
@@ -30,7 +30,7 @@ TemplateMapsController.prototype.register = function(app) {
 };
 
 // Add a template
-TemplateMapsController.prototype.create = function(req, res) {
+NamedMapsController.prototype.create = function(req, res) {
     var self = this;
 
     this.app.doCORS(res);
@@ -42,39 +42,22 @@ TemplateMapsController.prototype.create = function(req, res) {
             self.serverOptions.authorizedByAPIKey(req, this);
         },
         function addTemplate(err, authenticated) {
-            if ( err ) throw err;
-            if (authenticated !== 1) {
-                err = new Error("Only authenticated user can create templated maps");
-                err.http_status = 403;
-                throw err;
-            }
-            if ( ! req.headers['content-type'] || req.headers['content-type'].split(';')[0] != 'application/json' )
-                throw new Error('template POST data must be of type application/json');
+            assert.ifError(err);
+            ifUnauthenticated(authenticated, 'Only authenticated users can get template maps');
+            ifInvalidContentType(req, 'template POST data must be of type application/json');
             var cfg = req.body;
             self.templateMaps.addTemplate(cdbuser, cfg, this);
         },
         function prepareResponse(err, tpl_id){
-            if ( err ) throw err;
-            // NOTE: might omit "cdbuser" if == dbowner ...
-            return { template_id: cdbuser + '@' + tpl_id };
+            assert.ifError(err);
+            return { template_id: tpl_id };
         },
-        function finish(err, response){
-            if (err){
-                response = { error: ''+err };
-                var statusCode = 400;
-                if ( ! _.isUndefined(err.http_status) ) {
-                    statusCode = err.http_status;
-                }
-                self.app.sendError(res, response, statusCode, 'POST TEMPLATE', err);
-            } else {
-                self.app.sendResponse(res, [response, 200]);
-            }
-        }
+        finishFn(self.app, res, 'POST TEMPLATE')
     );
 };
 
 // Update a template
-TemplateMapsController.prototype.update = function(req, res) {
+NamedMapsController.prototype.update = function(req, res) {
     var self = this;
 
     this.app.doCORS(res);
@@ -87,47 +70,25 @@ TemplateMapsController.prototype.update = function(req, res) {
             self.serverOptions.authorizedByAPIKey(req, this);
         },
         function updateTemplate(err, authenticated) {
-            if ( err ) throw err;
-            if (authenticated !== 1) {
-                err = new Error("Only authenticated user can list templated maps");
-                err.http_status = 403;
-                throw err;
-            }
-            if ( ! req.headers['content-type'] || req.headers['content-type'].split(';')[0] != 'application/json' )
-                throw new Error('template PUT data must be of type application/json');
+            assert.ifError(err);
+            ifUnauthenticated(authenticated, 'Only authenticated user can update templated maps');
+            ifInvalidContentType(req, 'template PUT data must be of type application/json');
+
             template = req.body;
-            tpl_id = req.params.template_id.split('@');
-            if ( tpl_id.length > 1 ) {
-                if ( tpl_id[0] != cdbuser ) {
-                    err = new Error("Invalid template id '" + req.params.template_id + "' for user '" + cdbuser + "'");
-                    err.http_status = 404;
-                    throw err;
-                }
-                tpl_id = tpl_id[1];
-            }
+            tpl_id = templateName(req.params.template_id);
             self.templateMaps.updTemplate(cdbuser, tpl_id, template, this);
         },
         function prepareResponse(err){
-            if ( err ) throw err;
-            return { template_id: cdbuser + '@' + tpl_id };
+            assert.ifError(err);
+
+            return { template_id: tpl_id };
         },
-        function finish(err, response){
-            if (err){
-                var statusCode = 400;
-                response = { error: ''+err };
-                if ( ! _.isUndefined(err.http_status) ) {
-                    statusCode = err.http_status;
-                }
-                self.app.sendError(res, response, statusCode, 'PUT TEMPLATE', err);
-            } else {
-                self.app.sendResponse(res, [response, 200]);
-            }
-        }
+        finishFn(self.app, res, 'PUT TEMPLATE')
     );
 };
 
 // Get a specific template
-TemplateMapsController.prototype.retrieve = function(req, res) {
+NamedMapsController.prototype.retrieve = function(req, res) {
     var self = this;
 
     if (req.profiler) {
@@ -143,25 +104,13 @@ TemplateMapsController.prototype.retrieve = function(req, res) {
             self.serverOptions.authorizedByAPIKey(req, this);
         },
         function updateTemplate(err, authenticated) {
-            if ( err ) throw err;
-            if (authenticated !== 1) {
-                err = new Error("Only authenticated users can get template maps");
-                err.http_status = 403;
-                throw err;
-            }
-            tpl_id = req.params.template_id.split('@');
-            if ( tpl_id.length > 1 ) {
-                if ( tpl_id[0] != cdbuser ) {
-                    var templateNotFoundErr = new Error("Cannot get template id '" + req.params.template_id +
-                        "' for user '" + cdbuser + "'");
-                    templateNotFoundErr.http_status = 404;
-                    throw templateNotFoundErr;
-                }
-                tpl_id = tpl_id[1];
-            }
+            assert.ifError(err);
+            ifUnauthenticated(authenticated, 'Only authenticated users can get template maps');
+
+            tpl_id = templateName(req.params.template_id);
             self.templateMaps.getTemplate(cdbuser, tpl_id, this);
         },
-        function prepareResponse(err, tpl_val){
+        function prepareResponse(err, tpl_val) {
             if ( err ) throw err;
             if ( ! tpl_val ) {
                 err = new Error("Cannot find template '" + tpl_id + "' of user '" + cdbuser + "'");
@@ -173,23 +122,12 @@ TemplateMapsController.prototype.retrieve = function(req, res) {
             delete tpl_val.auth_id;
             return { template: tpl_val };
         },
-        function finish(err, response){
-            if (err){
-                var statusCode = 400;
-                response = { error: ''+err };
-                if ( ! _.isUndefined(err.http_status) ) {
-                    statusCode = err.http_status;
-                }
-                self.app.sendError(res, response, statusCode, 'GET TEMPLATE', err);
-            } else {
-                self.app.sendResponse(res, [response, 200]);
-            }
-        }
+        finishFn(self.app, res, 'GET TEMPLATE')
     );
 };
 
 // Delete a specific template
-TemplateMapsController.prototype.destroy = function(req, res) {
+NamedMapsController.prototype.destroy = function(req, res) {
     var self = this;
 
     if (req.profiler) {
@@ -204,45 +142,22 @@ TemplateMapsController.prototype.destroy = function(req, res) {
             self.serverOptions.authorizedByAPIKey(req, this);
         },
         function updateTemplate(err, authenticated) {
-            if ( err ) throw err;
-            if (authenticated !== 1) {
-                err = new Error("Only authenticated users can delete template maps");
-                err.http_status = 403;
-                throw err;
-            }
-            tpl_id = req.params.template_id.split('@');
-            if ( tpl_id.length > 1 ) {
-                if ( tpl_id[0] != cdbuser ) {
-                    var templateNotFoundErr = new Error("Cannot find template id '" + req.params.template_id +
-                        "' for user '" + cdbuser + "'");
-                    templateNotFoundErr.http_status = 404;
-                    throw templateNotFoundErr;
-                }
-                tpl_id = tpl_id[1];
-            }
+            assert.ifError(err);
+            ifUnauthenticated(authenticated, 'Only authenticated users can delete template maps');
+
+            tpl_id = templateName(req.params.template_id);
             self.templateMaps.delTemplate(cdbuser, tpl_id, this);
         },
         function prepareResponse(err/*, tpl_val*/){
             if ( err ) throw err;
             return { status: 'ok' };
         },
-        function finish(err, response){
-            if (err){
-                var statusCode = 400;
-                response = { error: ''+err };
-                if ( ! _.isUndefined(err.http_status) ) {
-                    statusCode = err.http_status;
-                }
-                self.app.sendError(res, response, statusCode, 'DELETE TEMPLATE', err);
-            } else {
-                self.app.sendResponse(res, ['', 204]);
-            }
-        }
+        finishFn(self.app, res, 'DELETE TEMPLATE', ['', 204])
     );
 };
 
 // Get a list of owned templates
-TemplateMapsController.prototype.list = function(req, res) {
+NamedMapsController.prototype.list = function(req, res) {
     var self = this;
     if ( req.profiler ) {
         req.profiler.start('windshaft-cartodb.get_template_list');
@@ -256,36 +171,20 @@ TemplateMapsController.prototype.list = function(req, res) {
             self.serverOptions.authorizedByAPIKey(req, this);
         },
         function listTemplates(err, authenticated) {
-            if ( err ) throw err;
-            if (authenticated !== 1) {
-                err = new Error("Only authenticated user can list templated maps");
-                err.http_status = 403;
-                throw err;
-            }
+            assert.ifError(err);
+            ifUnauthenticated(authenticated, 'Only authenticated user can list templated maps');
+
             self.templateMaps.listTemplates(cdbuser, this);
         },
         function prepareResponse(err, tpl_ids){
-            if ( err ) throw err;
-            // NOTE: might omit "cbduser" if == dbowner ...
-            var ids = _.map(tpl_ids, function(id) { return cdbuser + '@' + id; });
-            return { template_ids: ids };
+            assert.ifError(err);
+            return { template_ids: tpl_ids };
         },
-        function finish(err, response){
-            var statusCode = 200;
-            if (err){
-                response = { error: ''+err };
-                if ( ! _.isUndefined(err.http_status) ) {
-                    statusCode = err.http_status;
-                }
-                self.app.sendError(res, response, statusCode, 'GET TEMPLATE LIST', err);
-            } else {
-                self.app.sendResponse(res, [response, statusCode]);
-            }
-        }
+        finishFn(self.app, res, 'GET TEMPLATE LIST')
     );
 };
 
-TemplateMapsController.prototype.instantiate = function(req, res) {
+NamedMapsController.prototype.instantiate = function(req, res) {
     var self = this;
 
     if (req.profiler) {
@@ -293,9 +192,8 @@ TemplateMapsController.prototype.instantiate = function(req, res) {
     }
     step(
         function() {
-            if ( ! req.headers['content-type'] || req.headers['content-type'].split(';')[0] != 'application/json') {
-                throw new Error('template POST data must be of type application/json, it is instead ');
-            }
+            ifInvalidContentType(req, 'template POST data must be of type application/json');
+
             self.instantiateTemplate(req, res, req.body, this);
         }, function(err, response) {
             self.finish_instantiation(err, response, res);
@@ -303,7 +201,7 @@ TemplateMapsController.prototype.instantiate = function(req, res) {
     );
 };
 
-TemplateMapsController.prototype.options = function(req, res, next) {
+NamedMapsController.prototype.options = function(req, res, next) {
     this.app.doCORS(res, "Content-Type");
     return next();
 };
@@ -312,7 +210,7 @@ TemplateMapsController.prototype.options = function(req, res, next) {
  * jsonp endpoint, allows to instantiate a template with a json call.
  * callback query argument is mandatory
  */
-TemplateMapsController.prototype.jsonp = function(req, res) {
+NamedMapsController.prototype.jsonp = function(req, res) {
     var self = this;
 
     if (req.profiler) {
@@ -340,7 +238,7 @@ TemplateMapsController.prototype.jsonp = function(req, res) {
 
 
 // Instantiate a template
-TemplateMapsController.prototype.instantiateTemplate = function(req, res, template_params, callback) {
+NamedMapsController.prototype.instantiateTemplate = function(req, res, template_params, callback) {
     var self = this;
 
     this.app.doCORS(res);
@@ -350,17 +248,7 @@ TemplateMapsController.prototype.instantiateTemplate = function(req, res, templa
     var fakereq; // used for call to createLayergroup
     var cdbuser = cdbRequest.userByReq(req);
     // Format of template_id: [<template_owner>]@<template_id>
-    var tpl_id = req.params.template_id.split('@');
-    if ( tpl_id.length > 1 ) {
-        if ( tpl_id[0] && tpl_id[0] != cdbuser ) {
-            var err = new Error('Cannot instanciate map of user "' + tpl_id[0] + '" on database of user "' + cdbuser +
-                '"');
-            err.http_status = 403;
-            callback(err);
-            return;
-        }
-        tpl_id = tpl_id[1];
-    }
+    var tpl_id = templateName(req.params.template_id);
     var auth_token = req.query.auth_token;
     step(
         function getTemplate(){
@@ -412,7 +300,7 @@ TemplateMapsController.prototype.instantiateTemplate = function(req, res, templa
                 res: res,
                 profiler: req.profiler
             };
-            self.setDBParams(cdbuser, fakereq.params, this);
+            self.serverOptions.setDBParams(cdbuser, fakereq.params, this);
         },
         function setApiKey(err){
             if ( req.profiler ) req.profiler.done('setDBParams');
@@ -432,7 +320,7 @@ TemplateMapsController.prototype.instantiateTemplate = function(req, res, templa
             var tplhash = self.templateMaps.fingerPrint(template).substring(0,8);
             layergroup.layergroupid = cdbuser + '@' + tplhash + '@' + layergroup.layergroupid;
 
-            self.surrogateKeysCache.tag(res, new self.NamedMapsCacheEntry(cdbuser, template.name));
+            self.surrogateKeysCache.tag(res, new NamedMapsCacheEntry(cdbuser, template.name));
 
             return layergroup;
         },
@@ -440,7 +328,7 @@ TemplateMapsController.prototype.instantiateTemplate = function(req, res, templa
     );
 };
 
-TemplateMapsController.prototype.finish_instantiation = function(err, response, res) {
+NamedMapsController.prototype.finish_instantiation = function(err, response, res) {
     if (err) {
         var statusCode = 400;
         response = { error: ''+err };
@@ -453,18 +341,32 @@ TemplateMapsController.prototype.finish_instantiation = function(err, response,
     }
 };
 
-TemplateMapsController.prototype.setDBParams = function(cdbuser, params, callback) {
-    var self = this;
-    step(
-        function setAuth() {
-            self.pgConnection.setDBAuth(cdbuser, params, this);
-        },
-        function setConn(err) {
-            if ( err ) throw err;
-            self.pgConnection.setDBConn(cdbuser, params, this);
-        },
-        function finish(err) {
-            callback(err);
+function finishFn(app, res, description, okResponse) {
+    return function finish(err, response){
+        var statusCode = 200;
+        if (err) {
+            statusCode = 400;
+            response = { error: '' + err };
+            if ( ! _.isUndefined(err.http_status) ) {
+                statusCode = err.http_status;
+            }
+            app.sendError(res, response, statusCode, description, err);
+        } else {
+            app.sendResponse(res, okResponse || [response, statusCode]);
         }
-    );
-};
+    };
+}
+
+function ifUnauthenticated(authenticated, description) {
+    if (authenticated !== 1) {
+        var err = new Error(description);
+        err.http_status = 403;
+        throw err;
+    }
+}
+
+function ifInvalidContentType(req, description) {
+    if ( ! req.headers['content-type'] || req.headers['content-type'].split(';')[0] != 'application/json' ) {
+        throw new Error(description);
+    }
+}

lib/cartodb/controllers/named_static_maps.js

@@ -0,0 +1,248 @@
+var step = require('step');
+var assert = require('assert');
+var templateName = require('../template_maps').templateName;
+var CdbRequest = require('../models/cdb_request');
+var NamedMapsCacheEntry = require('../cache/model/named_maps_entry');
+var _ = require('underscore');
+
+function NamedStaticMapsController(app, serverOptions, templateMaps, staticMapBackend, surrogateKeysCache,
+                                   tablesExtentApi) {
+    this.app = app;
+    this.serverOptions = serverOptions;
+    this.templateMaps = templateMaps;
+    this.staticMapBackend = staticMapBackend;
+    this.surrogateKeysCache = surrogateKeysCache;
+    this.tablesExtentApi = tablesExtentApi;
+}
+
+module.exports = NamedStaticMapsController;
+
+var cdbRequest = new CdbRequest();
+
+NamedStaticMapsController.prototype.register = function(app) {
+    app.get(app.base_url_mapconfig + '/static/named/:template_id/:width/:height.:format', this.named.bind(this));
+};
+
+NamedStaticMapsController.prototype.named = function(req, res) {
+    var self = this;
+
+    this.app.doCORS(res);
+    var cdbUser = cdbRequest.userByReq(req);
+
+    var format = req.params.format === 'jpg' ? 'jpeg' : 'png';
+
+    var template;
+    var layergroupConfig;
+    var layergroupId;
+    var fakeReq;
+    var cacheChannel;
+
+    step(
+        function reqParams() {
+            self.app.req2params(req, this);
+        },
+        function getTemplate(err) {
+            assert.ifError(err);
+            self.templateMaps.getTemplate(cdbUser, templateName(req.params.template_id), this);
+        },
+        function checkExists(err, tpl) {
+            assert.ifError(err);
+            if (!tpl) {
+                var notFoundErr = new Error(
+                        "Template '" + templateName(req.params.template_id) + "' of user '" + cdbUser + "' not found"
+                );
+                notFoundErr.http_status = 404;
+                throw notFoundErr;
+            }
+            return tpl;
+        },
+        function checkAuthorized(err, tpl) {
+            assert.ifError(err);
+
+            var authorized = false;
+            try {
+                authorized = self.templateMaps.isAuthorized(tpl, req.query.auth_token);
+            } catch (err) {
+                // we catch to add http_status
+                var authorizationFailedErr = new Error('Failed to authorize template');
+                authorizationFailedErr.http_status = 403;
+                throw authorizationFailedErr;
+            }
+            if ( ! authorized ) {
+                var unauthorizedErr = new Error('Unauthorized template instantiation');
+                unauthorizedErr.http_status = 403;
+                throw unauthorizedErr;
+            }
+
+            return tpl;
+        },
+        function prepareParams(err, tpl) {
+            assert.ifError(err);
+
+            template = tpl;
+
+            var templateParams = {};
+            if (req.query.config) {
+                try {
+                    templateParams = JSON.parse(req.query.config);
+                } catch (e) {
+                    throw new Error('malformed config parameter, should be a valid JSON');
+                }
+            }
+
+            return templateParams;
+        },
+        function instantiateTemplate(err, templateParams) {
+            assert.ifError(err);
+            return self.templateMaps.instance(template, templateParams);
+        },
+        function prepareLayergroup(err, layergroup) {
+            assert.ifError(err);
+            layergroupConfig = layergroup;
+            fakeReq = {
+                query: {},
+                params: {
+                    user: req.params.user
+                },
+                headers: _.clone(req.headers),
+                context: _.clone(req.context),
+                method: req.method,
+                res: res,
+                profiler: req.profiler
+            };
+            self.serverOptions.setDBParams(cdbUser, fakeReq.params, this);
+        },
+        function setApiKey(err){
+            assert.ifError(err);
+            self.app.createLayergroup(layergroupConfig, fakeReq, this);
+        },
+        function prepareResponse(err, layergroup) {
+            assert.ifError(err);
+
+            // added by createLayergroup
+            cacheChannel = res.header('X-Cache-Channel');
+            res.removeHeader('X-Cache-Channel');
+            self.surrogateKeysCache.tag(res, new NamedMapsCacheEntry(cdbUser, template.name));
+
+            layergroupId = layergroup.layergroupid.split(":")[0];
+
+            return null;
+        },
+        function staticImageOptions(err) {
+            assert.ifError(err);
+            getStaticImageOptions(template, this);
+        },
+        function estimateBounds(err, imageOpts) {
+            assert.ifError(err);
+            if (imageOpts) {
+                return imageOpts;
+            }
+
+            var defaultZoomCenter = {
+                zoom: 1,
+                center: {
+                    lng: 0,
+                    lat: 0
+                }
+            };
+
+            var dbTables = cacheChannel.split(':');
+            if (dbTables.length <= 1 || dbTables[1].length === 0) {
+                return defaultZoomCenter;
+            }
+
+            var tableNames = dbTables[1].split(',');
+            if (tableNames.length === 0) {
+                return defaultZoomCenter;
+            }
+
+            var next = this;
+            self.tablesExtentApi.getBounds(cdbUser, tableNames, function(err, result) {
+                next(null, result || defaultZoomCenter);
+            });
+        },
+        function getImage(err, imageOpts) {
+            assert.ifError(err);
+
+            var staticImageReq = {
+                headers: _.clone(fakeReq.headers),
+                params: _.extend(_.clone(fakeReq.params), {
+                    token: layergroupId,
+                    format: req.params.format
+                })
+            };
+
+            var width = +req.params.width;
+            var height = +req.params.height;
+
+            if (!_.isUndefined(imageOpts.zoom) && imageOpts.center) {
+                self.staticMapBackend.getImage(staticImageReq, width, height, imageOpts.zoom, imageOpts.center, this);
+            } else {
+                self.staticMapBackend.getImage(staticImageReq, width, height, imageOpts.bounds, this);
+            }
+        },
+        function handleImage(err, image, headers, stats) {
+            if (req.profiler) {
+                req.profiler.done('render-' + format);
+                req.profiler.add(stats || {});
+            }
+
+            if (err) {
+                if (!err.error) {
+                    err.error = err.message;
+                }
+                self.app.sendError(res, err, self.app.findStatusCode(err), 'STATIC_VIZ_MAP', err);
+            } else {
+                res.setHeader('Content-Type', headers['Content-Type'] || 'image/' + format);
+                res.setHeader('Cache-Control', 'public,max-age=7200,must-revalidate');
+                self.app.sendResponse(res, [image, 200]);
+            }
+        }
+    );
+};
+
+function getStaticImageOptions(template, callback) {
+    if (template.view) {
+        var zoomCenter = templateZoomCenter(template.view);
+        if (zoomCenter) {
+            return callback(null, zoomCenter);
+        }
+
+        var bounds = templateBounds(template.view);
+        if (bounds) {
+            return callback(null, bounds);
+        }
+    }
+    return callback(null, null);
+}
+
+function templateZoomCenter(view) {
+    if (!_.isUndefined(view.zoom) && view.center) {
+        return {
+            zoom: view.zoom,
+            center: view.center
+        };
+    }
+    return false;
+}
+
+function templateBounds(view) {
+    if (view.bounds) {
+        var hasAllBounds = _.every(['west', 'south', 'east', 'north'], function(prop) {
+            return !!view.bounds[prop];
+        });
+        if (hasAllBounds) {
+            return {
+                bounds: {
+                    west: view.bounds.west,
+                    south: view.bounds.south,
+                    east: view.bounds.east,
+                    north: view.bounds.north
+                }
+            };
+        } else {
+            return false;
+        }
+    }
+    return false;
+}

lib/cartodb/server_options.js

@@ -5,6 +5,7 @@ var assert = require('assert');
 var RedisPool = require('redis-mpool');
 
 var QueryTablesApi = require('./api/query_tables_api');
+var PgQueryRunner = require('./backends/pg_query_runner');
 var PgConnection = require('./backends/pg_connection');
 var TemplateMaps = require('./template_maps.js');
 var MapConfigNamedLayersAdapter = require('./models/mapconfig_named_layers_adapter');
@@ -25,11 +26,12 @@ var REQUEST_QUERY_PARAMS_WHITELIST = [
 module.exports = function(redisPool) {
     redisPool = redisPool || new RedisPool(_.extend(global.environment.redis, {name: 'windshaft:server_options'}));
 
-    var cartoData = require('cartodb-redis')({ pool: redisPool }),
-        lzmaWorker = new LZMA(),
-        pgConnection = new PgConnection(cartoData),
-        queryTablesApi = new QueryTablesApi(pgConnection, cartoData),
-        cdbRequest = new CdbRequest();
+    var cartoData = require('cartodb-redis')({ pool: redisPool });
+    var lzmaWorker = new LZMA();
+    var pgConnection = new PgConnection(cartoData);
+    var pgQueryRunner = new PgQueryRunner(pgConnection);
+    var queryTablesApi = new QueryTablesApi(pgQueryRunner);
+    var cdbRequest = new CdbRequest();
 
     var rendererConfig = _.defaults(global.environment.renderer || {}, {
         cache_ttl: 60000, // milliseconds
@@ -86,6 +88,7 @@ module.exports = function(redisPool) {
         varnish_http_port: global.environment.varnish.http_port,
         varnish_secret: global.environment.varnish.secret,
         varnish_purge_enabled: global.environment.varnish.purge_enabled,
+        fastly: global.environment.fastly || {},
         cache_enabled: global.environment.cache_enabled,
         log_format: global.environment.log_format,
         useProfiler: global.environment.useProfiler
@@ -100,6 +103,8 @@ module.exports = function(redisPool) {
 
     // Re-use pgConnection
     me.pgConnection = pgConnection;
+    // Re-use pgQueryRunner
+    me.pgQueryRunner = pgQueryRunner;
 
     var templateMaps = new TemplateMaps(redisPool, {
         max_user_templates: global.environment.maxUserTemplates
@@ -400,7 +405,9 @@ module.exports = function(redisPool) {
         }
 
         mapStore.load(layergroup_id, function(err, mapConfig) {
-            assert.ifError(err);
+            if (err) {
+                return callback(err);
+            }
 
             var authorized = me.templateMaps.isAuthorized(mapConfig.obj().template, auth_token);
 
@@ -475,7 +482,9 @@ module.exports = function(redisPool) {
                 });
             },
             function checkSignAuthorized(err, signed_by){
-                assert.ifError(err);
+                if (err) {
+                    return callback(err);
+                }
 
                 if ( ! signed_by ) {
                   // request not authorized by signer.
@@ -503,6 +512,21 @@ module.exports = function(redisPool) {
         );
     };
 
+    me.setDBParams = function(cdbuser, params, callback) {
+        step(
+            function setAuth() {
+                pgConnection.setDBAuth(cdbuser, params, this);
+            },
+            function setConn(err) {
+                if ( err ) throw err;
+                pgConnection.setDBConn(cdbuser, params, this);
+            },
+            function finish(err) {
+                callback(err);
+            }
+        );
+    };
+
     // jshint maxcomplexity:10
     /**
      * Whitelist input and get database name & default geometry type from

lib/cartodb/template_maps.js

@@ -492,3 +492,14 @@ o.fingerPrint = function(template) {
     .digest('hex')
   ;
 };
+
+module.exports.templateName = function templateName(templateId) {
+    var templateIdTokens = templateId.split('@');
+    var name = templateIdTokens[0];
+
+    if (templateIdTokens.length > 1) {
+        name = templateIdTokens[1];
+    }
+
+    return name;
+};

package.json

@@ -1,7 +1,7 @@
 {
     "private": true,
     "name": "windshaft-cartodb",
-    "version": "2.1.2",
+    "version": "2.3.0",
     "description": "A map tile server for CartoDB",
     "keywords": [
       "cartodb"
@@ -24,12 +24,13 @@
     "dependencies": {
         "underscore"  : "~1.6.0",
         "dot": "~1.0.2",
-        "windshaft": "0.42.1",
+        "windshaft": "0.43.0",
         "step": "~0.0.5",
         "queue-async": "~1.0.7",
         "request": "~2.9.203",
-        "cartodb-redis": "~0.12.1",
+        "cartodb-redis": "~0.13.0",
         "cartodb-psql": "~0.4.0",
+        "fastly-purge": "~1.0.0",
         "redis-mpool": "~0.3.0",
         "lzma": "~1.3.7",
         "log4js": "https://github.com/CartoDB/log4js-node/tarball/cdb"

test/acceptance/cache/surrogate_keys_invalidation.js

@@ -3,6 +3,7 @@ require(__dirname + '/../../support/test_helper');
 var assert      = require('../../support/assert');
 var redis       = require('redis');
 var step        = require('step');
+var FastlyPurge = require('fastly-purge');
 
 var NamedMapsCacheEntry = require(__dirname + '/../../../lib/cartodb/cache/model/named_maps_entry');
 var CartodbWindshaft = require(__dirname + '/../../../lib/cartodb/cartodb_windshaft');
@@ -18,12 +19,23 @@ describe('templates surrogate keys', function() {
     var varnishPurgeEnabled = global.environment.varnish.purge_enabled;
     global.environment.varnish.purge_enabled = true;
 
+    var fastlyConfig = global.environment.fastly;
+    var FAKE_FASTLY_API_KEY = 'fastly-api-key';
+    var FAKE_FASTLY_SERVICE_ID = 'fake-service-id';
+    global.environment.fastly = {
+        enabled: true,
+        // the fastly api key
+        apiKey: FAKE_FASTLY_API_KEY,
+        // the service that will get surrogate key invalidation
+        serviceId: FAKE_FASTLY_SERVICE_ID
+    };
+
     var serverOptions = require('../../../lib/cartodb/server_options')();
     var server = new CartodbWindshaft(serverOptions);
 
     var templateOwner = 'localhost',
         templateName = 'acceptance',
-        expectedTemplateId = templateOwner + '@' + templateName,
+        expectedTemplateId = templateName,
         template = {
             version: '0.0.1',
             name: templateName,
@@ -51,6 +63,7 @@ describe('templates surrogate keys', function() {
 
     var cacheEntryKey = new NamedMapsCacheEntry(templateOwner, templateName).key();
     var invalidationMatchHeader = '\\b' + cacheEntryKey + '\\b';
+    var fastlyPurgePath = '/service/' + FAKE_FASTLY_SERVICE_ID + '/purge/' + encodeURIComponent(cacheEntryKey);
 
     var nock = require('nock');
     nock.enableNetConnect(/(127.0.0.1:5555|cartocdn.com)/);
@@ -60,6 +73,8 @@ describe('templates surrogate keys', function() {
         global.environment.varnish.host = varnishHost;
         global.environment.varnish.purge_enabled = varnishPurgeEnabled;
 
+        global.environment.fastly = fastlyConfig;
+
         nock.restore();
         done();
     });
@@ -109,6 +124,15 @@ describe('templates surrogate keys', function() {
             .matchHeader('Invalidation-Match', invalidationMatchHeader)
             .reply(204, '');
 
+        var fastlyScope = nock(FastlyPurge.FASTLY_API_ENDPOINT)
+            .post(fastlyPurgePath)
+            .matchHeader('Fastly-Key', FAKE_FASTLY_API_KEY)
+            .matchHeader('Fastly-Soft-Purge', 1)
+            .matchHeader('Accept', 'application/json')
+            .reply(200, {
+                status:'ok'
+            });
+
         step(
             function createTemplateToUpdate() {
                 createTemplate(this);
@@ -145,6 +169,7 @@ describe('templates surrogate keys', function() {
                 assert.deepEqual(parsedBody, expectedBody);
 
                 assert.equal(scope.pendingMocks().length, 0);
+                assert.equal(fastlyScope.pendingMocks().length, 0);
 
                 return null;
             },
@@ -171,6 +196,15 @@ describe('templates surrogate keys', function() {
             .matchHeader('Invalidation-Match', invalidationMatchHeader)
             .reply(204, '');
 
+        var fastlyScope = nock(FastlyPurge.FASTLY_API_ENDPOINT)
+            .post(fastlyPurgePath)
+            .matchHeader('Fastly-Key', FAKE_FASTLY_API_KEY)
+            .matchHeader('Fastly-Soft-Purge', 1)
+            .matchHeader('Accept', 'application/json')
+            .reply(200, {
+                status:'ok'
+            });
+
         step(
             function createTemplateToDelete() {
                 createTemplate(this);
@@ -204,6 +238,7 @@ describe('templates surrogate keys', function() {
                 }
 
                 assert.equal(scope.pendingMocks().length, 0);
+                assert.equal(fastlyScope.pendingMocks().length, 0);
 
                 return null;
             },

test/acceptance/health_check.js

@@ -1,4 +1,4 @@
-var helper = require(__dirname + '/../support/test_helper');
+require(__dirname + '/../support/test_helper');
 
 var assert      = require('../support/assert');
 var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/cartodb_windshaft');
@@ -10,7 +10,7 @@ var tilelive = {};
 var HealthCheck = require('../../lib/cartodb/monitoring/health_check');
 var healthCheck = new HealthCheck(metadataBackend, tilelive);
 
-suite('health checks', function () {
+describe('health checks', function () {
 
     function resetHealthConfig() {
         global.environment.health = {
@@ -30,7 +30,7 @@ suite('health checks', function () {
         }
     };
 
-    test('returns 200 and ok=true with enabled configuration', function (done) {
+    it('returns 200 and ok=true with enabled configuration', function (done) {
         resetHealthConfig();
 
         assert.response(server,
@@ -51,15 +51,15 @@ suite('health checks', function () {
         );
     });
 
-    test('error if disabled file exists', function(done) {
+    it('error if disabled file exists', function(done) {
       var fs = require('fs');
 
-      var readFileFn = fs.readFile
+      var readFileFn = fs.readFile;
       fs.readFile = function(filename, callback) {
         callback(null, "Maintenance");
-      }   
+      };
       
-      healthCheck.check(null, function(err, result) {
+      healthCheck.check(null, function(err/*, result*/) {
         assert.equal(err.message, "Maintenance");
         assert.equal(err.http_status, 503);
         done();
@@ -68,7 +68,7 @@ suite('health checks', function () {
       
     }); 
 
-    test('not err if disabled file does not exists', function(done) {
+    it('not err if disabled file does not exists', function(done) {
       resetHealthConfig();
 
       global.environment.disabled_file = '/tmp/ftreftrgtrccre';

test/acceptance/multilayer_server.js

@@ -6,7 +6,7 @@ var redis = require('redis');
 var _ = require('underscore');
 
 
-var QueryTablesApi = require('../../lib/cartodb/api/query_tables_api');
+var PgQueryRunner = require('../../lib/cartodb/backends/pg_query_runner');
 var CartodbWindshaft = require('../../lib/cartodb/cartodb_windshaft');
 var serverOptions = require('../../lib/cartodb/server_options')();
 var server = new CartodbWindshaft(serverOptions);
@@ -253,8 +253,8 @@ describe('tests from old api translated to multilayer', function() {
 
     it("creates layergroup fails when postgresql queries fail to figure affected tables in query",  function(done) {
 
-        var runQueryFn = QueryTablesApi.prototype.runQuery;
-        QueryTablesApi.prototype.runQuery = function(username, query, queryHandler, callback) {
+        var runQueryFn = PgQueryRunner.prototype.run;
+        PgQueryRunner.prototype.run = function(username, query, queryHandler, callback) {
             return queryHandler(new Error('fake error message'), [], callback);
         };
 
@@ -272,7 +272,7 @@ describe('tests from old api translated to multilayer', function() {
                 status: 400
             },
             function(res) {
-                QueryTablesApi.prototype.runQuery = runQueryFn;
+                PgQueryRunner.prototype.run = runQueryFn;
 
                 assert.ok(!res.headers.hasOwnProperty('x-cache-channel'));
 
@@ -300,8 +300,8 @@ describe('tests from old api translated to multilayer', function() {
                 status: 200
             },
             function(res) {
-                var runQueryFn = QueryTablesApi.prototype.runQuery;
-                QueryTablesApi.prototype.runQuery = function(username, query, queryHandler, callback) {
+                var runQueryFn = PgQueryRunner.prototype.run;
+                PgQueryRunner.prototype.run = function(username, query, queryHandler, callback) {
                     return queryHandler(new Error('failed to query database for affected tables'), [], callback);
                 };
 
@@ -327,7 +327,7 @@ describe('tests from old api translated to multilayer', function() {
                     },
                     function(res) {
                         assert.ok(!res.headers.hasOwnProperty('x-cache-channel'));
-                        QueryTablesApi.prototype.runQuery = runQueryFn;
+                        PgQueryRunner.prototype.run = runQueryFn;
                         done();
                     }
                 );

test/acceptance/named_layers.js

@@ -8,12 +8,11 @@ var server = new CartodbWindshaft(serverOptions);
 var RedisPool = require('redis-mpool');
 var TemplateMaps = require('../../lib/cartodb/template_maps.js');
 
-var Step = require('step');
-var _ = require('underscore');
+var step = require('step');
 
-suite('named_layers', function() {
+describe('named_layers', function() {
     // configure redis pool instance to use in tests
-    var redisPool = RedisPool(global.environment.redis);
+    var redisPool = new RedisPool(global.environment.redis);
 
     var templateMaps = new TemplateMaps(redisPool, {
         max_user_templates: global.environment.maxUserTemplates
@@ -95,7 +94,7 @@ suite('named_layers', function() {
         }
     };
 
-    suiteSetup(function(done) {
+    before(function(done) {
         global.environment.enabledFeatures = {cdbQueryTablesFromPostgres: true};
         templateMaps.addTemplate(username, nestedNamedMapTemplate, function(err) {
             if (err) {
@@ -112,7 +111,7 @@ suite('named_layers', function() {
         });
     });
 
-    test('should fail for non-existing template name', function(done) {
+    it('should fail for non-existing template name', function(done) {
         var layergroup =  {
             version: '1.3.0',
             layers: [
@@ -125,7 +124,7 @@ suite('named_layers', function() {
             ]
         };
 
-        Step(
+        step(
             function createLayergroup() {
                 var next = this;
                 assert.response(server,
@@ -162,7 +161,7 @@ suite('named_layers', function() {
         );
     });
 
-    test('should return 403 if not properly authorized', function(done) {
+    it('should return 403 if not properly authorized', function(done) {
 
         var layergroup =  {
             version: '1.3.0',
@@ -178,7 +177,7 @@ suite('named_layers', function() {
             ]
         };
 
-        Step(
+        step(
             function createLayergroup() {
                 var next = this;
                 assert.response(server,
@@ -219,7 +218,7 @@ suite('named_layers', function() {
 
     });
 
-    test('should return 200 and layergroup if properly authorized', function(done) {
+    it('should return 200 and layergroup if properly authorized', function(done) {
 
         var layergroup =  {
             version: '1.3.0',
@@ -235,7 +234,7 @@ suite('named_layers', function() {
             ]
         };
 
-        Step(
+        step(
             function createLayergroup() {
                 var next = this;
                 assert.response(server,
@@ -274,7 +273,7 @@ suite('named_layers', function() {
 
     });
 
-    test('should return 400 for nested named map layers', function(done) {
+    it('should return 400 for nested named map layers', function(done) {
 
         var layergroup =  {
             version: '1.3.0',
@@ -288,7 +287,7 @@ suite('named_layers', function() {
             ]
         };
 
-        Step(
+        step(
             function createLayergroup() {
                 var next = this;
                 assert.response(server,
@@ -326,7 +325,7 @@ suite('named_layers', function() {
 
     });
 
-    test('should return 200 and layergroup with private tables', function(done) {
+    it('should return 200 and layergroup with private tables', function(done) {
 
         var privateTableTemplateName = 'private_table_template';
         var privateTableTemplate = {
@@ -361,7 +360,7 @@ suite('named_layers', function() {
             ]
         };
 
-        Step(
+        step(
             function createTemplate() {
                 templateMaps.addTemplate(username, privateTableTemplate, this);
             },
@@ -447,7 +446,7 @@ suite('named_layers', function() {
 
     });
 
-    test('should return 200 and layergroup with private tables and interactivity', function(done) {
+    it('should return 200 and layergroup with private tables and interactivity', function(done) {
 
         var privateTableTemplateNameInteractivity = 'private_table_template_interactivity';
         var privateTableTemplate = {
@@ -489,7 +488,7 @@ suite('named_layers', function() {
             ]
         };
 
-        Step(
+        step(
             function createTemplate() {
                 templateMaps.addTemplate(username, privateTableTemplate, this);
             },
@@ -575,7 +574,7 @@ suite('named_layers', function() {
 
     });
 
-    test('should return 403 when private table is accessed from non named layer', function(done) {
+    it('should return 403 when private table is accessed from non named layer', function(done) {
 
         var layergroup =  {
             version: '1.3.0',
@@ -597,7 +596,7 @@ suite('named_layers', function() {
             ]
         };
 
-        Step(
+        step(
             function createLayergroup() {
                 var next = this;
                 assert.response(server,
@@ -636,7 +635,7 @@ suite('named_layers', function() {
     });
 
 
-    suiteTeardown(function(done) {
+    after(function(done) {
         global.environment.enabledFeatures = {cdbQueryTablesFromPostgres: false};
         templateMaps.delTemplate(username, nestedNamedMapTemplateName, function(err) {
             if (err) {

test/acceptance/named_static_maps.js

@@ -0,0 +1,189 @@
+var test_helper = require('../support/test_helper');
+var RedisPool = require('redis-mpool');
+var querystring = require('querystring');
+
+var assert = require('../support/assert');
+var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/cartodb_windshaft');
+var serverOptions = require(__dirname + '/../../lib/cartodb/server_options')();
+var server = new CartodbWindshaft(serverOptions);
+var TemplateMaps = require('../../lib/cartodb/template_maps.js');
+var NamedMapsCacheEntry = require('../../lib/cartodb/cache/model/named_maps_entry');
+
+describe('named static maps', function() {
+    // configure redis pool instance to use in tests
+    var redisPool = new RedisPool(global.environment.redis);
+
+    var templateMaps = new TemplateMaps(redisPool, {
+        max_user_templates: global.environment.maxUserTemplates
+    });
+
+    var wadusLayer = {
+        type: 'cartodb',
+        options: {
+            sql: 'select 1 cartodb_id, null::geometry the_geom_webmercator',
+            cartocss: '#layer { marker-fill: <%= color %>; }',
+            cartocss_version: '2.3.0'
+        }
+    };
+
+    var username = 'localhost';
+
+    var templateName = 'valid_template';
+    var template = {
+        version: '0.0.1',
+        name: templateName,
+        auth: {
+            method: 'open'
+        },
+        "placeholders": {
+            "color": {
+                "type": "css_color",
+                "default": "#cc3300"
+            }
+        },
+        layergroup: {
+            layers: [
+                wadusLayer
+            ]
+        }
+    };
+
+    var tokenAuthTemplateName = 'auth_valid_template';
+    var tokenAuthTemplate = {
+        version: '0.0.1',
+        name: tokenAuthTemplateName,
+        auth: {
+            method: 'token',
+            valid_tokens: ['valid1', 'valid2']
+        },
+        placeholders: {
+            color: {
+                "type": "css_color",
+                "default": "#cc3300"
+            }
+        },
+        layergroup: {
+            layers: [
+                wadusLayer
+            ]
+        }
+    };
+
+
+    var namedMapLayer = {
+        type: 'named',
+        options: {
+            name: templateName,
+            config: {},
+            auth_tokens: []
+        }
+    };
+
+    var nestedNamedMapTemplateName = 'nested_template';
+    var nestedNamedMapTemplate = {
+        version: '0.0.1',
+        name: nestedNamedMapTemplateName,
+        auth: {
+            method: 'open'
+        },
+        layergroup: {
+            layers: [
+                namedMapLayer
+            ]
+        }
+    };
+
+    before(function (done) {
+        templateMaps.addTemplate(username, nestedNamedMapTemplate, function (err) {
+            if (err) {
+                return done(err);
+            }
+            templateMaps.addTemplate(username, tokenAuthTemplate, function (err) {
+                if (err) {
+                    return done(err);
+                }
+                templateMaps.addTemplate(username, template, function (err) {
+                    return done(err);
+                });
+            });
+        });
+    });
+
+    after(function (done) {
+        templateMaps.delTemplate(username, nestedNamedMapTemplateName, function (err) {
+            if (err) {
+                return done(err);
+            }
+            templateMaps.delTemplate(username, tokenAuthTemplateName, function (err) {
+                if (err) {
+                    return done(err);
+                }
+                templateMaps.delTemplate(username, templateName, function (err) {
+                    return done(err);
+                });
+            });
+        });
+    });
+
+    function getStaticMap(name, options, callback) {
+
+        var url = '/api/v1/map/static/named/' + name + '/640/480.png';
+        if (options.params) {
+            url = url + '?' + querystring.stringify(options.params);
+        }
+        var requestOptions = {
+            url: url,
+            method: 'GET',
+            headers: {
+                host: username
+            }
+        };
+
+        console.log(url);
+
+        var statusCode = options.status || 200;
+
+        var expectedResponse = {
+            status: statusCode,
+            headers: {
+                'Content-Type': statusCode === 200 ? 'image/png' : 'application/json; charset=utf-8'
+            }
+        };
+
+        assert.response(server,
+            requestOptions,
+            expectedResponse,
+            function (res, err) {
+                return callback(err, res);
+            }
+        );
+    }
+
+    it('should return a 404 error for nonexistent template name', function (done) {
+        var nonexistentName = 'nonexistent';
+        getStaticMap(nonexistentName, { status: 404 }, function(err, res) {
+            assert.ok(!err);
+            var parsed = JSON.parse(res.body);
+            assert.equal(parsed.error, "Template '" + nonexistentName + "' of user '" + username + "' not found");
+            done();
+        });
+    });
+
+    it('should return 403 if not properly authorized', function(done) {
+        getStaticMap(tokenAuthTemplateName, { status: 403 }, function(err, res) {
+            assert.ok(!err);
+            var parsed = JSON.parse(res.body);
+            assert.equal(parsed.error, 'Unauthorized template instantiation');
+            done();
+        });
+    });
+
+    it('should return 200 if properly authorized', function(done) {
+        getStaticMap(tokenAuthTemplateName, { params: { auth_token: 'valid1' } }, function(err, res) {
+            assert.ok(!err);
+            test_helper.checkSurrogateKey(res, new NamedMapsCacheEntry(username, tokenAuthTemplateName).key());
+            done();
+        });
+    });
+
+});

test/integration/mapconfig_named_layers_datasource.js

@@ -1,4 +1,4 @@
-var test_helper = require('../support/test_helper');
+require('../support/test_helper');
 
 var assert = require('assert');
 var RedisPool = require('redis-mpool');
@@ -6,11 +6,8 @@ var TemplateMaps = require('../../lib/cartodb/template_maps.js');
 var PgConnection = require(__dirname + '/../../lib/cartodb/backends/pg_connection');
 var MapConfigNamedLayersAdapter = require('../../lib/cartodb/models/mapconfig_named_layers_adapter');
 
-var Step = require('step');
-var _ = require('underscore');
-
 // configure redis pool instance to use in tests
-var redisPool = RedisPool(global.environment.redis);
+var redisPool = new RedisPool(global.environment.redis);
 var pgConnection = new PgConnection(require('cartodb-redis')({ pool: redisPool }));
 
 var templateMaps = new TemplateMaps(redisPool, {
@@ -97,8 +94,8 @@ var multipleLayersTemplate = {
     }
 };
 
-suite('named_layers datasources', function() {
-    suiteSetup(function(done) {
+describe('named_layers datasources', function() {
+    before(function(done) {
         templateMaps.addTemplate(username, template, function(err) {
             if (err) {
                 return done(err);
@@ -224,7 +221,14 @@ suite('named_layers datasources', function() {
 
         {
             desc: 'with a mix of datasource and no datasource depending if layers are named or not',
-            config: makeNamedMapLayerConfig([simpleNamedLayer, multipleLayersNamedLayer, wadusLayer, simpleNamedLayer, wadusLayer, multipleLayersNamedLayer]),
+            config: makeNamedMapLayerConfig([
+                simpleNamedLayer,
+                multipleLayersNamedLayer,
+                wadusLayer,
+                simpleNamedLayer,
+                wadusLayer,
+                multipleLayersNamedLayer
+            ]),
             test: function(err, layers, datasource, done) {
 
                 assert.ok(!err);
@@ -280,14 +284,16 @@ suite('named_layers datasources', function() {
     ];
 
     testScenarios.forEach(function(testScenario) {
-        test('should return a list of layers ' + testScenario.desc, function(done) {
-            mapConfigNamedLayersAdapter.getLayers(username, testScenario.config.layers, pgConnection, function(err, layers, datasource) {
-                testScenario.test(err, layers, datasource, done);
-            });
+        it('should return a list of layers ' + testScenario.desc, function(done) {
+            mapConfigNamedLayersAdapter.getLayers(username, testScenario.config.layers, pgConnection,
+                function(err, layers, datasource) {
+                    testScenario.test(err, layers, datasource, done);
+                }
+            );
         });
     });
 
-    suiteTeardown(function(done) {
+    after(function(done) {
         templateMaps.delTemplate(username, templateName, function(err) {
             if (err) {
                 return done(err);

test/integration/mapconfig_named_layers_expanded.js

@@ -1,4 +1,4 @@
-var testHelper = require('../support/test_helper');
+require('../support/test_helper');
 
 var assert = require('assert');
 var RedisPool = require('redis-mpool');
@@ -6,13 +6,10 @@ var TemplateMaps = require('../../lib/cartodb/template_maps.js');
 var PgConnection = require(__dirname + '/../../lib/cartodb/backends/pg_connection');
 var MapConfigNamedLayersAdapter = require('../../lib/cartodb/models/mapconfig_named_layers_adapter');
 
-var Step = require('step');
-var _ = require('underscore');
-
-suite('mapconfig_named_layers_adapter', function() {
+describe('mapconfig_named_layers_adapter', function() {
 
     // configure redis pool instance to use in tests
-    var redisPool = RedisPool(global.environment.redis);
+    var redisPool = new RedisPool(global.environment.redis);
     var pgConnection = new PgConnection(require('cartodb-redis')({ pool: redisPool }));
 
     var templateMaps = new TemplateMaps(redisPool, {
@@ -138,40 +135,46 @@ suite('mapconfig_named_layers_adapter', function() {
     }
 
 
-    suiteSetup(function(done) {
+    before(function(done) {
         templateMaps.addTemplate(username, template, done);
     });
 
-    test('should fail for named map layer with missing name', function(done) {
+    it('should fail for named map layer with missing name', function(done) {
         var missingNamedMapLayerConfig = makeNamedMapLayerConfig({
             config: {}
         });
-        mapConfigNamedLayersAdapter.getLayers(username, missingNamedMapLayerConfig.layers, pgConnection, function(err, layers, datasource) {
-            assert.ok(err);
-            assert.ok(!layers);
-            assert.ok(!datasource);
-            assert.equal(err.message, 'Missing Named Map `name` in layer options');
+        mapConfigNamedLayersAdapter.getLayers(username, missingNamedMapLayerConfig.layers, pgConnection,
+            function(err, layers, datasource) {
+                assert.ok(err);
+                assert.ok(!layers);
+                assert.ok(!datasource);
+                assert.equal(err.message, 'Missing Named Map `name` in layer options');
 
-            done();
-        });
+                done();
+            }
+        );
     });
 
-    test('should fail for non-existing template name', function(done) {
+    it('should fail for non-existing template name', function(done) {
         var missingTemplateName = 'wadus';
         var nonExistentNamedMapLayerConfig = makeNamedMapLayerConfig({
             name: missingTemplateName
         });
-        mapConfigNamedLayersAdapter.getLayers(username, nonExistentNamedMapLayerConfig.layers, pgConnection, function(err, layers, datasource) {
-            assert.ok(err);
-            assert.ok(!layers);
-            assert.ok(!datasource);
-            assert.equal(err.message, "Template '" + missingTemplateName + "' of user '" + username + "' not found");
+        mapConfigNamedLayersAdapter.getLayers(username, nonExistentNamedMapLayerConfig.layers, pgConnection,
+            function(err, layers, datasource) {
+                assert.ok(err);
+                assert.ok(!layers);
+                assert.ok(!datasource);
+                assert.equal(
+                    err.message, "Template '" + missingTemplateName + "' of user '" + username + "' not found"
+                );
 
-            done();
-        });
+                done();
+            }
+        );
     });
 
-    test('should fail if not properly authorized', function(done) {
+    it('should fail if not properly authorized', function(done) {
         templateMaps.addTemplate(username, tokenAuthTemplate, function(err) {
             if (err) {
                 return done(err);
@@ -180,18 +183,20 @@ suite('mapconfig_named_layers_adapter', function() {
             var nonAuthTokensNamedMapLayerConfig = makeNamedMapLayerConfig({
                 name: tokenAuthTemplateName
             });
-            mapConfigNamedLayersAdapter.getLayers(username, nonAuthTokensNamedMapLayerConfig.layers, pgConnection, function(err, layers, datasource) {
-                assert.ok(err);
-                assert.ok(!layers);
-                assert.ok(!datasource);
-                assert.equal(err.message, "Unauthorized '" + tokenAuthTemplateName + "' template instantiation");
+            mapConfigNamedLayersAdapter.getLayers(username, nonAuthTokensNamedMapLayerConfig.layers, pgConnection,
+                function(err, layers, datasource) {
+                    assert.ok(err);
+                    assert.ok(!layers);
+                    assert.ok(!datasource);
+                    assert.equal(err.message, "Unauthorized '" + tokenAuthTemplateName + "' template instantiation");
 
-                templateMaps.delTemplate(username, tokenAuthTemplateName, done);
-            });
+                    templateMaps.delTemplate(username, tokenAuthTemplateName, done);
+                }
+            );
         });
     });
 
-    test('should fail for nested named map layers', function(done) {
+    it('should fail for nested named map layers', function(done) {
         templateMaps.addTemplate(username, nestedNamedMapTemplate, function(err) {
             if (err) {
                 return done(err);
@@ -200,32 +205,36 @@ suite('mapconfig_named_layers_adapter', function() {
             var nestedNamedMapLayerConfig = makeNamedMapLayerConfig({
                 name: nestedNamedMapTemplateName
             });
-            mapConfigNamedLayersAdapter.getLayers(username, nestedNamedMapLayerConfig.layers, pgConnection, function(err, layers, datasource) {
-                assert.ok(err);
-                assert.ok(!layers);
-                assert.ok(!datasource);
-                assert.equal(err.message, 'Nested named layers are not allowed');
+            mapConfigNamedLayersAdapter.getLayers(username, nestedNamedMapLayerConfig.layers, pgConnection,
+                function(err, layers, datasource) {
+                    assert.ok(err);
+                    assert.ok(!layers);
+                    assert.ok(!datasource);
+                    assert.equal(err.message, 'Nested named layers are not allowed');
 
-                templateMaps.delTemplate(username, nestedNamedMapTemplateName, done);
-            });
+                    templateMaps.delTemplate(username, nestedNamedMapTemplateName, done);
+                }
+            );
         });
     });
 
-    test('should return an expanded list of layers for a named map layer', function(done) {
+    it('should return an expanded list of layers for a named map layer', function(done) {
         var validNamedMapMapLayerConfig = makeNamedMapLayerConfig({
             name: templateName
         });
-        mapConfigNamedLayersAdapter.getLayers(username, validNamedMapMapLayerConfig.layers, pgConnection, function(err, layers, datasource) {
-            assert.ok(!err);
-            assert.ok(layers.length, 1);
-            assert.ok(layers[0].type, 'cartodb');
-            assert.notEqual(datasource.getLayerDatasource(0), undefined);
+        mapConfigNamedLayersAdapter.getLayers(username, validNamedMapMapLayerConfig.layers, pgConnection,
+            function(err, layers, datasource) {
+                assert.ok(!err);
+                assert.ok(layers.length, 1);
+                assert.ok(layers[0].type, 'cartodb');
+                assert.notEqual(datasource.getLayerDatasource(0), undefined);
 
-            done();
-        });
+                done();
+            }
+        );
     });
 
-    test('should return on auth=token with valid tokens provided', function(done) {
+    it('should return on auth=token with valid tokens provided', function(done) {
         templateMaps.addTemplate(username, tokenAuthTemplate, function(err) {
             if (err) {
                 return done(err);
@@ -235,17 +244,19 @@ suite('mapconfig_named_layers_adapter', function() {
                 name: tokenAuthTemplateName,
                 auth_tokens: ['valid1']
             });
-            mapConfigNamedLayersAdapter.getLayers(username, validAuthTokensNamedMapLayerConfig.layers, pgConnection, function(err, layers, datasource) {
-                assert.ok(!err);
-                assert.equal(layers.length, 1);
-                assert.notEqual(datasource.getLayerDatasource(0), undefined);
+            mapConfigNamedLayersAdapter.getLayers(username, validAuthTokensNamedMapLayerConfig.layers, pgConnection,
+                function(err, layers, datasource) {
+                    assert.ok(!err);
+                    assert.equal(layers.length, 1);
+                    assert.notEqual(datasource.getLayerDatasource(0), undefined);
 
-                templateMaps.delTemplate(username, tokenAuthTemplateName, done);
-            });
+                    templateMaps.delTemplate(username, tokenAuthTemplateName, done);
+                }
+            );
         });
     });
 
-    test('should return an expanded list of layers for a named map layer, multiple layers version', function(done) {
+    it('should return an expanded list of layers for a named map layer, multiple layers version', function(done) {
         templateMaps.addTemplate(username, multipleLayersTemplate, function(err) {
             if (err) {
                 return done(err);
@@ -255,24 +266,26 @@ suite('mapconfig_named_layers_adapter', function() {
                 name: multipleLayersTemplateName,
                 auth_tokens: ['valid2']
             });
-            mapConfigNamedLayersAdapter.getLayers(username, multipleLayersNamedMapLayerConfig.layers, pgConnection, function(err, layers, datasource) {
-                assert.ok(!err);
-                assert.equal(layers.length, 2);
+            mapConfigNamedLayersAdapter.getLayers(username, multipleLayersNamedMapLayerConfig.layers, pgConnection,
+                function(err, layers, datasource) {
+                    assert.ok(!err);
+                    assert.equal(layers.length, 2);
 
-                assert.equal(layers[0].type, 'mapnik');
-                assert.equal(layers[0].options.cartocss, '#layer { polygon-fill: green; }');
-                assert.notEqual(datasource.getLayerDatasource(0), undefined);
+                    assert.equal(layers[0].type, 'mapnik');
+                    assert.equal(layers[0].options.cartocss, '#layer { polygon-fill: green; }');
+                    assert.notEqual(datasource.getLayerDatasource(0), undefined);
 
-                assert.equal(layers[1].type, 'cartodb');
-                assert.equal(layers[1].options.cartocss, '#layer { marker-fill: red; }');
-                assert.notEqual(datasource.getLayerDatasource(1), undefined);
+                    assert.equal(layers[1].type, 'cartodb');
+                    assert.equal(layers[1].options.cartocss, '#layer { marker-fill: red; }');
+                    assert.notEqual(datasource.getLayerDatasource(1), undefined);
 
-                templateMaps.delTemplate(username, multipleLayersTemplateName, done);
-            });
+                    templateMaps.delTemplate(username, multipleLayersTemplateName, done);
+                }
+            );
         });
     });
 
-    test('should replace template params with the given config', function(done) {
+    it('should replace template params with the given config', function(done) {
         templateMaps.addTemplate(username, multipleLayersTemplate, function(err) {
             if (err) {
                 return done(err);
@@ -289,24 +302,26 @@ suite('mapconfig_named_layers_adapter', function() {
                 },
                 auth_tokens: ['valid2']
             });
-            mapConfigNamedLayersAdapter.getLayers(username, multipleLayersNamedMapLayerConfig.layers, pgConnection, function(err, layers, datasource) {
-                assert.ok(!err);
-                assert.equal(layers.length, 2);
+            mapConfigNamedLayersAdapter.getLayers(username, multipleLayersNamedMapLayerConfig.layers, pgConnection,
+                function(err, layers, datasource) {
+                    assert.ok(!err);
+                    assert.equal(layers.length, 2);
 
-                assert.equal(layers[0].type, 'mapnik');
-                assert.equal(layers[0].options.cartocss, '#layer { polygon-fill: ' + polygonColor + '; }');
-                assert.notEqual(datasource.getLayerDatasource(0), undefined);
+                    assert.equal(layers[0].type, 'mapnik');
+                    assert.equal(layers[0].options.cartocss, '#layer { polygon-fill: ' + polygonColor + '; }');
+                    assert.notEqual(datasource.getLayerDatasource(0), undefined);
 
-                assert.equal(layers[1].type, 'cartodb');
-                assert.equal(layers[1].options.cartocss, '#layer { marker-fill: ' + color + '; }');
-                assert.notEqual(datasource.getLayerDatasource(1), undefined);
+                    assert.equal(layers[1].type, 'cartodb');
+                    assert.equal(layers[1].options.cartocss, '#layer { marker-fill: ' + color + '; }');
+                    assert.notEqual(datasource.getLayerDatasource(1), undefined);
 
-                templateMaps.delTemplate(username, multipleLayersTemplateName, done);
-            });
+                    templateMaps.delTemplate(username, multipleLayersTemplateName, done);
+                }
+            );
         });
     });
 
-    suiteTeardown(function(done) {
+    after(function(done) {
         templateMaps.delTemplate(username, templateName, done);
     });
 });

test/unit/cartodb/template_maps.test.js

@@ -1,16 +1,15 @@
-var assert = require('assert')
-  //, _ = require('underscore')
-  , RedisPool = require('redis-mpool')
-  , TemplateMaps = require('../../../lib/cartodb/template_maps.js')
-  , test_helper = require('../../support/test_helper')
-  , Step = require('step')
-  , _ = require('underscore')
-  , tests = module.exports = {};
+require('../../support/test_helper');
 
-suite('template_maps', function() {
+var assert = require('assert');
+var RedisPool = require('redis-mpool');
+var TemplateMaps = require('../../../lib/cartodb/template_maps.js');
+var step = require('step');
+var _ = require('underscore');
+
+describe('template_maps', function() {
 
   // configure redis pool instance to use in tests
-  var redis_pool = RedisPool(global.environment.redis);
+  var redis_pool = new RedisPool(global.environment.redis);
 
     var wadusLayer = {
         options: {
@@ -20,24 +19,12 @@ suite('template_maps', function() {
         }
     };
 
-    var validTemplate = {
-        version:'0.0.1',
-        name: 'first',
-        auth: {},
-        layergroup: {
-            layers: [
-                wadusLayer
-            ]
-        }
-    };
-    var owner = 'me';
-    
-  test('does not accept template with unsupported version', function(done) {
+  it('does not accept template with unsupported version', function(done) {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
     var tpl = { version:'6.6.6',
       name:'k', auth: {}, layergroup: {layers:[wadusLayer]} };
-    Step(
+    step(
       function() {
         tmap.addTemplate('me', tpl, this);
       },
@@ -52,12 +39,12 @@ suite('template_maps', function() {
     );
   });
 
-  test('does not accept template with missing name', function(done) {
+  it('does not accept template with missing name', function(done) {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
     var tpl = { version:'0.0.1',
       auth: {}, layergroup: {layers:[wadusLayer]} };
-    Step(
+    step(
       function() {
         tmap.addTemplate('me', tpl, this);
       },
@@ -72,7 +59,7 @@ suite('template_maps', function() {
     );
   });
 
-  test('does not accept template with invalid name', function(done) {
+  it('does not accept template with invalid name', function(done) {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
     var tpl = { version:'0.0.1',
@@ -87,8 +74,7 @@ suite('template_maps', function() {
           done(new Error("Unexpected success with invalid name '" + n + "'"));
         }
         else if ( ! err.message.match(/template.*name/i) ) {
-          done(new Error("Unexpected error message with invalid name '" + n
-            + "': " + err));
+          done(new Error("Unexpected error message with invalid name '" + n + "': " + err));
         }
         else {
           testNext();
@@ -98,7 +84,7 @@ suite('template_maps', function() {
     testNext();
   });
 
-  test('does not accept template with invalid placeholder name', function(done) {
+  it('does not accept template with invalid placeholder name', function(done) {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
     var tpl = { version:'0.0.1',
@@ -115,8 +101,7 @@ suite('template_maps', function() {
           done(new Error("Unexpected success with invalid name '" + n + "'"));
         }
         else if ( ! err.message.match(/invalid.*name/i) ) {
-          done(new Error("Unexpected error message with invalid name '" + n
-            + "': " + err));
+          done(new Error("Unexpected error message with invalid name '" + n + "': " + err));
         }
         else {
           testNext();
@@ -126,7 +111,7 @@ suite('template_maps', function() {
     testNext();
   });
 
-  test('does not accept template with missing placeholder default', function(done) {
+  it('does not accept template with missing placeholder default', function(done) {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
     var tpl = { version:'0.0.1',
@@ -137,8 +122,7 @@ suite('template_maps', function() {
           done(new Error("Unexpected success with missing placeholder default"));
         }
         else if ( ! err.message.match(/missing default/i) ) {
-          done(new Error("Unexpected error message with missing placeholder default: "
-            + err));
+          done(new Error("Unexpected error message with missing placeholder default: " + err));
         }
         else {
           done();
@@ -146,7 +130,7 @@ suite('template_maps', function() {
       });
   });
 
-  test('does not accept template with missing placeholder type', function(done) {
+  it('does not accept template with missing placeholder type', function(done) {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
     var tpl = { version:'0.0.1',
@@ -157,8 +141,7 @@ suite('template_maps', function() {
           done(new Error("Unexpected success with missing placeholder type"));
         }
         else if ( ! err.message.match(/missing type/i) ) {
-          done(new Error("Unexpected error message with missing placeholder default: "
-            + err));
+          done(new Error("Unexpected error message with missing placeholder default: " + err));
         }
         else {
           done();
@@ -167,7 +150,7 @@ suite('template_maps', function() {
   });
 
   // See http://github.com/CartoDB/Windshaft-cartodb/issues/128
-  test('does not accept template with invalid token auth (undefined tokens)',
+  it('does not accept template with invalid token auth (undefined tokens)',
   function(done) {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
@@ -179,8 +162,7 @@ suite('template_maps', function() {
           done(new Error("Unexpected success with invalid token auth (undefined tokens)"));
         }
         else if ( ! err.message.match(/invalid 'token' authentication/i) ) {
-          done(new Error("Unexpected error message with invalid token auth (undefined tokens): "
-            + err));
+          done(new Error("Unexpected error message with invalid token auth (undefined tokens): " + err));
         }
         else {
           done();
@@ -188,14 +170,14 @@ suite('template_maps', function() {
       });
   });
 
-  test('add, get and delete a valid template', function(done) {
+  it('add, get and delete a valid template', function(done) {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
     var expected_failure = false;
     var tpl_id;
     var tpl = { version:'0.0.1',
       name: 'first', auth: {}, layergroup: {layers:[wadusLayer]} };
-    Step(
+    step(
       function() {
         tmap.addTemplate('me', tpl, this);
       },
@@ -224,15 +206,14 @@ suite('template_maps', function() {
     );
   });
 
-  test('add multiple templates, list them', function(done) {
+  it('add multiple templates, list them', function(done) {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
-    var expected_failure = false;
     var tpl1 = { version:'0.0.1', name: 'first', auth: {}, layergroup: {layers:[wadusLayer]} };
     var tpl1_id;
     var tpl2 = { version:'0.0.1', name: 'second', auth: {}, layergroup: {layers:[wadusLayer]} };
     var tpl2_id;
-    Step(
+    step(
       function addTemplate1() {
         tmap.addTemplate('me', tpl1, this);
       },
@@ -283,7 +264,7 @@ suite('template_maps', function() {
     );
   });
 
-  test('update templates', function(done) {
+  it('update templates', function(done) {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
     var expected_failure = false;
@@ -294,7 +275,7 @@ suite('template_maps', function() {
       layergroup: {layers:[wadusLayer]}
     };
     var tpl_id;
-    Step(
+    step(
       function addTemplate() {
         tmap.addTemplate(owner, tpl, this);
       },
@@ -323,7 +304,6 @@ suite('template_maps', function() {
       },
       function updateUnexistentTemplate(err) {
         if ( err && ! expected_failure) throw err;
-        expected_failure = false;
         assert.ok(err);
         assert.ok(err.message.match(/unsupported.*version/i), err);
         tpl.version = '0.0.1';
@@ -343,7 +323,7 @@ suite('template_maps', function() {
     );
   });
 
-  test('instanciate templates', function() {
+  it('instanciate templates', function() {
     var tmap = new TemplateMaps(redis_pool);
     assert.ok(tmap);
 
@@ -356,7 +336,7 @@ suite('template_maps', function() {
           color: { type: "css_color", default: "#a0fF9A" },
           name: { type: "sql_literal", default: "test" },
           zoom: { type: "number", default: "0" },
-          test_number: { type: "number", default: 23 },
+          test_number: { type: "number", default: 23 }
         },
         layergroup: {
           version: '1.0.0',
@@ -400,48 +380,48 @@ suite('template_maps', function() {
 
     // Invalid css_color
     var err = null;
-    try { inst = tmap.instance(tpl1, {color:'##ff00ff'}); }
+    try { tmap.instance(tpl1, {color:'##ff00ff'}); }
     catch (e) { err = e; }
     assert.ok(err);
     assert.ok(err.message.match(/invalid css_color/i), err);
 
     // Invalid css_color 2 (too few digits)
-    var err = null;
-    try { inst = tmap.instance(tpl1, {color:'#ff'}); }
+    err = null;
+    try { tmap.instance(tpl1, {color:'#ff'}); }
     catch (e) { err = e; }
     assert.ok(err);
     assert.ok(err.message.match(/invalid css_color/i), err);
 
     // Invalid css_color 3 (too many digits)
-    var err = null;
-    try { inst = tmap.instance(tpl1, {color:'#1234567'}); }
+    err = null;
+    try { tmap.instance(tpl1, {color:'#1234567'}); }
     catch (e) { err = e; }
     assert.ok(err);
     assert.ok(err.message.match(/invalid css_color/i), err);
 
     // Invalid number
-    var err = null;
-    try { inst = tmap.instance(tpl1, {zoom:'#'}); }
+    err = null;
+    try { tmap.instance(tpl1, {zoom:'#'}); }
     catch (e) { err = e; }
     assert.ok(err);
     assert.ok(err.message.match(/invalid number/i), err);
 
     // Invalid number 2
-    var err = null;
-    try { inst = tmap.instance(tpl1, {zoom:'23e'}); }
+    err = null;
+    try { tmap.instance(tpl1, {zoom:'23e'}); }
     catch (e) { err = e; }
     assert.ok(err);
     assert.ok(err.message.match(/invalid number/i), err);
 
     // Valid number
-    var err = null;
-    try { inst = tmap.instance(tpl1, {zoom:'-.23e10'}); }
+    err = null;
+    try { tmap.instance(tpl1, {zoom:'-.23e10'}); }
     catch (e) { err = e; }
     assert.ok(!err);
   });
 
   // Can set a limit on the number of user templates
-  test('can limit number of user templates', function(done) {
+  it('can limit number of user templates', function(done) {
     var tmap = new TemplateMaps(redis_pool, {
       max_user_templates: 2
     });
@@ -450,7 +430,7 @@ suite('template_maps', function() {
     var expectErr = false;
     var idMe = [];
     var idYou = [];
-    Step(
+    step(
       function oneForMe() {
         tpl.name = 'oneForMe';
         tmap.addTemplate('me', tpl, this);
@@ -470,7 +450,7 @@ suite('template_maps', function() {
         expectErr = true;
         tmap.addTemplate('me', tpl, this);
       },
-      function errForMe(err, id) {
+      function errForMe(err/*, id*/) {
         if ( err && ! expectErr ) throw err;
         expectErr = false;
         assert.ok(err);
@@ -508,7 +488,7 @@ suite('template_maps', function() {
         expectErr = true;
         tmap.addTemplate('you', tpl, this);
       },
-      function errForYou(err, id) {
+      function errForYou(err/*, id*/) {
         if ( err && ! expectErr ) throw err;
         expectErr = false;
         assert.ok(err);

test/unit/cartodb/template_maps_auth.test.js

@@ -1,11 +1,11 @@
+require('../../support/test_helper');
+
 var assert = require('assert');
 var RedisPool = require('redis-mpool');
-var TemplateMaps = require('../../../lib/cartodb/template_maps');
-var test_helper = require('../../support/test_helper');
-var Step = require('step');
-var tests = module.exports = {};
 
-suite('template_maps_auth', function() {
+var TemplateMaps = require('../../../lib/cartodb/template_maps');
+
+describe('template_maps_auth', function() {
 
     // configure redis pool instance to use in tests
     var redisPool = new RedisPool(global.environment.redis),
@@ -84,15 +84,15 @@ suite('template_maps_auth', function() {
     ];
 
     authorizationTestScenarios.forEach(function(testScenario) {
-        test(testScenario.desc, function(done) {
+        it(testScenario.desc, function(done) {
             var debugMessage = testScenario.expected ? 'should be authorized' : 'unexpectedly authorized';
             var result = templateMaps.isAuthorized(testScenario.template, testScenario.token);
             assert.equal(result, testScenario.expected, debugMessage);
             done();
-        })
+        });
     });
 
-    test("auth as 'open' string is authorized", function(done) {
+    it("auth as 'open' string is authorized", function(done) {
         var template = {
             name: 'wadus_template',
             auth: 'open'

test/unit/cartodb/template_maps_defaults.test.js

@@ -1,10 +1,11 @@
+require('../../support/test_helper');
+
 var assert = require('assert');
 var RedisPool = require('redis-mpool');
 var TemplateMaps = require('../../../lib/cartodb/template_maps.js');
-var test_helper = require('../../support/test_helper');
 var _ = require('underscore');
 
-suite('template_maps', function() {
+describe('template_maps', function() {
 
     var redisPool = new RedisPool(global.environment.redis),
         templateMaps = new TemplateMaps(redisPool);
@@ -88,7 +89,7 @@ suite('template_maps', function() {
     ];
 
     testScenarios.forEach(function(testScenario) {
-        test('adding template returns a new instance with ' + testScenario.desc, function(done) {
+        it('adding template returns a new instance with ' + testScenario.desc, function(done) {
 
             templateMaps.addTemplate(owner, testScenario.template, function(err, templateId, template) {
                 assert.ok(!err, 'Unexpected error adding template: ' + (err && err.message));

test/unit/cartodb/valid_template_maps.test.js

@@ -1,10 +1,11 @@
+require('../../support/test_helper');
+
 var assert = require('assert');
 var RedisPool = require('redis-mpool');
 var TemplateMaps = require('../../../lib/cartodb/template_maps.js');
-var test_helper = require('../../support/test_helper');
 var _ = require('underscore');
 
-suite('template_maps', function() {
+describe('template_maps', function() {
 
     var redisPool = new RedisPool(global.environment.redis),
         templateMaps = new TemplateMaps(redisPool);
@@ -87,7 +88,7 @@ suite('template_maps', function() {
     ];
 
     testScenarios.forEach(function(testScenario) {
-        test(testScenario.desc, function(done) {
+        it(testScenario.desc, function(done) {
 
             templateMaps.addTemplate(owner, testScenario.template, function(err) {