leaflet-js 0.7.9 → 0.8.dev2

data/lib/leaflet/spec/suites/layer/LayerGroupSpec.js

@@ -0,0 +1,71 @@
+describe('LayerGroup', function () {
+	describe("#hasLayer", function () {
+		it("returns false when passed undefined, null, or false", function () {
+			var lg = L.layerGroup();
+			expect(lg.hasLayer(undefined)).to.equal(false);
+			expect(lg.hasLayer(null)).to.equal(false);
+			expect(lg.hasLayer(false)).to.equal(false);
+		});
+	});
+
+	describe("#addLayer", function () {
+		it('adds a layer', function () {
+			var lg = L.layerGroup(),
+				marker = L.marker([0, 0]);
+
+			expect(lg.addLayer(marker)).to.eql(lg);
+
+			expect(lg.hasLayer(marker)).to.be(true);
+		});
+	});
+
+	describe("#removeLayer", function () {
+		it('removes a layer', function () {
+			var lg = L.layerGroup(),
+				marker = L.marker([0, 0]);
+
+			lg.addLayer(marker);
+			expect(lg.removeLayer(marker)).to.eql(lg);
+
+			expect(lg.hasLayer(marker)).to.be(false);
+		});
+	});
+
+	describe("#clearLayers", function () {
+		it('removes all layers', function () {
+			var lg = L.layerGroup(),
+				marker = L.marker([0, 0]);
+
+			lg.addLayer(marker);
+			expect(lg.clearLayers()).to.eql(lg);
+
+			expect(lg.hasLayer(marker)).to.be(false);
+		});
+	});
+
+	describe("#getLayers", function () {
+		it('gets all layers', function () {
+			var lg = L.layerGroup(),
+				marker = L.marker([0, 0]);
+
+			lg.addLayer(marker);
+
+			expect(lg.getLayers()).to.eql([marker]);
+		});
+	});
+
+	describe("#eachLayer", function () {
+		it('iterates over all layers', function () {
+			var lg = L.layerGroup(),
+				marker = L.marker([0, 0]),
+				ctx = { foo: 'bar' };
+
+			lg.addLayer(marker);
+
+			lg.eachLayer(function (layer) {
+				expect(layer).to.eql(marker);
+				expect(this).to.eql(ctx);
+			}, ctx);
+		});
+	});
+});

data/lib/leaflet/spec/suites/layer/PopupSpec.js

