describe('MapProperties', function() {

  describe('.getMapId', function() {

    it('returns the id of the map', function() {
      var mapProperties = new MapProperties( { layergroupid: 'wadus' });
      expect(mapProperties.getMapId()).toEqual('wadus');
    })
  });

  describe('.getLayerIndexByType', function() {

    it('returns the index of a layer of a given type', function() {
      var layers = [
        { type: 'mapnik' },
        { type: 'http' },
        { type: 'mapnik' }
      ]
      var mapProperties = new MapProperties({
        metadata: {
          layers: layers
        }
      });
      expect(mapProperties.getLayerIndexByType(0, 'mapnik')).toEqual(0);
      expect(mapProperties.getLayerIndexByType(1, 'mapnik')).toEqual(2);
      expect(mapProperties.getLayerIndexByType(0, 'http')).toEqual(1);
      expect(mapProperties.getLayerIndexByType(10, 'http')).toEqual(-1);
    })

    it('returns the given index if metadata is empty', function() {
      var mapProperties = new MapProperties({});

      expect(mapProperties.getLayerIndexByType(0, 'mapnik')).toEqual(0);
      expect(mapProperties.getLayerIndexByType(1, 'mapnik')).toEqual(1);
    })
  })

  describe('.getLayerIndexesByType', function() {
    var mapProperties;

    beforeEach(function() {
      var layers = [
        { type: 'mapnik' },
        { type: 'http' },
        { type: 'torque' },
        { type: 'mapnik' }
      ]
      mapProperties = new MapProperties({
        metadata: {
          layers: layers
        }
      });
    })

    it('should return the indexes of all non-torque layers if no types are specified', function() {
      expect(mapProperties.getLayerIndexesByType()).toEqual([0, 1, 3]);
      expect(mapProperties.getLayerIndexesByType('')).toEqual([0, 1, 3]);
      expect(mapProperties.getLayerIndexesByType([])).toEqual([0, 1, 3]);
    })

    it('should return the indexes of the layers of the given types', function() {
      expect(mapProperties.getLayerIndexesByType('mapnik')).toEqual([0, 3]);
      expect(mapProperties.getLayerIndexesByType('http')).toEqual([1]);
      expect(mapProperties.getLayerIndexesByType(['http', 'mapnik'])).toEqual([0, 1, 3]);
    })

    it('returns wadus if metadata is empty', function() {
      mapProperties = new MapProperties({ });
      expect(mapProperties.getLayerIndexesByType()).toBeUndefined();
    })
  })
})

