diff --git a/test/acceptance/user-database-timeout-limit.js b/test/acceptance/user-database-timeout-limit.js
index c59b26df..da9183c7 100644
--- a/test/acceptance/user-database-timeout-limit.js
+++ b/test/acceptance/user-database-timeout-limit.js
@@ -5,7 +5,7 @@ const TestClient = require('../support/test-client');
 
 const pointSleepSql = `
     SELECT
-        pg_sleep(0.5),
+        pg_sleep(0.3),
         'SRID=3857;POINT(0 0)'::geometry the_geom_webmercator,
         1 cartodb_id,
         2 val
@@ -17,7 +17,8 @@ const createMapConfig = ({
     sql = pointSleepSql,
     cartocss = TestClient.CARTOCSS.POINTS,
     cartocss_version = '2.3.0',
-    countBy = 'cartodb_id'
+    countBy = 'cartodb_id',
+    attributes
 } = {}) => ({
     version,
     layers: [{
@@ -27,7 +28,8 @@ const createMapConfig = ({
                 id: 'a0'
             },
             cartocss,
-            cartocss_version
+            cartocss_version,
+            attributes
         }
     }],
     analyses: [
@@ -54,15 +56,15 @@ const createMapConfig = ({
 });
 
 describe('user database timeout limit', function () {
-    beforeEach(function (done) {
-        TestClient.setUserDatabaseTimeoutLimit('localhost', 300, done);
-    });
-
-    afterEach(function (done) {
-        TestClient.setUserDatabaseTimeoutLimit('localhost', 0, done);
-    });
-
     describe('dataview', function () {
+        beforeEach(function (done) {
+            TestClient.setUserDatabaseTimeoutLimit('localhost', 200, done);
+        });
+
+        afterEach(function (done) {
+            TestClient.setUserDatabaseTimeoutLimit('localhost', 0, done);
+        });
+
         beforeEach(function () {
             const mapconfig = createMapConfig();
             this.testClient = new TestClient(mapconfig, 1234);
@@ -95,38 +97,236 @@ describe('user database timeout limit', function () {
         });
     });
 
-    describe('torque', function () {
-        beforeEach(function () {
-            const mapconfig = createMapConfig({
-                type: 'torque',
-                cartocss: TestClient.CARTOCSS.TORQUE
+    describe('torque:', function () {
+        describe('while validating in layergroup creation', function () {
+            beforeEach(function (done) {
+                const mapconfig = createMapConfig({
+                    type: 'torque',
+                    cartocss: TestClient.CARTOCSS.TORQUE
+                });
+                this.testClient = new TestClient(mapconfig, 1234);
+                TestClient.setUserDatabaseTimeoutLimit('localhost', 200, done);
+            });
+
+            afterEach(function (done) {
+                TestClient.setUserDatabaseTimeoutLimit('localhost', 0, (err) => {
+                    if (err) {
+                        return done(err);
+                    }
+                    this.testClient.drain(done);
+                });
+            });
+
+            it('fails due to statement timeout', function (done) {
+                const expectedResponse = {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json; charset=utf-8'
+                    }
+                };
+
+                this.testClient.getLayergroup(expectedResponse, (err, timeoutError) => {
+                    assert.deepEqual(timeoutError, {
+                        errors: [ 'TorqueRenderer: canceling statement due to statement timeout' ],
+                        errors_with_context: [{
+                            type: 'layer',
+                            message: 'TorqueRenderer: canceling statement due to statement timeout',
+                            layer: { id: 'torque-layer0', index: 0, type: 'torque' }
+                        }]
+                    });
+
+                    done();
+                });
             });
-            this.testClient = new TestClient(mapconfig, 1234);
         });
 
-        afterEach(function (done) {
-            this.testClient.drain(done);
-        });
+        describe('fetching "torque.json" tile', function () {
+            before(function (done) {
+                const mapconfig = createMapConfig({
+                    type: 'torque',
+                    cartocss: TestClient.CARTOCSS.TORQUE
+                });
+                this.testClient = new TestClient(mapconfig, 1234);
+                const expectedResponse = {
+                    status: 200,
+                    headers: {
+                        'Content-Type': 'application/json; charset=utf-8'
+                    }
+                };
 
-        it('layergroup creation fails due to statement timeout', function (done) {
-            const expectedResponse = {
-                status: 400,
-                headers: {
-                    'Content-Type': 'application/json; charset=utf-8'
-                }
-            };
+                this.testClient.getLayergroup(expectedResponse, (err, res) => {
+                    if (err) {
+                        return done(err);
+                    }
 
-            this.testClient.getLayergroup(expectedResponse, (err, timeoutError) => {
-                assert.deepEqual(timeoutError, {
-                    errors: ["TorqueRenderer: canceling statement due to statement timeout"],
-                    errors_with_context: [{
-                        type: "layer",
-                        message: "TorqueRenderer: canceling statement due to statement timeout",
-                        layer: { id: 'torque-layer0', index: 0, type: "torque" }
-                    }]
+                    this.layergroupid = res.layergroupid;
+
+                    done();
+                });
+            });
+
+            afterEach(function (done) {
+                this.testClient.drain(done);
+            });
+
+            describe('with user\'s timeout of 200 ms', function () {
+                beforeEach(function (done) {
+                    TestClient.setUserDatabaseTimeoutLimit('localhost', 200, done);
                 });
 
-                done();
+                afterEach(function (done) {
+                    TestClient.setUserDatabaseTimeoutLimit('localhost', 0, done);
+                });
+
+                it('fails due to statement timeout', function (done) {
+                    const params = {
+                        layergroupid: this.layergroupid,
+                        format: 'torque.json',
+                        layers: [ 0 ],
+                        response: {
+                            status: 400,
+                            headers: {
+                                'Content-Type': 'application/json; charset=utf-8'
+                            }
+                        }
+                    };
+
+                    this.testClient.getTile(0, 0, 0, params, (err, res, attributes) => {
+                        assert.ifError(err);
+
+                        assert.deepEqual(attributes, {
+                            errors: [ 'TorqueRenderer: canceling statement due to statement timeout' ],
+                            errors_with_context: [{
+                                type: 'unknown',
+                                message: 'TorqueRenderer: canceling statement due to statement timeout',
+                            }]
+                        });
+
+                        done();
+                    });
+                });
+            });
+        });
+    });
+
+    describe('attributes:', function () {
+        describe('while validating in map instatiation', function () {
+            beforeEach(function (done) {
+                const mapconfig = createMapConfig({
+                    attributes: {
+                        id: 'cartodb_id',
+                        columns: [ 'val' ]
+                    }
+                });
+                this.testClient = new TestClient(mapconfig, 1234);
+                TestClient.setUserDatabaseTimeoutLimit('localhost', 200, done);
+            });
+
+            afterEach(function (done) {
+                TestClient.setUserDatabaseTimeoutLimit('localhost', 0, (err) => {
+                    if (err) {
+                        return done(err);
+                    }
+                    this.testClient.drain(done);
+                });
+            });
+
+            it('layergroup creation fails due to statement timeout', function (done) {
+                const expectedResponse = {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json; charset=utf-8'
+                    }
+                };
+
+                this.testClient.getLayergroup(expectedResponse, (err, timeoutError) => {
+                    assert.deepEqual(timeoutError, {
+                        errors: [ 'canceling statement due to statement timeout' ],
+                        errors_with_context: [{
+                            type: 'layer',
+                            message: 'canceling statement due to statement timeout',
+                            layer: {
+                                id: 'layer0',
+                                index: 0,
+                                type: 'mapnik'
+                            }
+                        }]
+                    });
+
+                    done();
+                });
+            });
+        });
+
+        describe('fetching by feature id', function () {
+            beforeEach(function (done) {
+                const mapconfig = createMapConfig({
+                    attributes: {
+                        id: 'cartodb_id',
+                        columns: [ 'val' ]
+                    }
+                });
+
+                this.testClient = new TestClient(mapconfig, 1234);
+
+                const expectedResponse = {
+                    status: 200,
+                    headers: {
+                        'Content-Type': 'application/json; charset=utf-8'
+                    }
+                };
+
+                this.testClient.getLayergroup(expectedResponse, (err, res) => {
+                    if (err) {
+                        return done(err);
+                    }
+
+                    this.layergroupid = res.layergroupid;
+
+                    done();
+                });
+            });
+
+            afterEach(function (done) {
+                this.testClient.drain(done);
+            });
+
+            describe('with user\'s timeout of 200 ms', function () {
+                beforeEach(function (done) {
+                    TestClient.setUserDatabaseTimeoutLimit('localhost', 200, done);
+                });
+
+                afterEach(function (done) {
+                    TestClient.setUserDatabaseTimeoutLimit('localhost', 0, done);
+                });
+
+                it('fails due to statement timeout', function (done) {
+                    const params = {
+                        layergroupid: this.layergroupid,
+                        featureId: 1,
+                        layer: 0,
+                        response: {
+                            status: 400,
+                            headers: {
+                                'Content-Type': 'application/json; charset=utf-8'
+                            }
+                        }
+                    };
+
+                    this.testClient.getAttributes(params, (err, res, attributes) => {
+                        assert.ifError(err);
+
+                        assert.deepEqual(attributes, {
+                            errors: ['canceling statement due to statement timeout'],
+                            errors_with_context: [{
+                                type: 'unknown',
+                                message: 'canceling statement due to statement timeout'
+                            }]
+                        });
+
+                        done();
+                    });
+                });
             });
         });
     });