@@ -0,0 +1,119 @@
+describe('Popup', function () {
+
+	var c, map;
+
+	beforeEach(function () {
+		c = document.createElement('div');
+		c.style.width = '400px';
+		c.style.height = '400px';
+		map = new L.Map(c);
+		map.setView(new L.LatLng(55.8, 37.6), 6);
+	});
+
+	it("closes on map click when map has closePopupOnClick option", function () {
+		map.options.closePopupOnClick = true;
+
+		var popup = new L.Popup()
+			.setLatLng(new L.LatLng(55.8, 37.6))
+			.openOn(map);
+
+		happen.click(c);
+
+		expect(map.hasLayer(popup)).to.be(false);
+	});
+
+	it("closes on map click when popup has closeOnClick option", function () {
+		map.options.closePopupOnClick = false;
+
+		var popup = new L.Popup({closeOnClick: true})
+			.setLatLng(new L.LatLng(55.8, 37.6))
+			.openOn(map);
+
+		happen.click(c);
+
+		expect(map.hasLayer(popup)).to.be(false);
+	});
+
+	it("does not close on map click when popup has closeOnClick: false option", function () {
+		map.options.closePopupOnClick = true;
+
+		var popup = new L.Popup({closeOnClick: false})
+			.setLatLng(new L.LatLng(55.8, 37.6))
+			.openOn(map);
+
+		happen.click(c);
+
+		expect(map.hasLayer(popup)).to.be(true);
+	});
+
+	it("toggles its visibility when marker is clicked", function () {
+		var marker = new L.Marker(new L.LatLng(55.8, 37.6));
+		map.addLayer(marker);
+
+		marker.bindPopup('Popup1').openPopup();
+
+		map.options.closePopupOnClick = true;
+		happen.click(c);
+
+		// toggle open popup
+		sinon.spy(marker, "openPopup");
+		marker.fire('click');
+		expect(marker.openPopup.calledOnce).to.be(true);
+		expect(map.hasLayer(marker._popup)).to.be(true);
+		marker.openPopup.restore();
+
+		// toggle close popup
+		sinon.spy(marker, "closePopup");
+		marker.fire('click');
+		expect(marker.closePopup.calledOnce).to.be(true);
+		expect(map.hasLayer(marker._popup)).to.be(false);
+		marker.closePopup.restore();
+	});
+
+	it("should trigger popupopen on marker when popup opens", function () {
+		var marker1 = new L.Marker(new L.LatLng(55.8, 37.6));
+		var marker2 = new L.Marker(new L.LatLng(57.123076977278, 44.861962891635));
+
+		map.addLayer(marker1);
+		map.addLayer(marker2);
+
+		marker1.bindPopup('Popup1');
+		marker2.bindPopup('Popup2');
+
+		var spy = sinon.spy();
+
+		marker1.on('popupopen', spy);
+
+		expect(spy.called).to.be(false);
+		marker2.openPopup();
+		expect(spy.called).to.be(false);
+		marker1.openPopup();
+		expect(spy.called).to.be(true);
+	});
+
+	it("should trigger popupclose on marker when popup closes", function () {
+		var marker1 = new L.Marker(new L.LatLng(55.8, 37.6));
+		var marker2 = new L.Marker(new L.LatLng(57.123076977278, 44.861962891635));
+
+		map.addLayer(marker1);
+		map.addLayer(marker2);
+
+		marker1.bindPopup('Popup1');
+		marker2.bindPopup('Popup2');
+
+		var spy = sinon.spy();
+
+		marker1.on('popupclose', spy);
+
+		expect(spy.called).to.be(false);
+		marker2.openPopup();
+		expect(spy.called).to.be(false);
+		marker1.openPopup();
+		expect(spy.called).to.be(false);
+		marker2.openPopup();
+		expect(spy.called).to.be(true);
+		marker1.openPopup();
+		marker1.closePopup();
+		expect(spy.callCount).to.be(2);
+	});
+});

data/lib/leaflet/spec/suites/layer/marker/MarkerSpec.js

