Windshaft-cartodb/test/acceptance/multilayer-test.js
2020-12-16 16:32:32 +01:00

1387 lines
62 KiB
JavaScript

'use strict';
var path = require('path');
var assert = require('../support/assert');
var _ = require('underscore');
var redis = require('redis');
var step = require('step');
var strftime = require('strftime');
var redisStatsDb = 5;
const mapnik = require('@carto/mapnik');
var semver = require('semver');
var helper = require('../support/test-helper');
var LayergroupToken = require('../../lib/models/layergroup-token');
var windshaftFixtures = path.join(__dirname, '/../../node_modules/windshaft/test/fixtures');
var IMAGE_EQUALS_TOLERANCE_PER_MIL = 20;
var IMAGE_EQUALS_HIGHER_TOLERANCE_PER_MIL = 25;
const createServer = require('../../lib/server');
var serverOptions = require('../../lib/server-options');
var QueryTables = require('cartodb-query-tables').queryTables;
['/api/v1/map', '/user/localhost/api/v1/map'].forEach(function (layergroupUrl) {
var suiteName = 'multilayer:postgres=layergroupUrl=' + layergroupUrl;
describe(suiteName, function () {
var server;
before(function () {
server = createServer(serverOptions);
server.setMaxListeners(0);
});
var keysToDelete;
beforeEach(function () {
keysToDelete = {};
});
afterEach(function (done) {
helper.deleteRedisKeys(keysToDelete, done);
});
var cdbQueryTablesFromPostgresEnabledValue = true;
var expectedLastUpdatedEpoch = 1234567890123; // this is hard-coded into SQLAPIEmu
var expectedLastUpdated = new Date(expectedLastUpdatedEpoch).toISOString();
var testUser = _.template(global.environment.postgres_auth_user, { user_id: 1 });
var testDatabase = testUser + '_db';
it('layergroup with 2 layers, each with its style', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select cartodb_id, ST_Translate(the_geom_webmercator, 5e6, 0) as the_geom_webmercator' +
' from test_table limit 2',
cartocss: '#layer { marker-fill:red; marker-width:32; marker-allow-overlap:true; }',
cartocss_version: '2.0.1',
interactivity: 'cartodb_id'
}
},
{
options: {
sql: 'select cartodb_id, ST_Translate(the_geom_webmercator, -5e6, 0) as the_geom_webmercator' +
' from test_table limit 2 offset 2',
cartocss: '#layer { marker-fill:blue; marker-allow-overlap:true; }',
cartocss_version: '2.0.2',
interactivity: 'cartodb_id'
}
}
]
};
var expectedToken; // = "e34dd7e235138a062f8ba7ad051aa3a7";
step(
function doPost () {
var next = this;
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
var parsedBody = JSON.parse(res.body);
assert.strictEqual(parsedBody.last_updated, expectedLastUpdated);
assert.strictEqual(res.headers['x-layergroup-id'], parsedBody.layergroupid);
expectedToken = parsedBody.layergroupid;
next(null, res);
});
},
function doGetTile (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + ':cb0/0/0/0.png',
method: 'GET',
headers: { host: 'localhost' },
encoding: 'binary'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'image/png');
// Check Cache-Control
var cc = res.headers['cache-control'];
assert.strictEqual(cc, 'public,max-age=31536000'); // 1 year
// Check X-Cache-Channel
cc = res.headers['x-cache-channel'];
assert.ok(cc);
var dbname = testDatabase;
assert.strictEqual(cc.substring(0, dbname.length), dbname);
if (!cdbQueryTablesFromPostgresEnabledValue) { // only test if it was using the SQL API
var jsonquery = cc.substring(dbname.length + 1);
var sentquery = JSON.parse(jsonquery);
var expectedQuery = [
layergroup.layers[0].options.sql, ';',
layergroup.layers[1].options.sql
].join('');
assert.strictEqual(sentquery.q, 'WITH querytables AS ( SELECT * FROM CDB_QueryTables($windshaft$' +
expectedQuery +
'$windshaft$) as tablenames )' +
' SELECT (SELECT tablenames FROM querytables), EXTRACT(EPOCH FROM max(updated_at)) as max' +
' FROM CDB_TableMetadata m' +
' WHERE m.tabname = any ((SELECT tablenames from querytables)::regclass[])');
}
assert.imageBufferIsSimilarToFile(res.body, 'test/fixtures/test_table_0_0_0_multilayer1.png',
IMAGE_EQUALS_HIGHER_TOLERANCE_PER_MIL, function (err/*, similarity */) {
next(err);
}
);
});
},
// See https://github.com/CartoDB/Windshaft-cartodb/issues/170
function doGetTileNoSignature (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/localhost@' + expectedToken + ':cb0/0/0/0.png',
method: 'GET',
headers: { host: 'localhost' },
encoding: 'binary'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 403, res.statusCode + ':' + res.body);
var parsed = JSON.parse(res.body);
var msg = parsed.errors[0];
assert.ok(msg.match(/permission denied/i), msg);
next(err);
});
},
function doGetGridLayer0 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + '/0/0/0/0.grid.json',
headers: { host: 'localhost' },
method: 'GET'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8');
assert.utfgridEqualsFile(res.body, 'test/fixtures/test_table_0_0_0_multilayer1.layer0.grid.json', 2,
function (err/*, similarity */) {
next(err);
});
});
},
function doGetGridLayer1 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + '/1/0/0/0.grid.json',
headers: { host: 'localhost' },
method: 'GET'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8');
assert.utfgridEqualsFile(res.body, 'test/fixtures/test_table_0_0_0_multilayer1.layer1.grid.json', 2,
function (err/*, similarity */) {
next(err);
});
});
},
function finish (err) {
keysToDelete['map_cfg|' + LayergroupToken.parse(expectedToken).token] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
done(err);
}
);
});
describe('server-metadata', function () {
var serverMetadata;
beforeEach(function () {
serverMetadata = global.environment.serverMetadata;
global.environment.serverMetadata = { cdn_url: { http: 'test', https: 'tests' } };
});
afterEach(function () {
global.environment.serverMetadata = serverMetadata;
});
it('should include serverMedata in the response', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select cartodb_id, ST_Translate(the_geom_webmercator, 5e6, 0) as the_geom_webmercator' +
' from test_table limit 2',
cartocss: '#layer { marker-fill:red; marker-width:32; marker-allow-overlap:true; }',
cartocss_version: '2.0.1'
}
}
]
};
step(
function doCreateGet () {
var next = this;
assert.response(server, {
url: layergroupUrl + '?config=' + encodeURIComponent(JSON.stringify(layergroup)),
method: 'GET',
headers: { host: 'localhost' }
}, {}, function (res, err) { next(err, res); });
},
function doCheckCreate (err, res) {
assert.ifError(err);
var parsed = JSON.parse(res.body);
keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
assert.ok(_.isEqual(parsed.cdn_url, global.environment.serverMetadata.cdn_url));
done();
}
);
});
});
it('get creation requests has cache', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select cartodb_id, the_geom_webmercator from test_table',
cartocss: '#layer { marker-fill:red; marker-width:32; marker-allow-overlap:true; }',
cartocss_version: '2.0.1',
interactivity: 'cartodb_id'
}
},
{
options: {
sql: 'select cartodb_id, the_geom_webmercator from test_table_2',
cartocss: '#layer { marker-fill:blue; marker-allow-overlap:true; }',
cartocss_version: '2.0.2',
interactivity: 'cartodb_id'
}
}
]
};
var expectedToken;
step(
function doCreateGet () {
var next = this;
assert.response(server, {
url: layergroupUrl + '?config=' + encodeURIComponent(JSON.stringify(layergroup)),
method: 'GET',
headers: { host: 'localhost' }
}, {}, function (res, err) { next(err, res); });
},
function doCheckCreate (err, res) {
assert.ifError(err);
assert.strictEqual(res.statusCode, 200, res.body);
var parsedBody = JSON.parse(res.body);
expectedToken = parsedBody.layergroupid.split(':')[0];
helper.checkCache(res);
helper.checkSurrogateKey(res, new QueryTables.QueryMetadata([
{ dbname: 'test_windshaft_cartodb_user_1_db', table_name: 'test_table', schema_name: 'public' },
{ dbname: 'test_windshaft_cartodb_user_1_db', table_name: 'test_table_2', schema_name: 'public' }
]).key().join(' '));
keysToDelete['map_cfg|' + expectedToken] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
done();
}
);
});
it('get creation has no cache if sql is bogus', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select bogus(0,0) as the_geom_webmercator',
cartocss: '#layer { polygon-fill: red; }',
cartocss_version: '2.0.1'
}
}
]
};
assert.response(server, {
url: layergroupUrl + '?config=' + encodeURIComponent(JSON.stringify(layergroup)),
method: 'GET',
headers: { host: 'localhost' }
}, {}, function (res) {
assert.notStrictEqual(res.statusCode, 200);
helper.checkNoCache(res);
done();
});
});
it('get creation has no cache if cartocss is not valid', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select cartodb_id, ST_Translate(the_geom_webmercator, 5e6, 0) as the_geom_webmercator' +
' from test_table limit 2',
cartocss: '#layer { invalid-rule:red; }',
cartocss_version: '2.0.1'
}
}
]
};
assert.response(server, {
url: layergroupUrl + '?config=' + encodeURIComponent(JSON.stringify(layergroup)),
method: 'GET',
headers: { host: 'localhost' }
}, {}, function (res) {
assert.notStrictEqual(res.statusCode, 200);
helper.checkNoCache(res);
done();
});
});
it('layergroup can hold substitution tokens', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select 1 as cartodb_id, ST_Buffer(!bbox!, -32*greatest(!pixel_width!,!pixel_height!))' +
' as the_geom_webmercator from test_table limit 1',
cartocss: '#layer { polygon-fill:red; }',
cartocss_version: '2.0.1',
interactivity: 'cartodb_id'
}
}
]
};
var expectedToken; // = "6d8e4ad5458e2d25cf0eef38e38717a6";
step(
function doPost () {
var next = this;
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
var parsedBody = JSON.parse(res.body);
assert.strictEqual(parsedBody.last_updated, expectedLastUpdated);
if (expectedToken) {
assert.strictEqual(parsedBody.layergroupid, expectedToken + ':' + expectedLastUpdatedEpoch);
} else {
expectedToken = parsedBody.layergroupid.split(':')[0];
}
next(null, res);
});
},
function doGetTile1 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + ':cb10/1/0/0.png',
method: 'GET',
headers: { host: 'localhost' },
encoding: 'binary'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'image/png');
// Check X-Cache-Channel
var cc = res.headers['x-cache-channel'];
assert.ok(cc);
var dbname = testDatabase;
assert.strictEqual(cc.substring(0, dbname.length), dbname);
if (!cdbQueryTablesFromPostgresEnabledValue) { // only test if it was using the SQL API
var jsonquery = cc.substring(dbname.length + 1);
var sentquery = JSON.parse(jsonquery);
var expectedQuery = layergroup.layers[0].options.sql
.replace(/!bbox!/g, 'ST_MakeEnvelope(0,0,0,0)')
.replace(/!pixel_width!/g, '1')
.replace(/!pixel_height!/g, '1');
assert.strictEqual(sentquery.q, 'WITH querytables AS ( SELECT * FROM CDB_QueryTables($windshaft$' +
expectedQuery +
'$windshaft$) as tablenames )' +
' SELECT (SELECT tablenames FROM querytables), EXTRACT(EPOCH FROM max(updated_at)) as max' +
' FROM CDB_TableMetadata m' +
' WHERE m.tabname = any ((SELECT tablenames from querytables)::regclass[])');
}
var referenceImagePath = 'test/fixtures/test_multilayer_bbox.png';
assert.imageBufferIsSimilarToFile(res.body, referenceImagePath, IMAGE_EQUALS_TOLERANCE_PER_MIL,
function (err/*, similarity */) {
next(err);
});
});
},
function doGetTile4 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + ':cb11/4/0/0.png',
method: 'GET',
headers: { host: 'localhost' },
encoding: 'binary'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'image/png');
// Check X-Cache-Channel
var cc = res.headers['x-cache-channel'];
assert.ok(cc);
var dbname = testDatabase;
assert.strictEqual(cc.substring(0, dbname.length), dbname);
if (!cdbQueryTablesFromPostgresEnabledValue) { // only test if it was using the SQL API
var jsonquery = cc.substring(dbname.length + 1);
var sentquery = JSON.parse(jsonquery);
var expectedQuery = layergroup.layers[0].options.sql
.replace('!bbox!', 'ST_MakeEnvelope(0,0,0,0)')
.replace('!pixel_width!', '1')
.replace('!pixel_height!', '1');
assert.strictEqual(sentquery.q, 'WITH querytables AS ( SELECT * FROM CDB_QueryTables($windshaft$' +
expectedQuery +
'$windshaft$) as tablenames )' +
' SELECT (SELECT tablenames FROM querytables), EXTRACT(EPOCH FROM max(updated_at)) as max' +
' FROM CDB_TableMetadata m' +
' WHERE m.tabname = any ((SELECT tablenames from querytables)::regclass[])');
}
var referenceImagePath = 'test/fixtures/test_multilayer_bbox.png';
assert.imageBufferIsSimilarToFile(res.body, referenceImagePath, IMAGE_EQUALS_TOLERANCE_PER_MIL,
function (err/*, similarity */) {
next(err);
});
});
},
function doGetGrid1 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + '/0/1/0/0.grid.json',
headers: { host: 'localhost' },
method: 'GET'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8');
assert.utfgridEqualsFile(res.body, 'test/fixtures/test_multilayer_bbox.grid.json', 2,
function (err/*, similarity */) {
next(err);
});
});
},
function doGetGrid4 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + '/0/4/0/0.grid.json',
headers: { host: 'localhost' },
method: 'GET'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8');
assert.utfgridEqualsFile(res.body, 'test/fixtures/test_multilayer_bbox.grid.json', 2, next);
});
},
function finish (err) {
keysToDelete['map_cfg|' + expectedToken] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
done(err);
}
);
});
it('layergroup creation raises mapviews counter', function (done) {
var layergroup = {
stat_tag: 'random_tag',
version: '1.0.0',
layers: [
{
options: {
sql: 'select 1 as cartodb_id, !pixel_height! as h,' +
' ST_Buffer(!bbox!, -32*greatest(!pixel_width!,!pixel_height!)) as the_geom_webmercator',
cartocss: '#layer { polygon-fill:red; }',
cartocss_version: '2.0.1'
}
}
]
};
var statskey = 'user:localhost:mapviews';
var redisStatsClient = redis.createClient(
{
port: global.environment.redis.port,
host: global.environment.redis.host
});
var expectedToken; // will be set on first post and checked on second
var now = strftime('%Y%m%d', new Date());
step(
function cleanStats () {
var next = this;
redisStatsClient.select(redisStatsDb, function (err) {
if (err) {
next(err);
} else {
redisStatsClient.del(statskey + ':global', next);
}
});
},
function doPost1 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
expectedToken = JSON.parse(res.body).layergroupid;
redisStatsClient.zscore(statskey + ':global', now, next);
});
},
function checkGlobalStats1 (err, val) {
assert.ifError(err);
assert.strictEqual(val, '1', 'Expected score of ' + now + ' in ' + statskey + ':global to be 1, got ' + val);
redisStatsClient.zscore(statskey + ':stat_tag:random_tag', now, this);
},
function checkTagStats1DoPost2 (err, val) {
assert.ifError(err);
assert.strictEqual(val, '1', 'Expected score of ' + now + ' in ' + statskey + ':stat_tag:' + layergroup.stat_tag +
' to be 1, got ' + val);
var next = this;
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(JSON.parse(res.body).layergroupid, expectedToken);
redisStatsClient.zscore(statskey + ':global', now, next);
});
},
function checkGlobalStats2 (err, val) {
assert.ifError(err);
assert.strictEqual(val, '2', 'Expected score of ' + now + ' in ' + statskey + ':global to be 2, got ' + val);
redisStatsClient.zscore(statskey + ':stat_tag:' + layergroup.stat_tag, now, this);
},
function checkTagStats2 (err, val) {
assert.ifError(err);
assert.strictEqual(val, '2', 'Expected score of ' + now + ' in ' + statskey + ':stat_tag:' + layergroup.stat_tag +
' to be 2, got ' + val);
return 1;
},
function finish (err) {
if (err) {
return done(err);
}
// strip epoch
expectedToken = expectedToken.split(':')[0];
keysToDelete['map_cfg|' + expectedToken] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
keysToDelete[statskey + ':stat_tag:' + layergroup.stat_tag] = 5;
done();
}
);
});
it('layergroup creation fails if CartoCSS is bogus', function (done) {
var layergroup = {
stat_tag: 'random_tag',
version: '1.0.0',
layers: [
{
options: {
sql: 'select 1 as cartodb_id, !pixel_height! as h,' +
'ST_Buffer(!bbox!, -32*greatest(!pixel_width!,!pixel_height!)) as the_geom_webmercator',
cartocss: '#layer { polygon-fit:red; }',
cartocss_version: '2.0.1'
}
}
]
};
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 400, res.body);
var parsed = JSON.parse(res.body);
assert.ok(parsed.errors[0].match(/^style0/));
assert.ok(parsed.errors[0].match(/Unrecognized rule: polygon-fit/));
done();
});
});
// Also tests that server doesn't crash:
// see http://github.com/CartoDB/Windshaft-cartodb/issues/109
it('layergroup creation fails if sql is bogus', function (done) {
var layergroup = {
stat_tag: 'random_tag',
version: '1.0.0',
layers: [
{
options: {
sql: 'select bogus(0,0) as the_geom_webmercator',
cartocss: '#layer { polygon-fill:red; }',
cartocss_version: '2.0.1'
}
}
]
};
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 400, res.statusCode + ': ' + res.body);
var parsed = JSON.parse(res.body);
var msg = parsed.errors[0];
assert.ok(msg.match(/bogus.*exist/), msg);
helper.checkNoCache(res);
done();
});
});
it('layergroup with 2 private-table layers', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select * from test_table_private_1 where cartodb_id=1',
cartocss: '#layer { marker-fill:red; marker-width:32; marker-allow-overlap:true; }',
cartocss_version: '2.1.0',
interactivity: 'cartodb_id'
}
},
{
options: {
sql: 'select * from test_table_private_1 where cartodb_id=2',
cartocss: '#layer { marker-fill:blue; marker-allow-overlap:true; }',
cartocss_version: '2.1.0',
interactivity: 'cartodb_id'
}
}
]
};
var expectedToken; // = "b4ed64d93a411a59f330ab3d798e4009";
step(
function doPost () {
var next = this;
assert.response(server, {
url: layergroupUrl + '?map_key=1234',
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
var parsedBody = JSON.parse(res.body);
assert.strictEqual(parsedBody.last_updated, expectedLastUpdated);
if (expectedToken) {
assert.strictEqual(parsedBody.layergroupid, expectedToken + ':' + expectedLastUpdatedEpoch);
} else {
expectedToken = parsedBody.layergroupid.split(':')[0];
}
next(null, res);
});
},
function doGetTile (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + ':cb0/0/0/0.png?map_key=1234',
method: 'GET',
headers: { host: 'localhost' },
encoding: 'binary'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'image/png');
// Check X-Cache-Channel
var cc = res.headers['x-cache-channel'];
assert.ok(cc);
var dbname = testDatabase;
assert.strictEqual(cc.substring(0, dbname.length), dbname);
next(err);
});
},
function doGetGridLayer0 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + '/0/0/0/0.grid.json?map_key=1234',
headers: { host: 'localhost' },
method: 'GET'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
next(err);
});
},
function doGetGridLayer1 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + '/1/0/0/0.grid.json?map_key=1234',
headers: { host: 'localhost' },
method: 'GET'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8');
next(err);
});
},
function doGetTileUnauth (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + ':cb0/0/0/0.png',
method: 'GET',
headers: { host: 'localhost' },
encoding: 'binary'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 403);
var re = new RegExp('permission denied');
assert.ok(res.body.match(re), 'No "permission denied" error: ' + res.body);
next(err);
});
},
function doGetGridLayer0Unauth (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + '/0/0/0/0.grid.json',
headers: { host: 'localhost' },
method: 'GET'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 403);
var re = new RegExp('permission denied');
assert.ok(res.body.match(re), 'No "permission denied" error: ' + res.body);
next(err);
});
},
function doGetGridLayer1Unauth (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + '/1/0/0/0.grid.json',
headers: { host: 'localhost' },
method: 'GET'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 403);
var re = new RegExp('permission denied');
assert.ok(res.body.match(re), 'No "permission denied" error: ' + res.body);
next(err);
});
},
function finish (err) {
keysToDelete['map_cfg|' + expectedToken] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
done(err);
}
);
});
// See https://github.com/CartoDB/Windshaft-cartodb/issues/152
it('x-cache-channel still works for GETs after tiler restart', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select * from test_table where cartodb_id=1',
cartocss: '#layer { marker-fill:red; marker-width:32; marker-allow-overlap:true; }',
cartocss_version: '2.1.0',
interactivity: 'cartodb_id'
}
}
]
};
var expectedToken; // = "b4ed64d93a411a59f330ab3d798e4009";
step(
function doPost () {
var next = this;
assert.response(server, {
url: layergroupUrl + '?map_key=1234',
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res, err) { next(err, res); });
},
function checkPost (err, res) {
assert.ifError(err);
assert.strictEqual(res.statusCode, 200, res.body);
var parsedBody = JSON.parse(res.body);
assert.strictEqual(parsedBody.last_updated, expectedLastUpdated);
if (expectedToken) {
assert.strictEqual(parsedBody.layergroupid, expectedToken + ':' + expectedLastUpdatedEpoch);
} else {
expectedToken = parsedBody.layergroupid.split(':')[0];
}
return null;
},
function doGet0 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + ':cb0/0/0/0.png?map_key=1234',
method: 'GET',
headers: { host: 'localhost' },
encoding: 'binary'
}, {}, function (res, err) { next(err, res); });
},
function doCheck0 (err, res) {
assert.ifError(err);
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'image/png');
// Check X-Cache-Channel
var cc = res.headers['x-cache-channel'];
assert.ok(cc, 'Missing X-Cache-Channel');
var dbname = testDatabase;
assert.strictEqual(cc.substring(0, dbname.length), dbname);
return null;
},
function doRestartServer (err/*, res */) {
assert.ifError(err);
// hack simulating restart...
server = createServer(serverOptions);
return null;
},
function doGet1 (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + ':cb0/0/0/0.png?map_key=1234',
method: 'GET',
headers: { host: 'localhost' },
encoding: 'binary'
}, {}, function (res, err) { next(err, res); });
},
function doCheck1 (err, res) {
assert.ifError(err);
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'image/png');
// Check X-Cache-Channel
var cc = res.headers['x-cache-channel'];
assert.ok(cc, 'Missing X-Cache-Channel on restart');
var dbname = testDatabase;
assert.strictEqual(cc.substring(0, dbname.length), dbname);
return null;
},
function finish (err) {
keysToDelete['map_cfg|' + expectedToken] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
done(err);
}
);
});
// https://github.com/cartodb/Windshaft-cartodb/issues/81
it('invalid text-name in CartoCSS', function (done) {
var layergroup = {
version: '1.0.1',
layers: [
{
options: {
sql: "select 1 as cartodb_id, 'SRID=3857;POINT(0 0)'::geometry as the_geom_webmercator",
cartocss: '#sample { text-name: cartodb_id; text-face-name: "Dejagnu"; }',
cartocss_version: '2.1.0'
}
}
]
};
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 400, res.statusCode + ': ' + res.body);
var parsed = JSON.parse(res.body);
assert.strictEqual(parsed.errors.length, 1);
var errmsg = parsed.errors[0];
assert.ok(errmsg.match(/text-face-name.*Dejagnu/), parsed.errors.toString());
done();
});
});
it('quotes CartoCSS', function (done) {
var layergroup = {
version: '1.0.1',
layers: [
{
options: {
sql: "select 'single''quote' as n, 'SRID=3857;POINT(0 0)'::geometry as the_geom_webmercator",
cartocss: '#s [n="single\'quote" ] { marker-fill:red; }',
cartocss_version: '2.1.0'
}
},
{
options: {
sql: "select 'double\"quote' as n, 'SRID=3857;POINT(2 0)'::geometry as the_geom_webmercator",
cartocss: '#s [n="double\\"quote" ] { marker-fill:red; }',
cartocss_version: '2.1.0'
}
}
]
};
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.statusCode + ': ' + res.body);
keysToDelete['map_cfg|' + LayergroupToken.parse(JSON.parse(res.body).layergroupid).token] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
done();
});
});
// See https://github.com/CartoDB/Windshaft-cartodb/issues/87
it('exponential notation in CartoCSS filter values', function (done) {
var layergroup = {
version: '1.0.1',
layers: [
{
options: {
sql: "select .4 as n, 'SRID=3857;POINT(0 0)'::geometry as the_geom_webmercator",
cartocss: '#s [n<=.2e-2] { marker-fill:red; }',
cartocss_version: '2.1.0'
}
}
]
};
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.statusCode + ': ' + res.body);
keysToDelete['map_cfg|' + LayergroupToken.parse(JSON.parse(res.body).layergroupid).token] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
done();
});
});
// See https://github.com/CartoDB/Windshaft-cartodb/issues/93
if (semver.satisfies(mapnik.versions.mapnik, '2.3.x')) {
it('accepts unused directives', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: "select 'SRID=3857;POINT(0 0)'::geometry as the_geom_webmercator",
cartocss: '#layer { point-transform:"scale(20)"; }',
cartocss_version: '2.0.1'
}
}
]
};
var expectedToken; // = "e34dd7e235138a062f8ba7ad051aa3a7";
step(
function doPost () {
var next = this;
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
var parsedBody = JSON.parse(res.body);
if (expectedToken) {
assert.strictEqual(parsedBody.layergroupid, expectedToken + ':' + expectedLastUpdatedEpoch);
assert.strictEqual(res.headers['x-layergroup-id'], parsedBody.layergroupid);
} else {
var tokenComponents = parsedBody.layergroupid.split(':');
expectedToken = tokenComponents[0];
expectedLastUpdatedEpoch = tokenComponents[1];
}
next(null, res);
});
},
function doGetTile (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + ':cb0/0/0/0.png',
method: 'GET',
headers: { host: 'localhost' },
encoding: 'binary'
}, {}, function (res) {
assert.strictEqual(res.statusCode, 200, res.body);
assert.strictEqual(res.headers['content-type'], 'image/png');
assert.imageBufferIsSimilarToFile(res.body, windshaftFixtures + '/test_default_mapnik_point.png',
IMAGE_EQUALS_TOLERANCE_PER_MIL, function (err/*, similarity */) {
next(err);
}
);
});
},
function finish (err) {
keysToDelete['user:localhost:mapviews:global'] = 5;
keysToDelete['map_cfg|' + expectedToken] = 0;
done(err);
}
);
});
}
// See https://github.com/CartoDB/Windshaft-cartodb/issues/91
// and https://github.com/CartoDB/Windshaft-cartodb/issues/38
it('tiles for private tables can be fetched with api_key', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select * from test_table_private_1 LIMIT 0',
cartocss: '#layer { marker-fill:red; }',
cartocss_version: '2.0.1'
}
}
]
};
var expectedToken; // = "e34dd7e235138a062f8ba7ad051aa3a7";
step(
function doPost () {
var next = this;
assert.response(server, {
url: layergroupUrl + '?api_key=1234',
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res) { next(null, res); });
},
function checkResult (err, res) {
assert.ifError(err);
var next = this;
assert.strictEqual(res.statusCode, 200, res.statusCode + ': ' + res.body);
var parsedBody = JSON.parse(res.body);
if (expectedToken) {
assert.strictEqual(parsedBody.layergroupid, expectedToken + ':' + expectedLastUpdatedEpoch);
assert.strictEqual(res.headers['x-layergroup-id'], parsedBody.layergroupid);
} else {
var tokenComponents = parsedBody.layergroupid.split(':');
expectedToken = tokenComponents[0];
expectedLastUpdatedEpoch = tokenComponents[1];
}
next(null, res);
},
function doGetTile (err) {
assert.ifError(err);
var next = this;
assert.response(server, {
url: layergroupUrl + '/' + expectedToken + ':cb0/0/0/0.png?api_key=1234',
method: 'GET',
headers: { host: 'localhost' },
encoding: 'binary'
}, {}, function (res) { next(null, res); });
},
function checkGetTile (err, res) {
if (err) {
return done(err);
}
assert.strictEqual(res.statusCode, 200, res.body);
keysToDelete['user:localhost:mapviews:global'] = 5;
keysToDelete['map_cfg|' + expectedToken] = 0;
done(err);
}
);
});
// SQL strings can be of arbitrary length, when using POST
// See https://github.com/CartoDB/Windshaft-cartodb/issues/111
it('sql string can be very long', function (done) {
var longVal = 'pretty';
for (var i = 0; i < 1024; ++i) {
longVal += ' long';
}
longVal += ' string';
var sql = 'SELECT ';
for (i = 0; i < 16; ++i) {
sql += "'" + longVal + "'::text as pretty_long_field_name_" + i + ', ';
}
sql += 'cartodb_id, the_geom_webmercator FROM gadm4 g';
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: sql,
cartocss: '#layer { marker-fill:red; }',
cartocss_version: '2.0.1'
}
}
]
};
var expectedToken;
step(
function doPost () {
var data = JSON.stringify(layergroup);
assert.ok(data.length > 1024 * 64);
var next = this;
assert.response(server, {
url: layergroupUrl + '?api_key=1234',
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: data
}, {}, function (res) { next(null, res); });
},
function checkResult (err, res) {
assert.ifError(err);
assert.strictEqual(res.statusCode, 200, res.statusCode + ': ' + res.body);
var parsedBody = JSON.parse(res.body);
var tokenComponents = parsedBody.layergroupid.split(':');
expectedToken = tokenComponents[0];
return null;
},
function cleanup (err) {
if (err) {
return done(err);
}
keysToDelete['user:localhost:mapviews:global'] = 5;
keysToDelete['map_cfg|' + expectedToken] = 0;
done(err);
}
);
});
// WARN: MapConfig with mapnik layer and no cartocss it's valid since
// vector & raster aggregation project, now we can request MVT format w/o defining styles
// for the layer.
// See https://github.com/CartoDB/Windshaft-cartodb/issues/133
it.skip('MapConfig with mapnik layer and no cartocss', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select cartodb_id, ST_Translate(the_geom_webmercator, 5e6, 0) as the_geom_webmercator' +
' from test_table limit 2',
interactivity: 'cartodb_id'
}
}
]
};
step(
function doPost () {
var next = this;
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res, err) { next(err, res); });
},
function checkPost (err, res) {
assert.ifError(err);
assert.strictEqual(res.statusCode, 400, res.statusCode + ': ' + res.body);
var parsed = JSON.parse(res.body);
assert.ok(parsed.errors, 'Missing "errors" in response: ' + JSON.stringify(parsed));
assert.strictEqual(parsed.errors.length, 1);
var msg = parsed.errors[0];
assert.strictEqual(msg, 'Missing cartocss for layer 0 options');
return null;
},
function finish (err) {
done(err);
}
);
});
if (!cdbQueryTablesFromPostgresEnabledValue) { // only test if it was using the SQL API
// See https://github.com/CartoDB/Windshaft-cartodb/issues/167
it('lack of response from sql-api will result in a timeout', function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: "select *, 'SQLAPINOANSWER' from test_table",
cartocss: '#layer { marker-fill:red; marker-width:32; marker-allow-overlap:true; }',
cartocss_version: '2.1.0'
}
}
]
};
step(
function doPost () {
var next = this;
assert.response(server, {
url: layergroupUrl,
method: 'POST',
headers: { host: 'localhost', 'Content-Type': 'application/json' },
data: JSON.stringify(layergroup)
}, {}, function (res, err) { next(err, res); });
},
function checkPost (err, res) {
assert.ifError(err);
assert.strictEqual(res.statusCode, 400, res.statusCode + ': ' + res.body);
var parsed = JSON.parse(res.body);
assert.ok(parsed.errors, 'Missing "errors" in response: ' + JSON.stringify(parsed));
assert.strictEqual(parsed.errors.length, 1);
var msg = parsed.errors[0];
assert.ok(msg, /could not fetch source tables/, msg);
return null;
},
function finish (err) {
done(err);
}
);
});
}
var layergroupTtlRequest = {
url: layergroupUrl + '?config=' + encodeURIComponent(JSON.stringify({
version: '1.0.0',
layers: [
{
options: {
sql: 'select * from test_table limit 2',
cartocss: '#layer { marker-fill:red; marker-width:32; marker-allow-overlap:true; }',
cartocss_version: '2.0.1'
}
}
]
})),
method: 'GET',
headers: { host: 'localhost' }
};
var layergroupTtlResponseExpectation = {
status: 200
};
it('cache control for layergroup default value', function (done) {
global.environment.varnish.layergroupTtl = null;
var server = createServer(serverOptions);
assert.response(server, layergroupTtlRequest, layergroupTtlResponseExpectation,
function (res) {
assert.strictEqual(res.headers['cache-control'], 'public,max-age=86400,must-revalidate');
keysToDelete['map_cfg|' + LayergroupToken.parse(JSON.parse(res.body).layergroupid).token] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
done();
}
);
});
it('cache control for layergroup uses configuration for max-age', function (done) {
var layergroupTtl = 300;
global.environment.varnish.layergroupTtl = layergroupTtl;
var server = createServer(serverOptions);
assert.response(server, layergroupTtlRequest, layergroupTtlResponseExpectation,
function (res) {
assert.strictEqual(res.headers['cache-control'], 'public,max-age=' + layergroupTtl + ',must-revalidate');
keysToDelete['map_cfg|' + LayergroupToken.parse(JSON.parse(res.body).layergroupid).token] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
done();
}
);
});
it("it's not possible to override authorization with a crafted layergroup", function (done) {
var layergroup = {
version: '1.0.0',
layers: [
{
options: {
sql: 'select * from test_table_private_1',
cartocss: '#layer { marker-fill:red; }',
cartocss_version: '2.3.0',
interactivity: 'cartodb_id'
}
}
],
template: {
auth: {
method: 'open'
},
name: 'open'
}
};
assert.response(
server,
{
url: '/api/v1/map?signer=localhost',
method: 'POST',
headers: {
host: 'localhost',
'Content-Type': 'application/json'
},
data: JSON.stringify(layergroup)
},
{
status: 403
},
function (res) {
assert.ok(res.body.match(/permission denied for .+?test_table_private_1/));
done();
}
);
});
it('should response to empty layers mapconfig', function (done) {
var layergroup = {
layers: []
};
assert.response(
server,
{
url: '/api/v1/map',
method: 'POST',
headers: {
host: 'localhost',
'Content-Type': 'application/json'
},
data: JSON.stringify(layergroup)
},
{
status: 200
},
function (res, err) {
assert.ok(!err);
var parsedBody = JSON.parse(res.body);
assert.ok(parsedBody.layergroupid);
keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
keysToDelete['user:localhost:mapviews:global'] = 5;
done();
}
);
});
});
});