Release 4.8.0

Add urlTemplate URLs to metadata

NEWS.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 4.8.0
+Released 2018-01-04
+
+New features:
+ - Return url template in metadata #838.
+
+
+## 4.7.0
+Released 2018-01-03
+
+New features:
+ - Return tilejson in metadata #837.
+
+Bug fixes:
+ - Allow to create vector map-config for layers that doesn't have points. Layers with lines or polygons won't be aggregated by default.
+
+
 ## 4.6.0
 Released 2018-01-02
 

lib/cartodb/controllers/map.js

@@ -90,6 +90,7 @@ MapController.prototype.composeCreateMapMiddleware = function (useTemplate = fal
         this.setAnalysesMetadataToLayergroup(includeQuery),
         this.setTurboCartoMetadataToLayergroup(),
         this.setAggregationMetadataToLayergroup(),
+        this.setTilejsonMetadataToLayergroup(),
         this.setSurrogateKeyHeader(),
         this.sendResponse(),
         this.augmentError({ label, addContext })
@@ -313,6 +314,84 @@ MapController.prototype.augmentLayergroupData = function () {
     };
 };
 
+function getTemplateUrl(url) {
+    return url.https || url.http;
+}
+
+function getTilejson(tiles, grids) {
+    const tilejson = {
+        tilejson: '2.2.0',
+        tiles: tiles.https || tiles.http
+    };
+
+    if (grids) {
+        tilejson.grids = grids.https || grids.http;
+    }
+
+    return tilejson;
+}
+
+MapController.prototype.setTilejsonMetadataToLayergroup = function () {
+    return function augmentLayergroupTilejsonMiddleware (req, res, next) {
+        const { layergroup, user, mapconfig } = res.locals;
+
+        const isVectorOnlyMapConfig = mapconfig.isVectorOnlyMapConfig();
+        let hasMapnikLayers = false;
+        layergroup.metadata.layers.forEach((layerMetadata, index) => {
+            const layerId = mapconfig.getLayerId(index);
+            const rasterResource = `${layergroup.layergroupid}/${layerId}/{z}/{x}/{y}.png`;
+            if (mapconfig.layerType(index) === 'mapnik') {
+                hasMapnikLayers = true;
+                const vectorResource = `${layergroup.layergroupid}/${layerId}/{z}/{x}/{y}.mvt`;
+                const layerTilejson = {
+                    vector: getTilejson(this.resourceLocator.getTileUrls(user, vectorResource))
+                };
+                if (!isVectorOnlyMapConfig) {
+                    let grids = null;
+                    const layer = mapconfig.getLayer(index);
+                    if (layer.options.interactivity) {
+                        const gridResource = `${layergroup.layergroupid}/${layerId}/{z}/{x}/{y}.grid.json`;
+                        grids = this.resourceLocator.getTileUrls(user, gridResource);
+                    }
+                    layerTilejson.raster = getTilejson(
+                        this.resourceLocator.getTileUrls(user, rasterResource),
+                        grids
+                    );
+                }
+                layerMetadata.tilejson = layerTilejson;
+            } else {
+                layerMetadata.tilejson = {
+                    raster: getTilejson(this.resourceLocator.getTileUrls(user, rasterResource))
+                };
+            }
+        });
+
+        const tilejson = {};
+        const url = {};
+
+        if (hasMapnikLayers) {
+            const vectorResource = `${layergroup.layergroupid}/{z}/{x}/{y}.mvt`;
+            tilejson.vector = getTilejson(
+                this.resourceLocator.getTileUrls(user, vectorResource)
+            );
+            url.vector = getTemplateUrl(this.resourceLocator.getTemplateUrls(user, vectorResource));
+
+            if (!isVectorOnlyMapConfig) {
+                const rasterResource = `${layergroup.layergroupid}/{z}/{x}/{y}.png`;
+                tilejson.raster = getTilejson(
+                    this.resourceLocator.getTileUrls(user, rasterResource)
+                );
+                url.raster = getTemplateUrl(this.resourceLocator.getTemplateUrls(user, rasterResource));
+            }
+        }
+
+        layergroup.metadata.tilejson = tilejson;
+        layergroup.metadata.url = url;
+
+        next();
+    }.bind(this);
+};
+
 MapController.prototype.getAffectedTables = function () {
     return function getAffectedTablesMiddleware (req, res, next) {
         const { dbname, layergroup, user, mapconfig } = res.locals;

lib/cartodb/controllers/named_maps_admin.js

@@ -1,10 +1,6 @@
-var step = require('step');
-var assert = require('assert');
-var templateName = require('../backends/template_maps').templateName;
-
-var cors = require('../middleware/cors');
-var userMiddleware = require('../middleware/user');
-
+const { templateName } = require('../backends/template_maps');
+const cors = require('../middleware/cors');
+const userMiddleware = require('../middleware/user');
 
 /**
  * @param {AuthApi} authApi
@@ -20,211 +16,189 @@ function NamedMapsAdminController(authApi, templateMaps) {
 module.exports = NamedMapsAdminController;
 
 NamedMapsAdminController.prototype.register = function (app) {
+    const { base_url_templated } = app;
+
     app.post(
-        app.base_url_templated + '/',
+        `${base_url_templated}/`,
         cors(),
         userMiddleware,
-        this.create.bind(this)
+        this.checkContentType('POST', 'POST TEMPLATE'),
+        this.authorizedByAPIKey('create', 'POST TEMPLATE'),
+        this.create()
     );
 
     app.put(
-        app.base_url_templated + '/:template_id',
+        `${base_url_templated}/:template_id`,
         cors(),
         userMiddleware,
-        this.update.bind(this)
+        this.checkContentType('PUT', 'PUT TEMPLATE'),
+        this.authorizedByAPIKey('update', 'PUT TEMPLATE'),
+        this.update()
     );
 
     app.get(
-        app.base_url_templated + '/:template_id',
+        `${base_url_templated}/:template_id`,
         cors(),
         userMiddleware,
-        this.retrieve.bind(this)
+        this.authorizedByAPIKey('get', 'GET TEMPLATE'),
+        this.retrieve()
     );
 
     app.delete(
-        app.base_url_templated + '/:template_id',
+        `${base_url_templated}/:template_id`,
         cors(),
         userMiddleware,
-        this.destroy.bind(this)
+        this.authorizedByAPIKey('delete', 'DELETE TEMPLATE'),
+        this.destroy()
     );
 
     app.get(
-        app.base_url_templated + '/',
+        `${base_url_templated}/`,
         cors(),
         userMiddleware,
-        this.list.bind(this)
+        this.authorizedByAPIKey('list', 'GET TEMPLATE LIST'),
+        this.list()
     );
 
     app.options(
-        app.base_url_templated + '/:template_id',
+        `${base_url_templated}/:template_id`,
         cors('Content-Type')
     );
 };
 
-NamedMapsAdminController.prototype.create = function(req, res, next) {
-    var self = this;
+NamedMapsAdminController.prototype.authorizedByAPIKey = function (action, label) {
+    return function authorizedByAPIKeyMiddleware (req, res, next) {
+        const { user } = res.locals;
 
-    var cdbuser = res.locals.user;
+        this.authApi.authorizedByAPIKey(user, req, (err, authenticated) => {
+            if (err) {
+                return next(err);
+            }
 
-    step(
-        function checkPerms(){
-            self.authApi.authorizedByAPIKey(cdbuser, req, this);
-        },
-        function addTemplate(err, authenticated) {
-            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){
-            assert.ifError(err);
-            return { template_id: tpl_id };
-        },
-        finishFn(self, req, res, 'POST TEMPLATE', null, next)
-    );
+            if (!authenticated) {
+                const error = new Error(`Only authenticated user can ${action} templated maps`);
+                error.http_status = 403;
+                error.label = label;
+                return next(error);
+            }
+
+            next();
+        });
+    }.bind(this);
 };
 
-NamedMapsAdminController.prototype.update = function(req, res, next) {
-    var self = this;
-
-    var cdbuser = res.locals.user;
-    var template;
-    var tpl_id;
-
-    step(
-        function checkPerms(){
-            self.authApi.authorizedByAPIKey(cdbuser, req, this);
-        },
-        function updateTemplate(err, authenticated) {
-            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 = templateName(req.params.template_id);
-            self.templateMaps.updTemplate(cdbuser, tpl_id, template, this);
-        },
-        function prepareResponse(err){
-            assert.ifError(err);
-
-            return { template_id: tpl_id };
-        },
-        finishFn(self, req, res, 'PUT TEMPLATE', null, next)
-    );
+NamedMapsAdminController.prototype.checkContentType = function (action, label) {
+    return function checkContentTypeMiddleware (req, res, next) {
+        if (!req.is('application/json')) {
+            const error = new Error(`template ${action} data must be of type application/json`);
+            error.label = label;
+            return next(error);
+        }
+        next();
+    };
 };
 
-NamedMapsAdminController.prototype.retrieve = function(req, res, next) {
-    var self = this;
+NamedMapsAdminController.prototype.create = function () {
+    return function createTemplateMiddleware (req, res, next) {
+        const { user } = res.locals;
+        const template = req.body;
 
-    req.profiler.start('windshaft-cartodb.get_template');
+        this.templateMaps.addTemplate(user, template, (err, templateId) => {
+            if (err) {
+                return next(err);
+            }
 
-    var cdbuser = res.locals.user;
-    var tpl_id;
-    step(
-        function checkPerms(){
-            self.authApi.authorizedByAPIKey(cdbuser, req, this);
-        },
-        function getTemplate(err, authenticated) {
-            assert.ifError(err);
-            ifUnauthenticated(authenticated, 'Only authenticated users can get template maps');
+            res.status(200);
 
-            tpl_id = templateName(req.params.template_id);
-            self.templateMaps.getTemplate(cdbuser, tpl_id, this);
-        },
-        function prepareResponse(err, tpl_val) {
-            assert.ifError(err);
-            if ( ! tpl_val ) {
-                err = new Error("Cannot find template '" + tpl_id + "' of user '" + cdbuser + "'");
-                err.http_status = 404;
-                throw err;
+            const method = req.query.callback ? 'jsonp' : 'json';
+            res[method]({ template_id: templateId });
+        });
+    }.bind(this);
+};
+
+NamedMapsAdminController.prototype.update = function () {
+    return function updateTemplateMiddleware (req, res, next) {
+        const { user } = res.locals;
+        const template = req.body;
+        const templateId = templateName(req.params.template_id);
+
+        this.templateMaps.updTemplate(user, templateId, template, (err) => {
+            if (err) {
+                return next(err);
+            }
+
+            res.status(200);
+
+            const method = req.query.callback ? 'jsonp' : 'json';
+            res[method]({ template_id: templateId });
+        });
+    }.bind(this);
+};
+
+NamedMapsAdminController.prototype.retrieve =  function () {
+    return function retrieveTemplateMiddleware (req, res, next) {
+        req.profiler.start('windshaft-cartodb.get_template');
+
+        const { user } = res.locals;
+        const templateId = templateName(req.params.template_id);
+
+        this.templateMaps.getTemplate(user, templateId, (err, template) => {
+            if (err) {
+                return next(err);
+            }
+
+            if (!template) {
+                const error = new Error(`Cannot find template '${templateId}' of user '${user}'`);
+                error.http_status = 404;
+                return next(error);
             }
             // auth_id was added by ourselves,
             // so we remove it before returning to the user
-            delete tpl_val.auth_id;
-            return { template: tpl_val };
-        },
-        finishFn(self, req, res, 'GET TEMPLATE', null, next)
-    );
+            delete template.auth_id;
+
+            res.status(200);
+
+            const method = req.query.callback ? 'jsonp' : 'json';
+            res[method]({ template });
+        });
+    }.bind(this);
 };
 
-NamedMapsAdminController.prototype.destroy = function(req, res, next) {
-    var self = this;
+NamedMapsAdminController.prototype.destroy = function () {
+    return function destroyTemplateMiddleware (req, res, next) {
+        req.profiler.start('windshaft-cartodb.delete_template');
 
-    req.profiler.start('windshaft-cartodb.delete_template');
+        const { user } = res.locals;
+        const templateId = templateName(req.params.template_id);
 
-    var cdbuser = res.locals.user;
-    var tpl_id;
-    step(
-        function checkPerms(){
-            self.authApi.authorizedByAPIKey(cdbuser, req, this);
-        },
-        function deleteTemplate(err, authenticated) {
-            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*/){
-            assert.ifError(err);
-            return '';
-        },
-        finishFn(self, req, res, 'DELETE TEMPLATE', 204, next)
-    );
-};
-
-NamedMapsAdminController.prototype.list = function(req, res, next) {
-    var self = this;
-    req.profiler.start('windshaft-cartodb.get_template_list');
-
-    var cdbuser = res.locals.user;
-
-    step(
-        function checkPerms(){
-            self.authApi.authorizedByAPIKey(cdbuser, req, this);
-        },
-        function listTemplates(err, authenticated) {
-            assert.ifError(err);
-            ifUnauthenticated(authenticated, 'Only authenticated user can list templated maps');
-
-            self.templateMaps.listTemplates(cdbuser, this);
-        },
-        function prepareResponse(err, tpl_ids){
-            assert.ifError(err);
-            return { template_ids: tpl_ids };
-        },
-        finishFn(self, req, res, 'GET TEMPLATE LIST', null, next)
-    );
-};
-
-function finishFn(controller, req, res, description, status, next) {
-    return function finish(err, body){
-        if (err) {
-            err.label = description;
-            next(err);
-        } else {
-            res.status(status || 200);
-
-            if (req.query && req.query.callback) {
-                res.jsonp(body);
-            } else {
-                res.json(body);
+        this.templateMaps.delTemplate(user, templateId, (err/* , tpl_val */) => {
+            if (err) {
+                return next(err);
             }
-        }
-    };
-}
 
-function ifUnauthenticated(authenticated, description) {
-    if (!authenticated) {
-        var err = new Error(description);
-        err.http_status = 403;
-        throw err;
-    }
-}
+            res.status(204);
 
-function ifInvalidContentType(req, description) {
-    if (!req.is('application/json')) {
-        throw new Error(description);
-    }
-}
+            const method = req.query.callback ? 'jsonp' : 'json';
+            res[method]('');
+        });
+    }.bind(this);
+};
+
+NamedMapsAdminController.prototype.list = function () {
+    return function listTemplatesMiddleware (req, res, next) {
+        req.profiler.start('windshaft-cartodb.get_template_list');
+
+        const { user } = res.locals;
+
+        this.templateMaps.listTemplates(user, (err, templateIds) => {
+            if (err) {
+                return next(err);
+            }
+
+            res.status(200);
+
+            const method = req.query.callback ? 'jsonp' : 'json';
+            res[method]({ template_ids: templateIds });
+        });
+    }.bind(this);
+};