@@ -0,0 +1,117 @@
+describe("Marker", function () {
+	var map,
+		spy,
+		icon1,
+		icon2;
+
+	beforeEach(function () {
+		map = L.map(document.createElement('div')).setView([0, 0], 0);
+		icon1 = new L.Icon.Default();
+		icon2 = new L.Icon.Default({
+			iconUrl: icon1._getIconUrl('icon') + '?2',
+			shadowUrl: icon1._getIconUrl('shadow') + '?2'
+		});
+	});
+
+	describe("#setIcon", function () {
+		it("changes the icon to another image", function () {
+			var marker = new L.Marker([0, 0], {icon: icon1});
+			map.addLayer(marker);
+
+			var beforeIcon = marker._icon;
+			marker.setIcon(icon2);
+			var afterIcon = marker._icon;
+
+			expect(beforeIcon).to.be(afterIcon);
+			expect(afterIcon.src).to.contain(icon2._getIconUrl('icon'));
+		});
+
+		it("changes the icon to another DivIcon", function () {
+			var marker = new L.Marker([0, 0], {icon: new L.DivIcon({html: 'Inner1Text' }) });
+			map.addLayer(marker);
+
+			var beforeIcon = marker._icon;
+			marker.setIcon(new L.DivIcon({html: 'Inner2Text' }));
+			var afterIcon = marker._icon;
+
+			expect(beforeIcon).to.be(afterIcon);
+			expect(afterIcon.innerHTML).to.contain('Inner2Text');
+		});
+
+		it("removes text when changing to a blank DivIcon", function () {
+			var marker = new L.Marker([0, 0], {icon: new L.DivIcon({html: 'Inner1Text' }) });
+			map.addLayer(marker);
+
+			marker.setIcon(new L.DivIcon());
+			var afterIcon = marker._icon;
+
+			expect(marker._icon.innerHTML).to.not.contain('Inner1Text');
+		});
+
+		it("changes a DivIcon to an image", function () {
+			var marker = new L.Marker([0, 0], {icon: new L.DivIcon({html: 'Inner1Text' }) });
+			map.addLayer(marker);
+			var oldIcon = marker._icon;
+
+			marker.setIcon(icon1);
+
+			expect(oldIcon).to.not.be(marker._icon);
+			expect(oldIcon.parentNode).to.be(null);
+
+			expect(marker._icon.src).to.contain('marker-icon.png');
+			expect(marker._icon.parentNode).to.be(map._panes.markerPane);
+		});
+
+		it("changes an image to a DivIcon", function () {
+			var marker = new L.Marker([0, 0], {icon: icon1});
+			map.addLayer(marker);
+			var oldIcon = marker._icon;
+
+			marker.setIcon(new L.DivIcon({html: 'Inner1Text' }));
+
+			expect(oldIcon).to.not.be(marker._icon);
+			expect(oldIcon.parentNode).to.be(null);
+
+			expect(marker._icon.innerHTML).to.contain('Inner1Text');
+			expect(marker._icon.parentNode).to.be(map._panes.markerPane);
+		});
+
+		it("reuses the icon/shadow when changing icon", function () {
+			var marker = new L.Marker([0, 0], { icon: icon1});
+			map.addLayer(marker);
+			var oldIcon = marker._icon;
+			var oldShadow = marker._shadow;
+
+			marker.setIcon(icon2);
+
+			expect(oldIcon).to.be(marker._icon);
+			expect(oldShadow).to.be(marker._shadow);
+
+			expect(marker._icon.parentNode).to.be(map._panes.markerPane);
+			expect(marker._shadow.parentNode).to.be(map._panes.shadowPane);
+		});
+	});
+
+	describe("#setLatLng", function () {
+		it("fires a move event", function () {
+
+			var marker = new L.Marker([0, 0], { icon: icon1 });
+			map.addLayer(marker);
+
+			var beforeLatLng = marker._latlng;
+			var afterLatLng = new L.LatLng(1, 2);
+
+			var eventArgs = null;
+			marker.on('move', function (e) {
+				eventArgs = e;
+			});
+
+			marker.setLatLng(afterLatLng);
+
+			expect(eventArgs).to.not.be(null);
+			expect(eventArgs.oldLatlng).to.be(beforeLatLng);
+			expect(eventArgs.latlng).to.be(afterLatLng);
+			expect(marker.getLatLng()).to.be(afterLatLng);
+		});
+	});
+});

data/lib/leaflet/spec/suites/layer/tile/GridLayerSpec.js

@@ -0,0 +1,70 @@
+
+describe('GridLayer', function () {
+
+	var div;
+
+	beforeEach(function () {
+		div = document.createElement('div');
+		div.style.width = '800px';
+		div.style.height = '600px';
+		div.style.visibility = 'hidden';
+
+		document.body.appendChild(div);
+	});
+
+	afterEach(function () {
+		document.body.removeChild(div);
+	});
+
+	describe('#redraw', function () {
+		it('can be called before map.setView', function () {
+			var map = L.map(div),
+				grid = L.gridLayer().addTo(map);
+			expect(grid.redraw()).to.equal(grid);
+		});
+	});
+
+	describe('#setOpacity', function () {
+		it('can be called before map.setView', function () {
+			var map = L.map(div),
+				grid = L.gridLayer().addTo(map);
+			expect(grid.setOpacity(0.5)).to.equal(grid);
+		});
+	});
+
+	it('positions tiles correctly with wrapping and bounding', function () {
+
+		var map = L.map(div).setView([0, 0], 1);
+
+		var tiles = [];
+
+		var grid = L.gridLayer();
+		grid.createTile = function (coords) {
+			var tile = document.createElement('div');
+			tiles.push({coords: coords, tile: tile});
+			return tile;
+		};
+
+		map.addLayer(grid);
+
+		var loaded = {};
+
+		for (var i = 0; i < tiles.length; i++) {
+			var coords = tiles[i].coords,
+				pos = L.DomUtil.getPosition(tiles[i].tile);
+
+			loaded[pos.x + ':' + pos.y] = [coords.x, coords.y];
+		}
+
+		expect(loaded).to.eql({
+			'144:44': [0, 0],
+			'400:44': [1, 0],
+			'144:300': [0, 1],
+			'400:300': [1, 1],
+			'-112:44': [1, 0],
+			'656:44': [0, 0],
+			'-112:300': [1, 1],
+			'656:300': [0, 1]
+		});
+	});
+});