describe("LayerDefinition", function() {

  var layerDefinition;

  beforeEach(function(){
    var layer_definition = {
      version: '1.0.0',
      stat_tag: 'vis_id',
      layers: [
        {
          type: 'cartodb',
          options: {
            sql: 'select * from ne_10m_populated_places_simple',
            cartocss: '#layer { marker-fill: red; }',
            interactivity: ['test', 'cartodb_id']
          },
          visible: true
        },
        {
          type: 'cartodb',
          options: {
            sql: "select * from european_countries_export",
            cartocss: '#layer { polygon-fill: #000; polygon-opacity: 0.8;}',
            cartocss_version : '2.0.0',
            interactivity: ['       test2    ', 'cartodb_id2']
          },
          visible: true
        }
      ]
    };
    layerDefinition = new LayerDefinition(layer_definition, {
      tiler_domain: "carto.com",
      tiler_port: "8081",
      tiler_protocol: "http",
      user_name: 'rambo',
      no_cdn: true,
      subdomains: [null]
    });
  });

  describe('.removeLayer', function() {

    it("should remove a layer", function() {
      layerDefinition.removeLayer(0);
      expect(layerDefinition.getLayerCount()).toEqual(1);
      expect(layerDefinition.getLayer(0)).toEqual({
        type: 'cartodb', 
        options: {
          sql: "select * from european_countries_export",
          cartocss: '#layer { polygon-fill: #000; polygon-opacity: 0.8;}',
          cartocss_version: '2.0.0',
          interactivity: ['       test2    ', 'cartodb_id2']
        },
        visible: true
      });
    });
  });

  describe('.addLayer', function() {

    it("should add a layer", function() {
      layerDefinition.addLayer({ sql : 'b', cartocss: 'b'});
      expect(layerDefinition.getLayerCount()).toEqual(3);

      expect(layerDefinition.getLayer(2).type).toEqual('cartodb')
      expect(layerDefinition.getLayer(2).options).toEqual({
        sql: 'b',
        cartocss: 'b'
      });

      layerDefinition.addLayer({ sql : 'a', cartocss: 'a'}, 0);

      expect(layerDefinition.getLayer(0).type).toEqual('cartodb');
      expect(layerDefinition.getLayer(0).options).toEqual({
        sql: "a",
       cartocss: 'a'
      });
    });

    it('should add cartodb layers by default or the specified type', function() {
      layerDefinition.addLayer({ sql : 'b', cartocss: 'b'});

      expect(layerDefinition.getLayer(2).type).toEqual('cartodb')

      layerDefinition.addLayer({ type: 'http', urlTemplate: 'urlTemplate' });

      expect(layerDefinition.getLayer(3).type).toEqual('http');
    });

    it('should mark the definition as updated', function() {
      spyOn(layerDefinition, '_definitionUpdated');

      layerDefinition.addLayer({ sql : 'b', cartocss: 'b'});

      expect(layerDefinition._definitionUpdated).toHaveBeenCalled();
    });

    it("shouldn't add the layer and throw an error if is not valid (missing required attributes)", function() {
      var layerCount = layerDefinition.getLayerCount();

      expect(function() {
        layerDefinition.addLayer({
          sql : 'b'
        });
      }).toThrow('Layer definition should contain all the required attributes');

      // Layer has not been added
      expect(layerDefinition.getLayerCount()).toEqual(layerCount);
    });

    it("shouldn't mark the definition as updated if layer is not valid", function() {
      spyOn(layerDefinition, '_definitionUpdated');

      expect(function() {
        layerDefinition.addLayer({
          sql : 'b'
        });
      }).toThrow('Layer definition should contain all the required attributes');

      expect(layerDefinition._definitionUpdated).not.toHaveBeenCalled();
    });
  });

  describe('.getLayerCount', function() {

    it('should return the number of layers in the definition', function() {
      expect(layerDefinition.getLayerCount()).toEqual(2);
    });
  });

  describe(".getTooltipData", function() {

    it ('should return tooltip data if tooltip is present and has fields', function() {
      layerDefinition.layers = [{
        tooltip: {
          fields: ['wadus']
        }
      }];

      var tooltip = layerDefinition.getTooltipData(0);
      expect(tooltip).toEqual({ fields: ['wadus'] });
    });

    it ('should return NULL if tooltip is not present or does NOT have fields', function() {
      layerDefinition.layers = [{
        tooltip: {}
      }];

      var tooltip = layerDefinition.getTooltipData(0);
      expect(tooltip).toBeNull()

      layerDefinition.layers = [{
        tooltip: {
          fields: []
        }
      }];

      var tooltip = layerDefinition.getTooltipData(0);
      expect(tooltip).toBeNull()
    });
  })

  describe('.toJSON', function() {

    it("should return json spec of visible layers", function() {
      expect(layerDefinition.toJSON()).toEqual({
        version: '1.0.0',
        stat_tag: 'vis_id',
        layers: [
          {
            type: 'cartodb', 
            options: {
              sql: 'select * from ne_10m_populated_places_simple',
              cartocss: '#layer { marker-fill: red; }',
              cartocss_version: '2.1.0',
              interactivity: ['test', 'cartodb_id']
            }
          },
          {
            type: 'cartodb', 
            options: {
              sql: "select * from european_countries_export",
              cartocss: '#layer { polygon-fill: #000; polygon-opacity: 0.8;}',
              cartocss_version: '2.0.0',
              interactivity: ['test2', 'cartodb_id2']
            }
          }
        ]
      });
    });

    it("should not include hidden layers", function() {
      // Hide layer 0 using sublayer.hide
      layerDefinition.getSubLayer(0).hide();

      // Hide layer 1 updating visible
      layerDefinition.layers[1].visible = false;

      // No layers are present
      expect(layerDefinition.toJSON()).toEqual({
        version: '1.0.0',
        stat_tag: 'vis_id',
        layers: []
      });
    });
  });

  describe('.getLayerNumberByIndex', function() {

    var layers;
    var layer_definition;

    it("should return -1 if there are no layers", function() {
      layer_definition = {
        version: '1.0.0',
        stat_tag: 'vis_id',
        layers: []
      };
      layerDefinition.setLayerDefinition(layer_definition);

      expect(layerDefinition.getLayerNumberByIndex(0)).toEqual(-1);
      expect(layerDefinition.getLayerNumberByIndex(10)).toEqual(-1);
    });

    it("should return -1 if layer is hidden", function() {
      var layer_definition = {
        version: '1.0.0',
        stat_tag: 'vis_id',
        layers: [
          { options: { 'hidden': true } }
        ]
      };

      layerDefinition.setLayerDefinition(layer_definition);

      expect(layerDefinition.getLayerNumberByIndex(0)).toEqual(-1);
    });

    it("should return -1 if layer is not visible", function() {
      var layer_definition = {
        version: '1.0.0',
        stat_tag: 'vis_id',
        layers: [
          { 
            visible: false,
            options: { }
          }
        ]
      };

      layerDefinition.setLayerDefinition(layer_definition);

      expect(layerDefinition.getLayerNumberByIndex(0)).toEqual(-1);
    });

    it("should return 0 if layer is not hidden", function() {
      var layer_definition = {
        version: '1.0.0',
        stat_tag: 'vis_id',
        layers: [
          { options: { 'hidden': false } }
        ]
      };

      layerDefinition.setLayerDefinition(layer_definition);

      expect(layerDefinition.getLayerNumberByIndex(0)).toEqual(0);
    });

    it("should return the index of the layer given the index of visible layers", function() {
      layers = [
        { options: { 'hidden': false } },
        { options: { 'hidden': true } },
        { options: { 'hidden': false } }
      ]
      layer_definition = {
        version: '1.0.0',
        stat_tag: 'vis_id',
        layers: layers
      };

      layerDefinition.setLayerDefinition(layer_definition);

      expect(layerDefinition.getLayerNumberByIndex(0)).toEqual(0);
      expect(layerDefinition.getLayerNumberByIndex(1)).toEqual(2);
      expect(layerDefinition.getLayerNumberByIndex(2)).toEqual(-1);
    });
  });

  describe('.getLayerIndexByNumber', function() {

    var layers;
    var layer_definition;

    it("should return undefined if there are no layers", function() {
      layer_definition = {
        version: '1.0.0',
        stat_tag: 'vis_id',
        layers: []
      };
      layerDefinition.setLayerDefinition(layer_definition);

      expect(layerDefinition.getLayerIndexByNumber(0)).toBeUndefined();
      expect(layerDefinition.getLayerIndexByNumber(2)).toBeUndefined();
    });

    it("should return the index of the visible layer given the index of the layer", function() {
      var layer_definition = {
        version: '1.0.0',
        stat_tag: 'vis_id',
        layers: [
          { options: { 'hidden': true }},
          { options: { 'hidden': false }},
          { options: { 'hidden': true }}
        ]
      };

      layerDefinition.setLayerDefinition(layer_definition);

      expect(layerDefinition.getLayerIndexByNumber(0)).toEqual(0);
      expect(layerDefinition.getLayerIndexByNumber(1)).toEqual(0);
      expect(layerDefinition.getLayerIndexByNumber(2)).toEqual(1);
      expect(layerDefinition.getLayerIndexByNumber(3)).toBeUndefined();
    });
  });

  describe("sublayers", function() {

    describe('.getSubLayer', function() {

      it("should return the sublayer at the specified position", function() {
        var sublayer = layerDefinition.getSubLayer(0);
        expect(sublayer instanceof CartoDBSubLayer).toEqual(true);
        expect(sublayer.getSQL()).toEqual('select * from ne_10m_populated_places_simple');
        expect(sublayer.getCartoCSS()).toEqual('#layer { marker-fill: red; }');
      });
    });

    describe('.getSubLayerCount', function() {

      it("should return the number of sublayers", function() {
        expect(layerDefinition.getSubLayerCount()).toEqual(2);
        var sub = layerDefinition.createSubLayer({
          sql: 'select * from table',
          cartocss: 'test',
          interactivity: 'test'
        });
        expect(layerDefinition.getSubLayerCount()).toEqual(3);
        sub.remove();
        expect(layerDefinition.getSubLayerCount()).toEqual(2);
      });
    });

    it("hide should remove interaction", function() {
      var interaction =  layerDefinition.interactionEnabled = {}
      layerDefinition.setInteraction = function(layer, value) {
        layerDefinition.interactionEnabled[layer] = value;
      };
      layerDefinition.getSubLayer(0).setInteraction(true);
      expect(interaction[0]).toEqual(true);
      layerDefinition.getSubLayer(0).hide();
      expect(interaction[0]).toEqual(false);
      layerDefinition.getSubLayer(0).show();
      expect(interaction[0]).toEqual(true);
      layerDefinition.getSubLayer(1).hide();
      layerDefinition.getSubLayer(1).show();
      expect(interaction[1]).toEqual(undefined);
    });

    it("should be the same object for the same sublayer", function() {
      expect(layerDefinition.getSubLayer(0)).toBe(layerDefinition.getSubLayer(0));
    });
  });

  describe('.setInteractivity', function() {

    it("should set interactivity", function() {
      layerDefinition.setInteractivity(1, ['cartodb_id', 'rambo   ']);
      expect(layerDefinition.getLayer(1).options.interactivity).toEqual(['cartodb_id','rambo']);
      layerDefinition.setInteractivity(['cartodb_id', 'john']);
      expect(layerDefinition.getLayer(0).options.interactivity).toEqual(['cartodb_id', 'john']);
      expect(layerDefinition.toJSON().layers[0].options.interactivity).toEqual(['cartodb_id', 'john']);
    });
  });

  describe('.createMap', function() {

    var ajax, ajaxParams, callback, fakeMapProperties, fakeMapConfig, originalSetTimeout;

    beforeEach(function() {
      ajaxParams = undefined;
      fakeMapProperties = {};
      fakeMapConfig = 'fakeMapConfig';
      layerDefinition.options.ajax = ajax = function(params) {
        ajaxParams = params;
        params.success(fakeMapProperties || {});
      }
      callback = jasmine.createSpy('callback');
      layerDefinition.toJSON = function() {
        return fakeMapConfig;
      };

      // Mock setTimeout that runs functions inmediatly
      originalSetTimeout = jasmine.getGlobal().setTimeout;
      jasmine.getGlobal().setTimeout = function (func, millis) {
        func();
      };
    })

    afterEach(function() {
      jasmine.getGlobal().setTimeout = originalSetTimeout;
    })

    it("should stack requests and invoke the callbacks with the mapProperties returned by the last request", function(done) {
      // Use the native setTimeout for this test
      jasmine.getGlobal().setTimeout = originalSetTimeout;

      var tokens = [];
      var i = 0;
      layerDefinition.options.ajax = function(p) {

        // Override ajax again
        layerDefinition.options.ajax = function(p) { 
          p.success({ layergroupid: 'layergroup_' + ++i });
        }

        // Before the ajax request is done, another request is sent
        layerDefinition.createMap(function(a) {
          tokens.push(a);
        });

        p.success({ layergroupid: 'layergroup_' + ++i });
      };

      layerDefinition.createMap(function(a) {
        tokens.push(a);
      });
      layerDefinition.createMap(function(a) {
        tokens.push(a);
      });

      setTimeout(function() {
        expect(tokens.length).toEqual(3);
        expect(tokens[0]).toEqual({ layergroupid: 'layergroup_2' });
        expect(tokens[1]).toEqual({ layergroupid: 'layergroup_2' });
        expect(tokens[2]).toEqual({ layergroupid: 'layergroup_2' });
        done();
      }, 4);
    });

    it('should not create a map if there are no visible layers', function() {
      for (var i=0; i<layerDefinition.getLayerCount(); i++) {
        layerDefinition.getSubLayer(i).hide();
      }

      layerDefinition.createMap(callback);

      expect(callback).toHaveBeenCalledWith(null, undefined);
      expect(callback.calls.count()).toEqual(1);
      expect(ajaxParams).toBeUndefined();
    })

    it("should create a map if there are no visible layers but it's a named map", function() {
      layerDefinition.named_map = {};

      for (var i=0; i<layerDefinition.getLayerCount(); i++) {
        layerDefinition.getSubLayer(i).hide();
      }

      layerDefinition.createMap(callback);

      expect(callback).toHaveBeenCalledWith(fakeMapProperties, undefined);
      expect(callback.calls.count()).toEqual(1);
      expect(ajaxParams.dataType).toEqual('jsonp');
    })

    describe('params', function() {

      it('should use a map/api key', function() {
        fakeMapConfig = 'mapConfig';

        layerDefinition.options.extra_params = { api_key: 'key' };
        layerDefinition.createMap(callback);

        expect(ajaxParams.url.indexOf('map_key=key')).not.toEqual(-1);
      })

      it('should use a map/api key', function() {
        fakeMapConfig = 'mapConfig';

        layerDefinition.options.extra_params = { map_key: 'key' };
        layerDefinition.createMap(callback);

        expect(ajaxParams.url.indexOf('map_key=key')).not.toEqual(-1);
      })

      it('should use a map/api key', function() {
        fakeMapConfig = 'mapConfig';

        layerDefinition.options.api_key = 'key';
        layerDefinition.createMap(callback);

        expect(ajaxParams.url.indexOf('map_key=key')).not.toEqual(-1);
      })

      it('should use a map/api key', function() {
        fakeMapConfig = 'mapConfig';

        layerDefinition.options.map_key = 'key';
        layerDefinition.createMap(callback);

        expect(ajaxParams.url.indexOf('map_key=key')).not.toEqual(-1);
      })

      it('should use an auth_token', function() {
        fakeMapConfig = 'mapConfig';

        layerDefinition.options.extra_params = { auth_token: 'token' };
        layerDefinition.createMap(callback);

        expect(ajaxParams.url.indexOf('auth_token=token')).not.toEqual(-1);
      })

      it('should multiple auth_token(s)', function() {
        fakeMapConfig = 'mapConfig';

        layerDefinition.options.extra_params = { auth_token: ['token1', 'token2'] };
        layerDefinition.createMap(callback);

        expect(ajaxParams.url.indexOf('auth_token[]=token1&auth_token[]=token2')).not.toEqual(-1);
      })

      it('should use a stat_tag', function() {
        layerDefinition.stat_tag = 'stat_tag';
        layerDefinition.createMap(callback);

        expect(ajaxParams.url.indexOf('stat_tag=stat_tag')).not.toEqual(-1);
      })
    })

    it("should set a refresh timer after creating the map", function() {
      layerDefinition.options.refreshTime = 100;

      spyOn(layerDefinition,'invalidate');

      layerDefinition.createMap(callback);

      expect(layerDefinition.invalidate).toHaveBeenCalled();
    });

    describe('GET request', function() {

      it('should create a map using a GET request', function() {
        fakeMapProperties = {};
        fakeMapConfig = 'mapConfig';

        layerDefinition.createMap(callback);

        expect(callback).toHaveBeenCalledWith(fakeMapProperties, undefined);
        expect(callback.calls.count()).toEqual(1);
        expect(ajaxParams.dataType).toEqual('jsonp');
        expect(ajaxParams.type).toBeUndefined(); // GET request
        expect(ajaxParams.url).toEqual('http://rambo.carto.com:8081/api/v1/map?stat_tag=vis_id&config=%22mapConfig%22');
        expect(ajaxParams.jsonpCallback().indexOf('_cdbc_')).toEqual(0);
        expect(ajaxParams.cache).toEqual(true);
      })

      it('should use the right endpoint', function() {
        layerDefinition.JSONPendPoint = '/api/v2/';

        layerDefinition.createMap(callback);

        expect(ajaxParams.url).toEqual('http://rambo.carto.com:8081/api/v2/?stat_tag=vis_id&config=%22fakeMapConfig%22');

        delete layerDefinition.JSONPendPoint;
        layerDefinition.endPoint = '/api/v3/'

        layerDefinition.createMap(callback);

        expect(ajaxParams.url).toEqual('http://rambo.carto.com:8081/api/v3/?stat_tag=vis_id&config=%22fakeMapConfig%22');
      })

      it('should the instanciateCallback as the jsonpCallback', function() {
        var callback = function() {
          console.log('hello world!')
        }
        layerDefinition.options.instanciateCallback = callback;

        layerDefinition.createMap(callback);

        expect(ajaxParams.jsonpCallback).toEqual(callback);
      })

      it('should use a cdn', function() {
        layerDefinition._host = function() { return 'http://cdn.test.com'; }
        layerDefinition._tilerHost = function() { return 'http://rambo.carto.com:8081'; }

        layerDefinition.options.dynamic_cdn = true;
        layerDefinition.createMap(callback);

        expect(ajaxParams.url.indexOf('http://cdn.test.com/api/v1/map?')).toEqual(0);
      });

      it("should compress the map definition using LZMA and the browser's btoa function", function() {
        layerDefinition.options.force_compress = true;

        spyOn(window, "btoa");

        var json = layerDefinition.toJSON();
        json = JSON.stringify({ config: JSON.stringify(json) });
        LZMA.compress(json, 3, function(encoded) {
          lzma = cdb.core.util.array2hex(encoded);

          layerDefinition.createMap(callback);
        });

        expect(window.btoa.calls.count()).toEqual(2);
        expect(window.btoa.calls.mostRecent().args.length).toEqual(1);
        expect(ajaxParams.url.indexOf('lzma=' + lzma)).not.toEqual(-1);
      });

      it("should compress the map definition using LZMA and cdb.core.util.encodeBase64", function() {
        layerDefinition.options.force_compress = true;

        var _btoa = window.btoa;
        window.btoa = undefined;
        spyOn(cdb.core.util, "encodeBase64");

        var json = layerDefinition.toJSON();
        json = JSON.stringify({ config: JSON.stringify(json) });
        LZMA.compress(json, 3, function(encoded) {
          lzma = cdb.core.util.array2hex(encoded);

          layerDefinition.createMap(callback);
        });

        expect(cdb.core.util.encodeBase64.calls.count()).toEqual(2);
        expect(cdb.core.util.encodeBase64.calls.mostRecent().args.length).toEqual(1);
        expect(ajaxParams.url.indexOf('lzma=' + lzma)).not.toEqual(-1);

        window.btoa = _btoa;
      });

      it('should handle errors returned by the tiler', function() {
        fakeMapProperties = { errors: ['Error!']};

        layerDefinition.createMap(callback);

        expect(callback).toHaveBeenCalledWith(null, { errors: [ 'Error!' ] });
      })

      it('should handle ajax errors', function() {
        layerDefinition.options.ajax = ajax = function(params) {
          ajaxParams = params;
          params.error('error!');
        }

        layerDefinition.createMap(callback);

        expect(callback).toHaveBeenCalledWith(null, { errors: [ 'unknow error' ] });
      })
    })

    describe('POST request', function() {

      beforeEach(function() {
        fakeMapConfig = 'a';
        for (var i = 0; i < 3000; i++) {
          fakeMapConfig += 'a';
        }
      })

      it('should use a POST request when request body is greater than maximum GET size', function() {
        layerDefinition.createMap(callback);

        expect(callback).toHaveBeenCalledWith(fakeMapProperties, undefined);
        expect(callback.calls.count()).toEqual(1);
        expect(ajaxParams.crossOrigin).toEqual(true);
        expect(ajaxParams.type).toEqual('POST'); // POST request
        expect(ajaxParams.method).toEqual('POST'); // POST request
        expect(ajaxParams.dataType).toEqual('json');
        expect(ajaxParams.contentType).toEqual('application/json');
        expect(ajaxParams.url).toEqual('http://rambo.carto.com:8081/api/v1/map?stat_tag=vis_id');
        expect(ajaxParams.data).toEqual('"' + fakeMapConfig + '"');
      })

      it('should use a POST request when forcing CORS', function() {
        fakeMapConfig = 'aaaa';
        layerDefinition.options.cors = 'something';
        layerDefinition.options.force_cors = true;

        layerDefinition.createMap(callback);

        expect(callback).toHaveBeenCalledWith(fakeMapProperties, undefined);
        expect(callback.calls.count()).toEqual(1);
        expect(ajaxParams.crossOrigin).toEqual(true);
        expect(ajaxParams.type).toEqual('POST'); // POST request
        expect(ajaxParams.method).toEqual('POST'); // POST request
        expect(ajaxParams.dataType).toEqual('json');
        expect(ajaxParams.contentType).toEqual('application/json');
        expect(ajaxParams.url).toEqual('http://rambo.carto.com:8081/api/v1/map?stat_tag=vis_id');
        expect(ajaxParams.data).toEqual('"' + fakeMapConfig + '"');
      })

      it('should use the right endpoint', function() {
        layerDefinition.options.cors = 'something';
        layerDefinition.options.force_cors = true;
        layerDefinition.endPoint = '/api/v20/';

        layerDefinition.createMap(callback);

        expect(ajaxParams.url).toEqual('http://rambo.carto.com:8081/api/v20/?stat_tag=vis_id');
      })

      it('should handle errors returned by the tiler', function() {
        fakeMapProperties = { errors: ['Error!']};

        layerDefinition.createMap(callback);

        expect(callback).toHaveBeenCalledWith(null, { errors: [ 'Error!' ] });
      })

      it('should handle ajax errors', function() {
        layerDefinition.options.ajax = ajax = function(params) {
          ajaxParams = params;
          params.error('error!');
        }

        layerDefinition.createMap(callback);

        expect(callback).toHaveBeenCalledWith(null, { errors: [ 'unknow error' ] });
      })
    })
  });

  describe('.getTiles', function() {
    var mapProperties, callback;

    beforeEach(function() {
      callback = jasmine.createSpy("callback");
      mapProperties = {};
      layerDefinition.createMap = function (_callback) {
        _callback(mapProperties);
      }
      spyOn(layerDefinition, "createMap").and.callThrough();
    })

    it("should fetch the map properties and invoke the callback with URLs for tiles and grids", function() {
      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      var expectedURLs = {
        "tiles": [
          "http://rambo.carto.com:8081/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png"
        ],
        "grids": [
          [ "http://rambo.carto.com:8081/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json" ],
          [ "http://rambo.carto.com:8081/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json" ]
        ]
      }

      layerDefinition.getTiles(callback);

      expect(layerDefinition.createMap).toHaveBeenCalled();
      expect(callback).toHaveBeenCalledWith(expectedURLs);
    });

    it("should generate url for tiles using a cdn", function() {
      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      layerDefinition.options.no_cdn = false;
      layerDefinition.options.cdn_url = { http: "api.cartocdn.com" }
      layerDefinition.options.subdomains = ['a', 'b', 'c', 'd'];

      layerDefinition.getTiles(callback);

      var expectedURLs = {
        tiles: [
          'http://a.api.cartocdn.com/rambo/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png',
          'http://b.api.cartocdn.com/rambo/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png',
          'http://c.api.cartocdn.com/rambo/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png',
          'http://d.api.cartocdn.com/rambo/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png'
        ],
        grids: [
          [
            'http://a.api.cartocdn.com/rambo/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json',
            'http://b.api.cartocdn.com/rambo/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json',
            'http://c.api.cartocdn.com/rambo/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json',
            'http://d.api.cartocdn.com/rambo/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json'
          ], [ 
            'http://a.api.cartocdn.com/rambo/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json',
            'http://b.api.cartocdn.com/rambo/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json',
            'http://c.api.cartocdn.com/rambo/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json',
            'http://d.api.cartocdn.com/rambo/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json'
          ]
        ]
      }
      expect(callback).toHaveBeenCalledWith(expectedURLs);
    });

    it("should use the cdn returned by the tiler", function() {
      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        },
        "cdn_url": {
          "http": "wadus.cartocdn.com"
        }
      }

      layerDefinition.options.no_cdn = false;
      layerDefinition.options.cdn_url = { http: "api.cartocdn.com" }
      layerDefinition.options.subdomains = ['a', 'b', 'c', 'd'];

      layerDefinition.getTiles(callback);

      var expectedURLs = {
        tiles: [
          'http://a.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png',
          'http://b.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png',
          'http://c.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png',
          'http://d.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png'
        ],
        grids: [
          [
            'http://a.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json',
            'http://b.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json',
            'http://c.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json',
            'http://d.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json'
          ], [
            'http://a.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json',
            'http://b.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json',
            'http://c.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json',
            'http://d.wadus.cartocdn.com/rambo/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json'
          ]
        ]
      }
      expect(callback).toHaveBeenCalledWith(expectedURLs);
    });

    it("should generate url for tiles without a cdn when cdn_url is empty", function() {
      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      layerDefinition.options.no_cdn = false;
      layerDefinition.options.subdomains = ['a', 'b', 'c', 'd'];

      layerDefinition.getTiles(callback);

      var expectedURLs = {
        tiles: [
          'http://rambo.carto.com:8081/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png',
          'http://rambo.carto.com:8081/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png',
          'http://rambo.carto.com:8081/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png',
          'http://rambo.carto.com:8081/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png'
        ],
        grids: [
          [
            'http://rambo.carto.com:8081/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json',
            'http://rambo.carto.com:8081/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json',
            'http://rambo.carto.com:8081/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json',
            'http://rambo.carto.com:8081/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json'
          ], [
            'http://rambo.carto.com:8081/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json',
            'http://rambo.carto.com:8081/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json',
            'http://rambo.carto.com:8081/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json',
            'http://rambo.carto.com:8081/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json'
          ]
        ]
      };
      expect(callback).toHaveBeenCalledWith(expectedURLs);
    });

    it("should only fetch the map properties if they were already fetched and the definition is valid", function() {
      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      layerDefinition.getTiles(callback);

      var expectedURLs = {
        "tiles": [
          "http://rambo.carto.com:8081/api/v1/map/layergroupid/0,1/{z}/{x}/{y}.png"
        ],
        "grids": [
          [ "http://rambo.carto.com:8081/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json" ],
          [ "http://rambo.carto.com:8081/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json" ]
        ]
      }

      expect(layerDefinition.createMap).toHaveBeenCalled();
      expect(callback).toHaveBeenCalledWith(expectedURLs);

      // Reset spies
      callback.calls.reset();
      layerDefinition.createMap.calls.reset();

      // Invoke the method again -> It should have cached the map properties
      layerDefinition.getTiles(callback);

      expect(layerDefinition.createMap).not.toHaveBeenCalled();
      expect(callback).toHaveBeenCalledWith(expectedURLs);

      // Reset spies
      callback.calls.reset();
      layerDefinition.createMap.calls.reset();

      // Invalidate the definition and try again -> It should query again
      layerDefinition.invalidate();
      layerDefinition.getTiles(callback);

      expect(layerDefinition.createMap).toHaveBeenCalled();
      expect(callback).toHaveBeenCalledWith(expectedURLs);
    });

    it("should invoke the callback with URLs for tiles and grids (for mapnik layers ONLY)", function() {
      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "http", "meta": {} },
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      layerDefinition.getTiles(callback);

      // LayerDefinition contains two mapnik layers (0 and 1), but the tiler contains:
      // 0 - http
      // 1 - mapnik
      // 2 - mapnik
      // We need to fetch the grid for layers 1 and 2. Those are the indexes that the tiler understands.
      var expectedURLs = {
        "tiles": [
          "http://rambo.carto.com:8081/api/v1/map/layergroupid/0,1,2/{z}/{x}/{y}.png"
        ],
        "grids": [
          [ "http://rambo.carto.com:8081/api/v1/map/layergroupid/1/{z}/{x}/{y}.grid.json" ],
          [ "http://rambo.carto.com:8081/api/v1/map/layergroupid/2/{z}/{x}/{y}.grid.json" ]
        ]
      }
      expect(callback).toHaveBeenCalledWith(expectedURLs);
    });

    it("should only include the specified layer types in the tiles", function() {
      layerDefinition.options.filter = "http";

      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "http", "meta": {} },
            { "type": "mapnik", "meta": {} },
            { "type": "http", "meta": {} }
          ]
        }
      }

      layerDefinition.getTiles(callback);

      // Tile URL is telling the tiler to only render layers 1 and 3 (both http)
      var expectedURLs = {
        "tiles": [
          "http://rambo.carto.com:8081/api/v1/map/layergroupid/1,3/{z}/{x}/{y}.png"
        ],
        "grids": [
          [ "http://rambo.carto.com:8081/api/v1/map/layergroupid/0/{z}/{x}/{y}.grid.json" ],
          [ "http://rambo.carto.com:8081/api/v1/map/layergroupid/2/{z}/{x}/{y}.grid.json" ]
        ]
      }
      expect(callback).toHaveBeenCalledWith(expectedURLs);
    })

    it("should use an empty gif if filter returns no layers", function() {
      layerDefinition.options.filter = "http";

      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} },
          ]
        }
      }

      layerDefinition.getTiles(callback);

      // No layers match the filter -> Render empty gifs
      var expectedURLs = {
        tiles: [ MapBase.EMPTY_GIF ],
        grids: [ ]
      }
      expect(callback).toHaveBeenCalledWith(expectedURLs);
    })

    it("should include extra params", function() {
      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      layerDefinition.options.extra_params = {
        'map_key': 'testapikey',
        'should_not': 'included'
      }

      layerDefinition.getTiles(function(tiles) {
        expect(tiles.tiles[0].indexOf('map_key=testapikey')).not.toEqual(-1)
        expect(tiles.tiles[0].indexOf('should_not')).toEqual(-1)
      });
    });

    it("should cache the mapProperties", function() {
      mapProperties = {
        layergroupid: 'test',
        metadata: { layers: [] },
        cdn_url: {
          http: 'cdn.test.com',
          https:'cdn.testhttps.com'
        }
      }

      // Request tiles for the first time
      layerDefinition.getTiles();

      expect(layerDefinition.createMap).toHaveBeenCalled();
      expect(layerDefinition.mapProperties.getMapId()).toEqual('test');

      // Reset calls to layerDefinition.createMap
      layerDefinition.createMap.calls.reset();

      // Request tiles again
      layerDefinition.getTiles();

      // We already have mapProperties so we don't need to request them again
      expect(layerDefinition.createMap).not.toHaveBeenCalled();
      expect(layerDefinition.mapProperties.getMapId()).toEqual('test');
    });

    it("should use an empty gif if there are no visible layers", function() {
      var urls;
      layerDefinition.getSubLayer(0).hide();
      layerDefinition.getSubLayer(1).hide();
      layerDefinition.createMap = function (callback) {
        callback(null);
      }

      layerDefinition.getTiles(function(t) {
        urls = t;
      })

      expect(urls.tiles[0]).toEqual(MapBase.EMPTY_GIF);
      expect(urls.grids[0]).toBeUndefined();
    });
  });

  describe('.fetchAttributes', function() {
    var mapProperties, callback, ajax;

    beforeEach(function() {
      callback = jasmine.createSpy("callback");
      ajax = layerDefinition.options.ajax = jasmine.createSpy('ajax');
      mapProperties = {};
      layerDefinition.createMap = function (callback) {
        callback(mapProperties);
      }
    })

    it('should fetch the attributes and invoke the callback', function() {
      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      // Fetch the map properties first
      layerDefinition.getTiles();

      layerDefinition.fetchAttributes(0, 'feature_id', 2, callback);

      // Ajax request to the right endpoint with right attributes
      expect(ajax).toHaveBeenCalled();
      var ajaxOptions = ajax.calls.mostRecent().args[0];
      expect(ajaxOptions.dataType).toEqual('jsonp');
      expect(ajaxOptions.jsonpCallback).toEqual('_cdbi_layer_attributes_' + layerDefinition._attrCallbackName);
      expect(ajaxOptions.url).toEqual('http://rambo.carto.com:8081/api/v1/map/layergroupid/0/attributes/feature_id');
      expect(ajaxOptions.cache).toEqual(true);

      // Ajax succeeds
      ajaxOptions.success('wadus');

      expect(callback).toHaveBeenCalledWith('wadus');
    })

    it('should convert layergroup indexes to the corresponding indexes in the tiler', function() {
      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "http", "meta": {} },
            { "type": "mapnik", "meta": {} },
            { "type": "http", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      // Fetch the map properties first
      layerDefinition.getTiles();

      // Fetch attributes for layer 0 (which is layer 1 in the tiler)
      layerDefinition.fetchAttributes(0, 'feature_id', 2, callback);

      var expectedUrl = 'http://rambo.carto.com:8081/api/v1/map/layergroupid/1/attributes/feature_id';
      var actualUrl = ajax.calls.mostRecent().args[0].url;

      expect(actualUrl).toEqual(expectedUrl);

      // Fetch attributes for layer 1 (which is layer 3 in the tiler)
      layerDefinition.fetchAttributes(1, 'feature_id', 2, callback);

      var expectedUrl = 'http://rambo.carto.com:8081/api/v1/map/layergroupid/3/attributes/feature_id';
      var actualUrl = ajax.calls.mostRecent().args[0].url;

      expect(actualUrl).toEqual(expectedUrl);
    })

    it('should handle hidden layers properly', function() {
      var layer_definition = {
        version: '1.0.0',
        stat_tag: 'vis_id',
        layers: [
          {
            type: 'http',
            urlTemplate: 'urlTemplate',
            options: {}
          },
          {
            type: 'http',
            urlTemplate: 'urlTemplate',
            options: {}
          },
          {
            type: 'cartodb',
            options: {
              sql: 'select * from ne_10m_populated_places_simple',
              cartocss: '#layer { marker-fill: red; }',
              interactivity: ['test', 'cartodb_id']
            }
          },
          {
            type: 'cartodb',
            options: {
              sql: "select * from european_countries_export",
              cartocss: '#layer { polygon-fill: #000; polygon-opacity: 0.8;}',
              cartocss_version : '2.0.0',
              interactivity: ['       test2    ', 'cartodb_id2']
            }
          }
        ]
      };

      layerDefinition.setLayerDefinition(layer_definition);

      // Hide the first `http` sublayer
      layerDefinition.getSubLayer(0).hide();

      // Hide the first `mapnik` sublayer
      layerDefinition.getSubLayer(1).hide();

      // Tiler returns the two layers that are visible
      mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "http", "meta": {} },
            { "type": "mapnik", "meta": {} },
          ]
        }
      }

      // Fetch the map properties
      layerDefinition.getTiles();

      // Fetch attributes for 2nd mapnik layer (which is layer 1 in the tiler)
      layerDefinition.fetchAttributes(2, 'feature_id', 2, callback);

      var expectedUrl = 'http://rambo.carto.com:8081/api/v1/map/layergroupid/1/attributes/feature_id';
      var actualUrl = ajax.calls.mostRecent().args[0].url;

      expect(actualUrl).toEqual(expectedUrl);
    })
  })

  describe('._buildMapsApiTemplate, ._host', function() {

    it("should use the tiler url when there's explicitly empty cdn defined", function() {
      layerDefinition.options.cdn_url = {
        http: "", https: ""
      };

      expect(layerDefinition._host()).toEqual('http://rambo.carto.com:8081');
      expect(layerDefinition._host('0')).toEqual('http://rambo.carto.com:8081');

      layerDefinition.options.tiler_protocol = "https";
      layerDefinition._buildMapsApiTemplate(layerDefinition.options);

      expect(layerDefinition._host()).toEqual('https://rambo.carto.com:8081');
      expect(layerDefinition._host('a')).toEqual('https://rambo.carto.com:8081');
    });

    it("should use the tiler url when there's explicitly no cdn", function() {
      layerDefinition.options.cdn_url = undefined;

      expect(layerDefinition._host()).toEqual('http://rambo.carto.com:8081');
      expect(layerDefinition._host('0')).toEqual('http://rambo.carto.com:8081');

      layerDefinition.options.tiler_protocol = "https";
      layerDefinition._buildMapsApiTemplate(layerDefinition.options);

      expect(layerDefinition._host()).toEqual('https://rambo.carto.com:8081');
      expect(layerDefinition._host('a')).toEqual('https://rambo.carto.com:8081');
    });

    it("should use cdn_url from tiler when present", function(done) {
      var params;
      delete layerDefinition.options.no_cdn;
      layerDefinition.options.ajax = function(p) { 
        params = p;
        p.success({ layergroupid: 'test', metadata: { layers: [] }, cdn_url: { http: 'cdn.test.com', https:'cdn.testhttps.com' }});
      };

      layerDefinition.getTiles();

      setTimeout(function() {
        expect(layerDefinition._host()).toEqual('http://cdn.test.com/rambo');

        setTimeout(function() {
          layerDefinition.options.tiler_protocol = 'https';
          layerDefinition._buildMapsApiTemplate(layerDefinition.options);
          layerDefinition.getTiles();

          setTimeout(function() {
            expect(layerDefinition._host()).toEqual('https://cdn.testhttps.com/rambo');
            done();
          }, 100)

        }, 200);

      }, 100);
    });
  });

  describe('.invalidate', function() {

    it('should clear the mapProperties and urls', function() {
      layerDefinition.mapProperties = 'test';
      layerDefinition.urls = ['test'];

      layerDefinition.invalidate();

      expect(layerDefinition.mapProperties).toEqual(null);
      expect(layerDefinition.urls).toEqual(null);
    });

    it('should invoke onLayerDefinitionUpdated', function() {
      spyOn(layerDefinition, 'onLayerDefinitionUpdated');

      layerDefinition.invalidate();

      expect(layerDefinition.onLayerDefinitionUpdated).toHaveBeenCalled();
    })
  });

  describe('LayerDefinition.layerDefFromSubLayers', function() {

    it("should generate layerdef", function() {
      var layerDef = LayerDefinition.layerDefFromSubLayers([{
        sql: 'test',
        cartocss:'test'
      }]);

      expect(layerDef).toEqual({
        version: '1.3.0',
        stat_tag: 'API',
        layers: [{
          type: 'cartodb',
          options: {
            sql: 'test',
            cartocss:'test',
            cartocss_version: '2.1.0'
          }
        }]
      });
    });

    it("should return the right type of layers", function() {
      var layerDef = LayerDefinition.layerDefFromSubLayers([{
        type: 'http',
        urlTemplate: 'urlTemplate'
      }]);

      expect(layerDef).toEqual({
        version: '1.3.0',
        stat_tag: 'API',
        layers: [{
          type: 'http',
          options: {
            urlTemplate: 'urlTemplate'
          }
        }]
      });
    });
  });
});