lib/cartodb/models/mapconfig/adapter/aggregation-mapconfig-adapter.js

@@ -132,7 +132,7 @@ module.exports = class AggregationMapConfigAdapter {
 
             const result = res.rows[0] || {};
 
-            if (!AggregationMapConfig.supportsGeometryType(result.type)) {
+            if (!mapConfig.isVectorOnlyMapConfig() && !AggregationMapConfig.supportsGeometryType(result.type)) {
                 const message = unsupportedGeometryTypeErrorMessage({ geometryType: result.type });
                 const error = new Error(message);
                 error.type = 'layer';
@@ -145,6 +145,10 @@ module.exports = class AggregationMapConfigAdapter {
                 return callback(error);
             }
 
+            if (mapConfig.isVectorOnlyMapConfig() && !AggregationMapConfig.supportsGeometryType(result.type)) {
+                return callback(null, false);
+            }
+
             if (!mapConfig.doesLayerReachThreshold(index, result.count)) {
                 return callback(null, false);
             }

lib/cartodb/models/resource-locator.js

@@ -21,69 +21,208 @@ function ResourceLocator(environment) {
 
 module.exports = ResourceLocator;
 
-ResourceLocator.prototype.getUrls = function(username, resource) {
+ResourceLocator.prototype.getTileUrls = function(username, resourcePath) {
     if (this.resourcesUrlTemplates) {
-        return this.getUrlsFromTemplate(username, resource);
-    }
-    var cdnDomain = getCdnDomain(this.environment.serverMetadata, resource);
-    if (cdnDomain) {
+        const urls = this.getUrlsFromTemplate(username, new TileResource(resourcePath));
         return {
-            http: 'http://' + cdnDomain.http + '/' + username + '/api/v1/map/' + resource,
-            https: 'https://' + cdnDomain.https + '/' + username + '/api/v1/map/' + resource
+            http: Array.isArray(urls.http) ? urls.http : [urls.http],
+            https: Array.isArray(urls.https) ? urls.https : [urls.https]
         };
+    }
+    var cdnUrls = getCdnUrls(this.environment.serverMetadata, username, new TileResource(resourcePath));
+    if (cdnUrls) {
+        return cdnUrls;
     } else {
         var port = this.environment.port;
         return {
-            http: 'http://' + username + '.' + 'localhost.lan:' + port +  '/api/v1/map/' + resource
+            http: [`http://${username}.localhost.lan:${port}/api/v1/map/${resourcePath}`]
         };
     }
 };
 
+ResourceLocator.prototype.getTemplateUrls = function(username, resourcePath) {
+    if (this.resourcesUrlTemplates) {
+        return this.getUrlsFromTemplate(username, new TemplateResource(resourcePath), true);
+    }
+    var cdnUrls = getCdnUrls(this.environment.serverMetadata, username, new TemplateResource(resourcePath));
+    if (cdnUrls) {
+        return cdnUrls;
+    } else {
+        var port = this.environment.port;
+        return {
+            http: {
+                urlTemplate: `http://${username}.localhost.lan:${port}/api/v1/map/${resourcePath}`,
+                subdomains: []
+            }
+        };
+    }
+};
 
-ResourceLocator.prototype.getUrlsFromTemplate = function(username, resource) {
-    var urls = {};
-    var cdnDomain = getCdnDomain(this.environment.serverMetadata, resource) || {};
+ResourceLocator.prototype.getUrls = function(username, resourcePath) {
+    if (this.resourcesUrlTemplates) {
+        return this.getUrlsFromTemplate(username, new Resource(resourcePath));
+    }
+    var cdnUrls = getCdnUrls(this.environment.serverMetadata, username, new Resource(resourcePath));
+    if (cdnUrls) {
+        return cdnUrls;
+    } else {
+        var port = this.environment.port;
+        return {
+            http: `http://${username}.localhost.lan:${port}/api/v1/map/${resourcePath}`
+        };
+    }
+};
 
-    if (this.resourcesUrlTemplates.http) {
-        urls.http = this.resourcesUrlTemplates.http({
-            cdn_url: cdnDomain.http,
+function urlForTemplate(tpl, username, cdnDomain, resource, templated) {
+    cdnDomain = cdnDomain || {};
+    if (templated) {
+        return {
+            urlTemplate: tpl({
+                cdn_url: (cdnDomain.hasOwnProperty('urlTemplate') ? cdnDomain.urlTemplate : cdnDomain),
+                user: username,
+                port: this.environment.port,
+                resource: resource.getPath()
+            }),
+            subdomains: cdnDomain.subdomains || []
+        };
+    }
+    if (Array.isArray(cdnDomain)) {
+        return cdnDomain.map(d => tpl({
+            cdn_url: d,
             user: username,
             port: this.environment.port,
-            resource: resource
+            resource: resource.getPath()
+        }));
+    } else {
+        return tpl({
+            cdn_url: cdnDomain,
+            user: username,
+            port: this.environment.port,
+            resource: resource.getPath()
         });
     }
+}
 
+ResourceLocator.prototype.getUrlsFromTemplate = function(username, resource, templated) {
+    var urls = {};
+    var cdnDomain = getCdnDomain(this.environment.serverMetadata, resource) || {};
+    if (this.resourcesUrlTemplates.http) {
+        urls.http = urlForTemplate(this.resourcesUrlTemplates.http, username, cdnDomain.http, resource, templated);
+    }
     if (this.resourcesUrlTemplates.https) {
-        urls.https = this.resourcesUrlTemplates.https({
-            cdn_url: cdnDomain.https,
-            user: username,
-            port: this.environment.port,
-            resource: resource
-        });
+        urls.https = urlForTemplate(this.resourcesUrlTemplates.https, username, cdnDomain.https, resource, templated);
     }
 
     return urls;
 };
 
+class Resource {
+    constructor (resourcePath) {
+        this.resourcePath = resourcePath;
+    }
+
+    getPath () {
+        return this.resourcePath;
+    }
+
+    getDomain (domain, subdomains) {
+        if (!subdomains) {
+            return domain;
+        }
+        return domain.replace('{s}', subdomain(subdomains, this.resourcePath));
+    }
+
+    getUrl (baseUrl, username, subdomains) {
+        let urls = getUrl(baseUrl, username, this.resourcePath);
+        if (subdomains) {
+            urls = urls.replace('{s}', subdomain(subdomains, this.resourcePath));
+        }
+        return urls;
+    }
+}
+
+class TileResource extends Resource {
+    constructor (resourcePath) {
+        super(resourcePath);
+    }
+
+    getDomain (domain, subdomains) {
+        if (!subdomains) {
+            return domain;
+        }
+        return subdomains.map(s => domain.replace('{s}', s));
+    }
+
+    getUrl (baseUrl, username, subdomains) {
+        if (!subdomains) {
+            return [super.getUrl(baseUrl, username)];
+        }
+        return subdomains.map(subdomain => {
+            return getUrl(baseUrl, username, this.resourcePath)
+                .replace('{s}', subdomain);
+        });
+    }
+}
+
+class TemplateResource extends Resource {
+    constructor (resourcePath) {
+        super(resourcePath);
+    }
+
+    getDomain (domain, subdomains) {
+        return {
+            urlTemplate: domain,
+            subdomains: subdomains || []
+        };
+    }
+
+    getUrl (baseUrl, username, subdomains) {
+        return {
+            urlTemplate: getUrl(baseUrl, username, this.resourcePath),
+            subdomains: subdomains || []
+        };
+    }
+}
+
+function getUrl(baseUrl, username, path) {
+    return `${baseUrl}/${username}/api/v1/map/${path}`;
+}
+
+function getCdnUrls(serverMetadata, username, resource) {
+    if (serverMetadata && serverMetadata.cdn_url) {
+        var cdnUrl = serverMetadata.cdn_url;
+        var httpUrls = resource.getUrl(`http://${cdnUrl.http}`, username);
+        var httpsUrls = resource.getUrl(`https://${cdnUrl.https}`, username);
+        if (cdnUrl.templates) {
+            var templates = cdnUrl.templates;
+            httpUrls = resource.getUrl(templates.http.url, username, templates.http.subdomains);
+            httpsUrls = resource.getUrl(templates.https.url, username, templates.https.subdomains);
+        }
+        return {
+            http: httpUrls,
+            https: httpsUrls,
+        };
+    }
+    return null;
+}
+
 function getCdnDomain(serverMetadata, resource) {
     if (serverMetadata && serverMetadata.cdn_url) {
         var cdnUrl = serverMetadata.cdn_url;
-        var http = cdnUrl.http;
-        var https = cdnUrl.https;
+        var httpDomain = resource.getDomain(cdnUrl.http);
+        var httpsDomain = resource.getDomain(cdnUrl.https);
         if (cdnUrl.templates) {
             var templates = cdnUrl.templates;
             var httpUrlTemplate = templates.http.url;
             var httpsUrlTemplate = templates.https.url;
-            http = httpUrlTemplate
-                .replace(/^(http[s]*:\/\/)/, '')
-                .replace('{s}', subdomain(templates.http.subdomains, resource));
-            https = httpsUrlTemplate
-                .replace(/^(http[s]*:\/\/)/, '')
-                .replace('{s}', subdomain(templates.https.subdomains, resource));
+            httpDomain = httpUrlTemplate.replace(/^(http[s]*:\/\/)/, '');
+            httpDomain = resource.getDomain(httpDomain, templates.http.subdomains);
+            httpsDomain = httpsUrlTemplate.replace(/^(http[s]*:\/\/)/, '');
+            httpsDomain = resource.getDomain(httpsDomain, templates.https.subdomains);
         }
         return {
-            http: http,
-            https: https,
+            http: httpDomain,
+            https: httpsDomain,
         };
     }
     return null;

package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "windshaft-cartodb",
-  "version": "4.6.0",
+  "version": "4.8.0",
   "description": "A map tile server for CartoDB",
   "keywords": [
     "cartodb"

test/acceptance/aggregation.js

@@ -385,6 +385,44 @@ describe('aggregation', function () {
                 });
             });
 
+            it('skip default aggregation by setting `aggregation: false` for just one layer', function (done) {
+                const mapConfig = createVectorMapConfig([
+                    {
+                        type: 'cartodb',
+                        options: {
+                            sql: POINTS_SQL_1,
+                            aggregation: {
+                                threshold: 1
+                            }
+                        }
+                    },
+                    {
+                        type: 'cartodb',
+                        options: {
+                            sql: POINTS_SQL_2,
+                            aggregation: false
+                        }
+                    }
+
+                ]);
+
+                this.testClient = new TestClient(mapConfig);
+
+                this.testClient.getLayergroup((err, body) => {
+                    if (err) {
+                        return done(err);
+                    }
+
+                    assert.equal(typeof body.metadata, 'object');
+                    assert.ok(Array.isArray(body.metadata.layers));
+
+                    assert.equal(body.metadata.layers[0].meta.aggregation.mvt, true);
+                    assert.equal(body.metadata.layers[1].meta.aggregation.mvt, false);
+
+                    done();
+                });
+            });
+
             it('when the aggregation param is not valid should respond with error', function (done) {
                 const mapConfig = createVectorMapConfig([
                     {
@@ -471,6 +509,8 @@ describe('aggregation', function () {
                         type: 'cartodb',
                         options: {
                             sql: POLYGONS_SQL_1,
+                            cartocss: '#layer { marker-width: [value]; }',
+                            cartocss_version: '2.3.0',
                             aggregation: {
                                 threshold: 1
                             }
@@ -1233,6 +1273,99 @@ describe('aggregation', function () {
                 });
             });
 
+
+            it('should skip aggregation w/o failing when is Vector Only MapConfig and layer has polygons',
+            function (done) {
+                this.mapConfig = createVectorMapConfig([
+                    {
+                        type: 'cartodb',
+                        options: {
+                            sql: POLYGONS_SQL_1
+                        }
+                    }
+                ]);
+
+                this.testClient = new TestClient(this.mapConfig);
+
+                this.testClient.getLayergroup((err, body) => {
+                    if (err) {
+                        return done(err);
+                    }
+
+                    assert.equal(typeof body.metadata, 'object');
+                    assert.ok(Array.isArray(body.metadata.layers));
+
+                    body.metadata.layers.forEach(layer => assert.ok(!layer.meta.aggregation.mvt));
+                    body.metadata.layers.forEach(layer => assert.ok(!layer.meta.aggregation.png));
+
+                    const options = {
+                        format: 'mvt'
+                    };
+
+                    this.testClient.getTile(0, 0, 0, options, (err, res, tile) => {
+                        if (err) {
+                            return done(err);
+                        }
+
+                        const tileJSON = tile.toJSON();
+
+                        assert.equal(tileJSON[0].features.length, 7);
+
+                        done();
+                    });
+                });
+            });
+
+            it('should skip aggregation for polygons (w/o failing) and aggregate when the layer has points',
+            function (done) {
+                this.mapConfig = createVectorMapConfig([
+                    {
+                        type: 'cartodb',
+                        options: {
+                            sql: POLYGONS_SQL_1
+                        }
+                    },
+                    {
+                        type: 'cartodb',
+                        options: {
+                            sql: POINTS_SQL_1,
+                            aggregation: {
+                                threshold: 1
+                            }
+                        }
+                    }
+                ]);
+
+                this.testClient = new TestClient(this.mapConfig);
+
+                this.testClient.getLayergroup((err, body) => {
+                    if (err) {
+                        return done(err);
+                    }
+
+                    assert.equal(typeof body.metadata, 'object');
+                    assert.ok(Array.isArray(body.metadata.layers));
+
+                    assert.equal(body.metadata.layers[0].meta.aggregation.mvt, false);
+                    assert.equal(body.metadata.layers[1].meta.aggregation.mvt, true);
+
+                    const options = {
+                        format: 'mvt'
+                    };
+
+                    this.testClient.getTile(0, 0, 0, options, (err, res, tile) => {
+                        if (err) {
+                            return done(err);
+                        }
+
+                        const tileJSON = tile.toJSON();
+
+                        assert.equal(tileJSON[0].features.length, 7);
+
+                        done();
+                    });
+                });
+            });
         });
     });
 });

test/acceptance/tilejson.js

@@ -0,0 +1,219 @@
+require('../support/test_helper');
+
+const assert = require('../support/assert');
+const TestClient = require('../support/test-client');
+
+describe('tilejson', function() {
+
+    function tilejsonValidation(tilejson, shouldHaveGrid = false) {
+        assert.equal(tilejson.tilejson, '2.2.0');
+
+        assert.ok(Array.isArray(tilejson.tiles), JSON.stringify(tilejson));
+        assert.ok(tilejson.tiles.length > 0);
+
+        if (shouldHaveGrid) {
+            assert.ok(Array.isArray(tilejson.grids));
+            assert.ok(tilejson.grids.length > 0);
+        }
+
+    }
+
+    const sql = 'SELECT * FROM populated_places_simple_reduced';
+    const cartocss = TestClient.CARTOCSS.POINTS;
+    const cartocss_version = '3.0.12';
+
+    const RASTER_LAYER = {
+        options: {
+            sql, cartocss, cartocss_version
+        }
+    };
+    const RASTER_INTERACTIVITY_LAYER = {
+        options: {
+            sql, cartocss, cartocss_version,
+            interactivity: ['cartodb_id']
+        }
+    };
+    const VECTOR_LAYER = {
+        options: {
+            sql
+        }
+    };
+    const PLAIN_LAYER = {
+        type: 'plain',
+        options: {
+            color: '#000000'
+        }
+    };
+
+    function mapConfig(layers) {
+        return {
+            version: '1.7.0',
+            layers: Array.isArray(layers) ? layers : [layers]
+        };
+    }
+
+    describe('per layer', function() {
+        it('should expose raster + vector tilejson for raster layers', function(done) {
+            var testClient = new TestClient(mapConfig(RASTER_LAYER));
+
+            testClient.getLayergroup(function(err, layergroupResult) {
+                assert.ok(!err, err);
+                const metadata = layergroupResult.metadata;
+                assert.ok(metadata);
+
+                assert.equal(metadata.layers.length, 1);
+
+                const layer = metadata.layers[0];
+                assert.deepEqual(Object.keys(layer.tilejson), ['vector', 'raster']);
+
+                Object.keys(layer.tilejson).forEach(k => {
+                    tilejsonValidation(layer.tilejson[k]);
+                });
+
+                testClient.drain(done);
+            });
+        });
+
+        it('should expose just the vector tilejson vector only layers', function(done) {
+            var testClient = new TestClient(mapConfig(VECTOR_LAYER));
+
+            testClient.getLayergroup(function(err, layergroupResult) {
+                assert.ok(!err, err);
+                const metadata = layergroupResult.metadata;
+                assert.ok(metadata);
+
+                assert.equal(metadata.layers.length, 1);
+
+                const layer = metadata.layers[0];
+                assert.deepEqual(Object.keys(layer.tilejson), ['vector']);
+
+                Object.keys(layer.tilejson).forEach(k => {
+                    tilejsonValidation(layer.tilejson[k]);
+                });
+
+                testClient.drain(done);
+            });
+        });
+
+        it('should expose just the raster tilejson plain layers', function(done) {
+            var testClient = new TestClient(mapConfig(PLAIN_LAYER));
+
+            testClient.getLayergroup(function(err, layergroupResult) {
+                assert.ok(!err, err);
+                const metadata = layergroupResult.metadata;
+                assert.ok(metadata);
+
+                assert.equal(metadata.layers.length, 1);
+
+                const layer = metadata.layers[0];
+                assert.deepEqual(Object.keys(layer.tilejson), ['raster']);
+
+                Object.keys(layer.tilejson).forEach(k => {
+                    tilejsonValidation(layer.tilejson[k]);
+                });
+
+                testClient.drain(done);
+            });
+        });
+
+        it('should expose grids for the raster layer with interactivity', function(done) {
+            var testClient = new TestClient(mapConfig(RASTER_INTERACTIVITY_LAYER));
+
+            testClient.getLayergroup(function(err, layergroupResult) {
+                assert.ok(!err, err);
+                const metadata = layergroupResult.metadata;
+                assert.ok(metadata);
+
+                assert.equal(metadata.layers.length, 1);
+
+                const layer = metadata.layers[0];
+                assert.deepEqual(Object.keys(layer.tilejson), ['vector', 'raster']);
+
+                tilejsonValidation(layer.tilejson.vector);
+                tilejsonValidation(layer.tilejson.raster, true);
+
+                testClient.drain(done);
+            });
+        });
+
+        it('should work with several layers', function(done) {
+            var testClient = new TestClient(mapConfig([RASTER_LAYER, RASTER_INTERACTIVITY_LAYER]));
+
+            testClient.getLayergroup(function(err, layergroupResult) {
+                assert.ok(!err, err);
+                const metadata = layergroupResult.metadata;
+                assert.ok(metadata);
+
+                assert.equal(metadata.layers.length, 2);
+
+                assert.deepEqual(Object.keys(metadata.layers[0].tilejson), ['vector', 'raster']);
+                tilejsonValidation(metadata.layers[0].tilejson.vector);
+                tilejsonValidation(metadata.layers[0].tilejson.raster);
+
+                assert.deepEqual(Object.keys(metadata.layers[1].tilejson), ['vector', 'raster']);
+                tilejsonValidation(metadata.layers[1].tilejson.vector);
+                tilejsonValidation(metadata.layers[1].tilejson.raster, true);
+
+                testClient.drain(done);
+            });
+        });
+    });
+
+    describe('root tilejson', function() {
+
+        it('should expose just the `vector` tilejson and URL when for vector only mapnik layers', function(done) {
+            var testClient = new TestClient(mapConfig(VECTOR_LAYER));
+
+            testClient.getLayergroup(function(err, layergroupResult) {
+                assert.ok(!err, err);
+                const metadata = layergroupResult.metadata;
+                assert.ok(metadata);
+
+                const tilejson = metadata.tilejson;
+                assert.deepEqual(Object.keys(tilejson), ['vector']);
+
+                Object.keys(tilejson).forEach(k => {
+                    tilejsonValidation(tilejson[k]);
+                });
+
+                const url = metadata.url;
+                assert.deepEqual(Object.keys(url), ['vector']);
+
+                assert.ok(url.vector.urlTemplate);
+                assert.ok(url.vector.subdomains);
+
+                testClient.drain(done);
+            });
+        });
+
+        it('should expose just the `vector` and `raster` tilejson and urls for mapnik layers', function(done) {
+            var testClient = new TestClient(mapConfig(RASTER_LAYER));
+
+            testClient.getLayergroup(function(err, layergroupResult) {
+                assert.ok(!err, err);
+                const metadata = layergroupResult.metadata;
+                assert.ok(metadata);
+
+                const tilejson = metadata.tilejson;
+                assert.deepEqual(Object.keys(tilejson), ['vector', 'raster']);
+
+                Object.keys(tilejson).forEach(k => {
+                    tilejsonValidation(tilejson[k]);
+                });
+
+                const url = metadata.url;
+                assert.deepEqual(Object.keys(url), ['vector', 'raster']);
+
+                assert.ok(url.vector.urlTemplate);
+                assert.ok(url.vector.subdomains);
+
+                assert.ok(url.raster.urlTemplate);
+                assert.ok(url.raster.subdomains);
+
+                testClient.drain(done);
+            });
+        });
+
+    });
+
+});

test/unit/cartodb/model/resource-locator.test.js

@@ -3,9 +3,10 @@ require('../../../support/test_helper');
 var assert = require('../../../support/assert');
 var ResourceLocator = require('../../../../lib/cartodb/models/resource-locator');
 
-describe('ResourceLocator.getUrls', function() {
+describe('ResourceLocator', function() {
     var USERNAME = 'username';
     var RESOURCE = 'wadus';
+    var TILE_RESOURCE = 'wadus/{z}/{x}/{y}.png';
     var HTTP_SUBDOMAINS = ['1', '2', '3', '4'];
     var HTTPS_SUBDOMAINS = ['a', 'b', 'c', 'd'];
 
@@ -15,118 +16,292 @@ describe('ResourceLocator.getUrls', function() {
         assert.ok(urls);
     });
 
-    var BASIC_ENVIRONMENT = {
-        serverMetadata: {
-            cdn_url: {
-                http: 'cdn.carto.com',
-                https: 'cdn.ssl.carto.com'
-            }
-        }
-    };
-    it('should return default urls when basic http and https domains are provided', function() {
-        var resourceLocator = new ResourceLocator(BASIC_ENVIRONMENT);
-        var urls = resourceLocator.getUrls(USERNAME, RESOURCE);
-        assert.ok(urls);
+    describe('basic', function() {
+
+        var BASIC_ENVIRONMENT = {
+            serverMetadata: {
+                cdn_url: {
+                    http: 'cdn.carto.com',
+                    https: 'cdn.ssl.carto.com'
+                }
+            }
+        };
+
+        describe('getUrls', function() {
+            it('should return default urls when basic http and https domains are provided', function() {
+                var resourceLocator = new ResourceLocator(BASIC_ENVIRONMENT);
+                var urls = resourceLocator.getUrls(USERNAME, RESOURCE);
+                assert.ok(urls);
+
+                assert.equal(urls.http, ['http://cdn.carto.com', USERNAME, 'api/v1/map', RESOURCE].join('/'));
+                assert.equal(urls.https, ['https://cdn.ssl.carto.com', USERNAME, 'api/v1/map', RESOURCE].join('/'));
+            });
+        });
+
+        describe('getTileUrls', function() {
+            it('should return default urls when basic http and https domains are provided', function() {
+                var resourceLocator = new ResourceLocator(BASIC_ENVIRONMENT);
+                var urls = resourceLocator.getTileUrls(USERNAME, TILE_RESOURCE);
+                assert.ok(urls);
+
+                assert.deepEqual(
+                    urls.http,
+                    [`http://cdn.carto.com/${USERNAME}/api/v1/map/${TILE_RESOURCE}`]
+                );
+                assert.deepEqual(
+                    urls.https,
+                    [`https://cdn.ssl.carto.com/${USERNAME}/api/v1/map/${TILE_RESOURCE}`]
+                );
+            });
+        });
+
+        describe('getTemplateUrls', function() {
+            it('should return default urls when basic http and https domains are provided', function() {
+                var resourceLocator = new ResourceLocator(BASIC_ENVIRONMENT);
+                var urls = resourceLocator.getTemplateUrls(USERNAME, TILE_RESOURCE);
+                assert.ok(urls);
+
+                assert.deepEqual(urls.http, {
+                    urlTemplate: `http://cdn.carto.com/${USERNAME}/api/v1/map/${TILE_RESOURCE}`,
+                    subdomains: []
+                });
+                assert.deepEqual(urls.https, {
+                    urlTemplate: `https://cdn.ssl.carto.com/${USERNAME}/api/v1/map/${TILE_RESOURCE}`,
+                    subdomains: []
+                });
+            });
+        });
 
-        assert.equal(urls.http, ['http://cdn.carto.com', USERNAME, 'api/v1/map', RESOURCE].join('/'));
-        assert.equal(urls.https, ['https://cdn.ssl.carto.com', USERNAME, 'api/v1/map', RESOURCE].join('/'));
     });
 
-    var RESOURCE_TEMPLATES_ENVIRONMENT = {
-        serverMetadata: {
-            cdn_url: {
-                http: 'cdn.carto.com',
-                https: 'cdn.ssl.carto.com'
-            }
-        },
-        resources_url_templates: {
-            http: 'http://{{=it.user}}.localhost.lan/api/v1/map',
-            https: 'https://{{=it.user}}.ssl.localhost.lan/api/v1/map'
-        }
-    };
-    it('resources_url_templates should take precedence over http and https domains', function() {
-        var resourceLocator = new ResourceLocator(RESOURCE_TEMPLATES_ENVIRONMENT);
-        var urls = resourceLocator.getUrls(USERNAME, RESOURCE);
-        assert.ok(urls);
+    describe('resource templates', function() {
+
+        var RESOURCE_TEMPLATES_ENVIRONMENT = {
+            serverMetadata: {
+                cdn_url: {
+                    http: 'cdn.carto.com',
+                    https: 'cdn.ssl.carto.com'
+                }
+            },
+            resources_url_templates: {
+                http: 'http://{{=it.user}}.localhost.lan/api/v1/map',
+                https: 'https://{{=it.user}}.ssl.localhost.lan/api/v1/map'
+            }
+        };
+
+        describe('getUrls', function() {
+            it('resources_url_templates should take precedence over http and https domains', function() {
+                var resourceLocator = new ResourceLocator(RESOURCE_TEMPLATES_ENVIRONMENT);
+                var urls = resourceLocator.getUrls(USERNAME, RESOURCE);
+                assert.ok(urls);
+
+                assert.equal(
+                    urls.http,
+                    ['http://' + USERNAME + '.localhost.lan', 'api/v1/map', RESOURCE].join('/')
+                );
+                assert.equal(
+                    urls.https,
+                    ['https://' + USERNAME + '.ssl.localhost.lan', 'api/v1/map', RESOURCE].join('/')
+                );
+            });
+        });
+
+        describe('getTileUrls', function() {
+            it('resources_url_templates should take precedence over http and https domains', function() {
+                var resourceLocator = new ResourceLocator(RESOURCE_TEMPLATES_ENVIRONMENT);
+                var urls = resourceLocator.getTileUrls(USERNAME, TILE_RESOURCE);
+                assert.ok(urls);
+
+                assert.deepEqual(
+                    urls.http,
+                    [`http://${USERNAME}.localhost.lan/api/v1/map/${TILE_RESOURCE}`]
+                );
+                assert.deepEqual(
+                    urls.https,
+                    [`https://${USERNAME}.ssl.localhost.lan/api/v1/map/${TILE_RESOURCE}`]
+                );
+            });
+        });
+
+        describe('getTemplateUrls', function() {
+            it('resources_url_templates should take precedence over http and https domains', function() {
+                var resourceLocator = new ResourceLocator(RESOURCE_TEMPLATES_ENVIRONMENT);
+                var urls = resourceLocator.getTemplateUrls(USERNAME, TILE_RESOURCE);
+                assert.ok(urls);
+
+                assert.deepEqual(urls.http, {
+                    urlTemplate: `http://${USERNAME}.localhost.lan/api/v1/map/${TILE_RESOURCE}`,
+                    subdomains: []
+                });
+                assert.deepEqual(urls.https, {
+                    urlTemplate: `https://${USERNAME}.ssl.localhost.lan/api/v1/map/${TILE_RESOURCE}`,
+                    subdomains: []
+                });
+            });
+        });
 
-        assert.equal(urls.http, ['http://' + USERNAME + '.localhost.lan', 'api/v1/map', RESOURCE].join('/'));
-        assert.equal(urls.https, ['https://' + USERNAME + '.ssl.localhost.lan', 'api/v1/map', RESOURCE].join('/'));
     });
 
-    var CDN_TEMPLATES_ENVIRONMENT = {
-        serverMetadata: {
-            cdn_url: {
-                http: 'cdn.carto.com',
-                https: 'cdn.ssl.carto.com',
-                templates: {
-                    http: {
-                        url: "http://{s}.cdn.carto.com",
-                        subdomains: HTTP_SUBDOMAINS
-                    },
-                    https: {
-                        url: "https://cdn_{s}.ssl.cdn.carto.com",
-                        subdomains: HTTPS_SUBDOMAINS
+    describe('cdn templates', function() {
+
+        var CDN_TEMPLATES_ENVIRONMENT = {
+            serverMetadata: {
+                cdn_url: {
+                    http: 'cdn.carto.com',
+                    https: 'cdn.ssl.carto.com',
+                    templates: {
+                        http: {
+                            url: "http://{s}.cdn.carto.com",
+                            subdomains: HTTP_SUBDOMAINS
+                        },
+                        https: {
+                            url: "https://cdn_{s}.ssl.cdn.carto.com",
+                            subdomains: HTTPS_SUBDOMAINS
+                        }
                     }
                 }
             }
-        }
-    };
-    it('cdn_url templates should take precedence over http and https domains', function() {
-        var resourceLocator = new ResourceLocator(CDN_TEMPLATES_ENVIRONMENT);
-        var urls = resourceLocator.getUrls(USERNAME, RESOURCE);
-        assert.ok(urls);
+        };
 
-        var httpSubdomain = ResourceLocator.subdomain(HTTP_SUBDOMAINS, RESOURCE);
-        var httpsSubdomain = ResourceLocator.subdomain(HTTPS_SUBDOMAINS, RESOURCE);
+        describe('getUrls', function() {
+            it('cdn_url templates should take precedence over http and https domains', function() {
+                var resourceLocator = new ResourceLocator(CDN_TEMPLATES_ENVIRONMENT);
+                var urls = resourceLocator.getUrls(USERNAME, RESOURCE);
+                assert.ok(urls);
+
+                var httpSubdomain = ResourceLocator.subdomain(HTTP_SUBDOMAINS, RESOURCE);
+                var httpsSubdomain = ResourceLocator.subdomain(HTTPS_SUBDOMAINS, RESOURCE);
+
+                assert.equal(
+                    urls.http,
+                    ['http://' + httpSubdomain + '.cdn.carto.com', USERNAME, 'api/v1/map', RESOURCE].join('/')
+                );
+                assert.equal(
+                    urls.https,
+                    ['https://cdn_' + httpsSubdomain + '.ssl.cdn.carto.com', USERNAME, 'api/v1/map', RESOURCE].join('/')
+                );
+            });
+        });
+
+        describe('getTileUrls', function() {
+            it('cdn_url templates should take precedence over http and https domains', function() {
+                var resourceLocator = new ResourceLocator(CDN_TEMPLATES_ENVIRONMENT);
+                var urls = resourceLocator.getTileUrls(USERNAME, TILE_RESOURCE);
+                assert.ok(urls);
+
+                assert.deepEqual(
+                    urls.http,
+                    HTTP_SUBDOMAINS
+                        .map(s => `http://${s}.cdn.carto.com/${USERNAME}/api/v1/map/${TILE_RESOURCE}`)
+                );
+                assert.deepEqual(
+                    urls.https,
+                    HTTPS_SUBDOMAINS
+                        .map(s => `https://cdn_${s}.ssl.cdn.carto.com/${USERNAME}/api/v1/map/${TILE_RESOURCE}`)
+                );
+            });
+        });
+
+        describe('getTemplateUrls', function() {
+            it('cdn_url templates should take precedence over http and https domains', function() {
+                var resourceLocator = new ResourceLocator(CDN_TEMPLATES_ENVIRONMENT);
+                var urls = resourceLocator.getTemplateUrls(USERNAME, TILE_RESOURCE);
+                assert.ok(urls);
+
+                assert.deepEqual(urls.http, {
+                    urlTemplate: `http://{s}.cdn.carto.com/${USERNAME}/api/v1/map/${TILE_RESOURCE}`,
+                    subdomains: HTTP_SUBDOMAINS
+                });
+                assert.deepEqual(urls.https, {
+                    urlTemplate: `https://cdn_{s}.ssl.cdn.carto.com/${USERNAME}/api/v1/map/${TILE_RESOURCE}`,
+                    subdomains: HTTPS_SUBDOMAINS
+                });
+            });
+        });
 
-        assert.equal(
-            urls.http,
-            ['http://' + httpSubdomain + '.cdn.carto.com', USERNAME, 'api/v1/map', RESOURCE].join('/')
-        );
-        assert.equal(
-            urls.https,
-            ['https://cdn_' + httpsSubdomain + '.ssl.cdn.carto.com', USERNAME, 'api/v1/map', RESOURCE].join('/')
-        );
     });
 
-    var CDN_URL_AND_RESOURCE_TEMPLATES_ENVIRONMENT = {
-        serverMetadata: {
-            cdn_url: {
-                http: 'cdn.carto.com',
-                https: 'cdn.ssl.carto.com',
-                templates: {
-                    http: {
-                        url: "http://{s}.cdn.carto.com",
-                        subdomains: HTTP_SUBDOMAINS
-                    },
-                    https: {
-                        url: "https://cdn_{s}.ssl.cdn.carto.com",
-                        subdomains: HTTPS_SUBDOMAINS
+    describe('cdn and resource templates', function() {
+
+        var CDN_URL_AND_RESOURCE_TEMPLATES_ENVIRONMENT = {
+            serverMetadata: {
+                cdn_url: {
+                    http: 'cdn.carto.com',
+                    https: 'cdn.ssl.carto.com',
+                    templates: {
+                        http: {
+                            url: "http://{s}.cdn.carto.com",
+                            subdomains: HTTP_SUBDOMAINS
+                        },
+                        https: {
+                            url: "https://cdn_{s}.ssl.cdn.carto.com",
+                            subdomains: HTTPS_SUBDOMAINS
+                        }
                     }
                 }
+            },
+            resources_url_templates: {
+                http: 'http://{{=it.cdn_url}}/u/{{=it.user}}/api/v1/map',
+                https: 'https://{{=it.cdn_url}}/u/{{=it.user}}/api/v1/map'
             }
-        },
-        resources_url_templates: {
-            http: 'http://{{=it.cdn_url}}/u/{{=it.user}}/api/v1/map',
-            https: 'https://{{=it.cdn_url}}/u/{{=it.user}}/api/v1/map'
-        }
-    };
-    it('should mix cdn_url templates and resources_url_templates', function() {
-        var resourceLocator = new ResourceLocator(CDN_URL_AND_RESOURCE_TEMPLATES_ENVIRONMENT);
-        var urls = resourceLocator.getUrls(USERNAME, RESOURCE);
-        assert.ok(urls);
+        };
 
-        var httpSubdomain = ResourceLocator.subdomain(HTTP_SUBDOMAINS, RESOURCE);
-        var httpsSubdomain = ResourceLocator.subdomain(HTTPS_SUBDOMAINS, RESOURCE);
+        describe('getUrls', function() {
+            it('should mix cdn_url templates and resources_url_templates', function() {
+                var resourceLocator = new ResourceLocator(CDN_URL_AND_RESOURCE_TEMPLATES_ENVIRONMENT);
+                var urls = resourceLocator.getUrls(USERNAME, RESOURCE);
+                assert.ok(urls);
+
+                var httpSubdomain = ResourceLocator.subdomain(HTTP_SUBDOMAINS, RESOURCE);
+                var httpsSubdomain = ResourceLocator.subdomain(HTTPS_SUBDOMAINS, RESOURCE);
+
+                assert.equal(
+                    urls.http,
+                    ['http://' + httpSubdomain + '.cdn.carto.com', 'u', USERNAME, 'api/v1/map', RESOURCE].join('/')
+                );
+                assert.equal(
+                    urls.https,
+                    `https://cdn_${httpsSubdomain}.ssl.cdn.carto.com/u/${USERNAME}/api/v1/map/${RESOURCE}`
+                );
+            });
+        });
+
+        describe('getTileUrls', function() {
+            it('should mix cdn_url templates and resources_url_templates', function() {
+                var resourceLocator = new ResourceLocator(CDN_URL_AND_RESOURCE_TEMPLATES_ENVIRONMENT);
+                var urls = resourceLocator.getTileUrls(USERNAME, TILE_RESOURCE);
+                assert.ok(urls);
+
+                assert.deepEqual(
+                    urls.http,
+                    HTTP_SUBDOMAINS
+                        .map(s => `http://${s}.cdn.carto.com/u/${USERNAME}/api/v1/map/${TILE_RESOURCE}`)
+                );
+                assert.deepEqual(
+                    urls.https,
+                    HTTPS_SUBDOMAINS
+                        .map(s => `https://cdn_${s}.ssl.cdn.carto.com/u/${USERNAME}/api/v1/map/${TILE_RESOURCE}`)
+                );
+            });
+        });
+
+        describe('getTemplateUrls', function() {
+            it('should mix cdn_url templates and resources_url_templates', function() {
+                var resourceLocator = new ResourceLocator(CDN_URL_AND_RESOURCE_TEMPLATES_ENVIRONMENT);
+                var urls = resourceLocator.getTemplateUrls(USERNAME, TILE_RESOURCE);
+                assert.ok(urls);
+
+                assert.deepEqual(urls.http, {
+                    urlTemplate: `http://{s}.cdn.carto.com/u/${USERNAME}/api/v1/map/${TILE_RESOURCE}`,
+                    subdomains: HTTP_SUBDOMAINS
+                });
+                assert.deepEqual(urls.https, {
+                    urlTemplate: `https://cdn_{s}.ssl.cdn.carto.com/u/${USERNAME}/api/v1/map/${TILE_RESOURCE}`,
+                    subdomains: HTTPS_SUBDOMAINS
+                });
+            });
+        });
 
-        assert.equal(
-            urls.http,
-            ['http://' + httpSubdomain + '.cdn.carto.com', 'u', USERNAME, 'api/v1/map', RESOURCE].join('/')
-        );
-        assert.equal(
-            urls.https,
-            ['https://cdn_' + httpsSubdomain + '.ssl.cdn.carto.com', 'u', USERNAME, 'api/v1/map', RESOURCE].join('/')
-        );
     });
 
 });