data/lib/leaflet/spec/suites/layer/tile/TileLayerSpec.js

@@ -0,0 +1,88 @@
+
+describe('TileLayer', function () {
+	var tileUrl = '';
+
+	describe("#getMaxZoom, #getMinZoom", function () {
+		var map;
+		beforeEach(function () {
+			map = L.map(document.createElement('div'));
+		});
+		describe("when a tilelayer is added to a map with no other layers", function () {
+			it("has the same zoomlevels as the tilelayer", function () {
+				var maxZoom = 10,
+					minZoom = 5;
+
+				map.setView([0, 0], 1);
+
+				L.tileLayer(tileUrl, {
+					maxZoom: maxZoom,
+					minZoom: minZoom
+				}).addTo(map);
+
+				expect(map.getMaxZoom()).to.be(maxZoom);
+				expect(map.getMinZoom()).to.be(minZoom);
+			});
+		});
+
+		describe("accessing a tilelayer's properties", function () {
+			it('provides a container', function () {
+				map.setView([0, 0], 1);
+
+				var layer = L.tileLayer(tileUrl).addTo(map);
+				expect(layer.getContainer()).to.be.ok();
+			});
+		});
+
+		describe("when a tilelayer is added to a map that already has a tilelayer", function () {
+			it("has its zoomlevels updated to fit the new layer", function () {
+				map.setView([0, 0], 1);
+
+				L.tileLayer(tileUrl, {minZoom: 10, maxZoom: 15}).addTo(map);
+				expect(map.getMinZoom()).to.be(10);
+				expect(map.getMaxZoom()).to.be(15);
+
+				L.tileLayer(tileUrl, {minZoom: 5, maxZoom: 10}).addTo(map);
+				expect(map.getMinZoom()).to.be(5);  // changed
+				expect(map.getMaxZoom()).to.be(15); // unchanged
+
+				L.tileLayer(tileUrl, {minZoom: 10, maxZoom: 20}).addTo(map);
+				expect(map.getMinZoom()).to.be(5);  // unchanged
+				expect(map.getMaxZoom()).to.be(20); // changed
+
+
+				L.tileLayer(tileUrl, {minZoom: 0, maxZoom: 25}).addTo(map);
+				expect(map.getMinZoom()).to.be(0); // changed
+				expect(map.getMaxZoom()).to.be(25); // changed
+			});
+		});
+		describe("when a tilelayer is removed from a map", function () {
+			it("has its zoomlevels updated to only fit the layers it currently has", function () {
+				var tiles = [  L.tileLayer(tileUrl, {minZoom: 10, maxZoom: 15}).addTo(map),
+							   L.tileLayer(tileUrl, {minZoom: 5, maxZoom: 10}).addTo(map),
+							   L.tileLayer(tileUrl, {minZoom: 10, maxZoom: 20}).addTo(map),
+							   L.tileLayer(tileUrl, {minZoom: 0, maxZoom: 25}).addTo(map)
+							];
+				map.whenReady(function () {
+					expect(map.getMinZoom()).to.be(0);
+					expect(map.getMaxZoom()).to.be(25);
+
+					map.removeLayer(tiles[0]);
+					expect(map.getMinZoom()).to.be(0);
+					expect(map.getMaxZoom()).to.be(25);
+
+					map.removeLayer(tiles[3]);
+					expect(map.getMinZoom()).to.be(5);
+					expect(map.getMaxZoom()).to.be(20);
+
+					map.removeLayer(tiles[2]);
+					expect(map.getMinZoom()).to.be(5);
+					expect(map.getMaxZoom()).to.be(10);
+
+					map.removeLayer(tiles[1]);
+					expect(map.getMinZoom()).to.be(0);
+					expect(map.getMaxZoom()).to.be(Infinity);
+				});
+			});
+		});
+	});
+});