describe("NamedMap", function() {
  var namedMap, named_map;

  beforeEach(function() {
    named_map = {
      name: 'testing',
      params: {
        color: 'red'
      },
      layers: [{
          infowindow: {
            fields: [ { title:'test', value:true, position:0, index:0 } ]
          }
      }]
    };
    namedMap= new NamedMap(named_map, {
      tiler_domain:   "carto.com",
      tiler_port:     "8081",
      tiler_protocol: "http",
      user_name: 'rambo',
      no_cdn: true,
      subdomains: [null]
    });
  });

  describe('.toJSON', function() {

    it('should return an empty object if no layers are present', function() {
      var config = {
        name: 'testing'
      };
      var namedMap = new NamedMap(config, {});

      expect(namedMap.toJSON()).toEqual({});

      config = {
        name: 'testing',
        layers: []
      };
      namedMap = new NamedMap(config, {});

      expect(namedMap.toJSON()).toEqual({});
    })

    it('should include the given params', function() {
      var config = {
        name: 'testing',
        params: {
          key: 'value'
        }
      };
      var namedMap = new NamedMap(config, {});

      expect(namedMap.toJSON()).toEqual({ key: 'value' });
    })

    it('should include layers and with the right visibility', function() {
      var config = {
        name: 'testing',
        layers: [
          {
          },
          {
            "visible": false
          },
          {
            "visible": true
          }
        ]
      };
      var namedMap = new NamedMap(config, {});

      // Layers 0 and 1 are visible, but layer 2 is hidden
      expect(namedMap.toJSON()).toEqual({
        layer0: 1,
        layer1: 0,
        layer2: 1
      });
    })
  })

  describe('.fetchAttributes', function() {
    var callback;

    beforeEach(function() {
      callback = jasmine.createSpy("callback");
    })

    it('should fetch the attributes and invoke the callback', function() {
      var mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      namedMap.createMap = function (callback) {
        callback(mapProperties);
      }

      // Fetch the map properties first
      namedMap.getTiles();

      var ajax = namedMap.options.ajax = jasmine.createSpy('ajax');
      var callback = jasmine.createSpy('callback');

      namedMap.fetchAttributes(0, 'feature_id', 2, callback);

      // Ajax request to the right endpoint with right attributes
      expect(ajax).toHaveBeenCalled();
      var ajaxOptions = ajax.calls.mostRecent().args[0];
      expect(ajaxOptions.dataType).toEqual('jsonp');
      expect(ajaxOptions.jsonpCallback).toEqual('_cdbi_layer_attributes_' + namedMap._attrCallbackName);
      expect(ajaxOptions.url).toEqual('http://rambo.carto.com:8081/api/v1/map/layergroupid/0/attributes/feature_id');
      expect(ajaxOptions.cache).toEqual(true);

      // Ajax succeeds
      ajaxOptions.success('wadus');

      expect(callback).toHaveBeenCalledWith('wadus');
    })

    it('should fetch attributes using an auth_token', function() {
      var mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      namedMap.createMap = function (callback) {
        callback(mapProperties);
      }

      namedMap.options.extra_params = {
        auth_token: 'token'
      }

      // Fetch the map properties first
      namedMap.getTiles();

      var ajax = namedMap.options.ajax = jasmine.createSpy('ajax');
      namedMap.fetchAttributes(0, 'feature_id', 2, callback);

      // Ajax request to the right endpoint with right attributes
      expect(ajax).toHaveBeenCalled();
      var ajaxOptions = ajax.calls.mostRecent().args[0];

      var expectedUrl = 'http://rambo.carto.com:8081/api/v1/map/layergroupid/0/attributes/feature_id?auth_token=token';
      expect(ajaxOptions.url).toEqual(expectedUrl);
    })

    it('should fetch attributes using multiple auth_tokens', function() {
      var mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "mapnik", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      namedMap.createMap = function (callback) {
        callback(mapProperties);
      }

      namedMap.options.extra_params = {
        auth_token: [ 'token1', 'token2' ]
      }

      // Fetch the map properties first
      namedMap.getTiles();

      var ajax = namedMap.options.ajax = jasmine.createSpy('ajax');
      namedMap.fetchAttributes(0, 'feature_id', 2, callback);

      // Ajax request to the right endpoint with right attributes
      expect(ajax).toHaveBeenCalled();
      var ajaxOptions = ajax.calls.mostRecent().args[0];

      var expectedUrl = 'http://rambo.carto.com:8081/api/v1/map/layergroupid/0/attributes/feature_id?auth_token[]=token1&auth_token[]=token2';
      expect(ajaxOptions.url).toEqual(expectedUrl);
    })

    it('should convert layergroup indexes to the corresponding indexes in the tiler', function() {
      var mapProperties = {
        "layergroupid": "layergroupid",
        "metadata": {
          "layers": [
            { "type": "http", "meta": {} },
            { "type": "mapnik", "meta": {} },
            { "type": "http", "meta": {} },
            { "type": "mapnik", "meta": {} }
          ]
        }
      }

      namedMap.createMap = function (callback) {
        callback(mapProperties);
      }

      // Fetch the map properties first
      namedMap.getTiles();

      var ajax = namedMap.options.ajax = jasmine.createSpy('ajax');

      // Fetch attributes for layer 0 (which is layer 1 in the tiler)
      namedMap.fetchAttributes(0, 'feature_id', 2, callback);

      var expectedUrl = 'http://rambo.carto.com:8081/api/v1/map/layergroupid/1/attributes/feature_id';
      var actualUrl = ajax.calls.mostRecent().args[0].url;

      expect(actualUrl).toEqual(expectedUrl);

      // Fetch attributes for layer 1 (which is layer 3 in the tiler)
      namedMap.fetchAttributes(1, 'feature_id', 2, callback);

      var expectedUrl = 'http://rambo.carto.com:8081/api/v1/map/layergroupid/3/attributes/feature_id';
      var actualUrl = ajax.calls.mostRecent().args[0].url;

      expect(actualUrl).toEqual(expectedUrl);
    })
  })

  describe('.setParams', function() {
    var namedMap;

    beforeEach(function() {
      var named_map = {
        params: {
          key1: 'value1'
        }
      };
      namedMap = new NamedMap(named_map, {
        tiler_domain:   "carto.com",
        tiler_port:     "8081",
        tiler_protocol: "https",
        user_name: 'rambo',
        no_cdn: true,
        subdomains: [null]
      });
    })

    it('should initialize params object if no params are present in the definition', function() {
      delete namedMap.named_map.params;

      namedMap.setParams('key2', 'value2');
      expect(namedMap.named_map.params).toEqual({
        key2: 'value2'
      })
    })

    it('should handle strings as arguments', function() {
      namedMap.setParams('key2', 'value2');
      expect(namedMap.named_map.params).toEqual({
        key1: 'value1',
        key2: 'value2'
      })
    })

    it('should handle objects as arguments', function() {
      namedMap.setParams({ key2: 'value2' });
      expect(namedMap.named_map.params).toEqual({
        key1: 'value1',
        key2: 'value2'
      })
    })

    it('should unset arguments', function() {
      namedMap.setParams({ key2: 'value2' });
      expect(namedMap.named_map.params).toEqual({
        key1: 'value1',
        key2: 'value2'
      })

      namedMap.setParams({ key1: null, key2: undefined });
      expect(namedMap.named_map.params).toEqual({})
    })

    it('should invalidate the map', function() {
      spyOn(namedMap, 'invalidate');

      namedMap.setParams();

      expect(namedMap.invalidate).toHaveBeenCalled();
    })
  });

  it("shoud have infowindow", function() {
    expect(namedMap.containInfowindow()).toEqual(true);
  });

  it("should get sublayer", function() {
    named_map = {
      name: 'testing',
      params: {
        color: 'red'
      }
    };
    namedMap = new NamedMap(named_map, {})
    expect(namedMap.getSubLayer(0)).not.toEqual(undefined);
  });

  it("should raise errors when try to set sql or cartocss", function() {
    expect(function() { namedMap.setCartoCSS('test') }).toThrow(new Error("cartocss is read-only in NamedMaps"));
    expect(function() { namedMap.setSQL('sql') }).toThrow(new Error("SQL is read-only in NamedMaps"));

    expect(function() {
      namedMap.getSubLayer(0).set({ 'sql':'test', })
    }).toThrow(new Error("sql is read-only in NamedMaps"));

    expect(function() {
      namedMap.getSubLayer(0).set({ interactivity: 'test1' });
    }).toThrow(new Error("interactivity is read-only in NamedMaps"));

    expect(function() {
      namedMap.getSubLayer(0).setInteractivity('test1');
    }).toThrow(new Error("interactivity is read-only in NamedMaps"));

    expect(function() {
      namedMap.getSubLayer(0).set({ 'hidden': 1 });
    }).not.toThrow();

    expect(function() {
      namedMap.getSubLayer(0).remove();
    }).toThrow(new Error("sublayers are read-only in Named Maps"));
    expect(function() {
      namedMap.createSubLayer();
    }).toThrow(new Error("sublayers are read-only in Named Maps"));
    expect(function() {
      namedMap.addLayer();
    }).toThrow(new Error("sublayers are read-only in Named Maps"));
  });

  it("should raise errors when try to get sql or cartocss", function() {
    expect(function() { namedMap.getCartoCSS('test') }).toThrow(new Error("cartocss can't be accessed in NamedMaps"));
    expect(function() { namedMap.getSQL('sql') }).toThrow(new Error("SQL can't be accessed in NamedMaps"));
  })

  it("should send auth_token when it's provided", function(done) {
    var tiles;
    var named_map = {
      name: 'testing',
      auth_token: 'auth_token_test',
      params: {
        color: 'red'
      },
      layers: [{}]
    };
    namedMap = new NamedMap(named_map, {
      tiler_domain:   "carto.com",
      tiler_port:     "8081",
      tiler_protocol: "https",
      user_name: 'rambo',
      no_cdn: true,
      subdomains: [null]
    });

    var mapProperties = {
      "layergroupid": "layergroupid",
      "metadata": {
        "layers": [
          { "type": "mapnik", "meta": {} },
          { "type": "mapnik", "meta": {} }
        ]
      }
    }

    namedMap.options.ajax = function(p) { 
      params = p;
      p.success(mapProperties);
    };

    namedMap._createMap();
    namedMap.getTiles(function(t) {
      tiles = t;
    });

    setTimeout(function() {
      expect(params.url.indexOf('auth_token=auth_token_test')).not.toEqual(-1);
      expect(tiles.tiles[0].indexOf('auth_token=auth_token_test')).not.toEqual(-1);
      expect(tiles.grids[0][0].indexOf('auth_token=auth_token_test')).not.toEqual(-1);

      namedMap.setAuthToken('test2');
      namedMap._createMap();

      setTimeout(function() {
        expect(params.url.indexOf('auth_token=test2')).not.toEqual(-1);

        setTimeout(function() {
          namedMap.setAuthToken(['token1', 'token2']);
          namedMap._createMap();
          namedMap.getTiles(function(t) {
            tiles = t;
          });

          setTimeout(function() {
            expect(params.url.indexOf('auth_token[]=token1')).not.toEqual(-1);
            expect(tiles.tiles[0].indexOf('auth_token[]=token1')).not.toEqual(-1);
            expect(tiles.grids[0][0].indexOf('auth_token[]=token1')).not.toEqual(-1);
            done();
          }, 100);

        }, 100);

      }, 100);

    }, 100);
  });

  it("should use https when auth_token is provided", function() {
    var named_map = {
      name: 'testing',
      auth_token: 'auth_token_test',
    };
    try {
      namedMap = new NamedMap(named_map, {
        tiler_domain:   "carto.com",
        tiler_port:     "8081",
        tiler_protocol: "http",
        user_name: 'rambo',
        no_cdn: true,
        subdomains: [null]
      });
      expect(0).toBe(1);
    } catch(e) {
      expect(e.message).toEqual("https must be used when map has token authentication");
    }
  });

  it("should return layer by index", function() {
    expect(namedMap.getLayerIndexByNumber(0)).toEqual(0);
    expect(namedMap.getLayerIndexByNumber(1)).toEqual(1);
  });
});