leaflet-js 0.6.beta4 → 0.7.0

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

@@ -1,6 +1,6 @@
 describe('LayerGroup', function () {
 	describe("#addLayer", function () {
-		it('adds a layer', function() {
+		it('adds a layer', function () {
 			var lg = L.layerGroup(),
 				marker = L.marker([0, 0]);
 
@@ -10,7 +10,7 @@
 		});
 	});
 	describe("#removeLayer", function () {
-		it('removes a layer', function() {
+		it('removes a layer', function () {
 			var lg = L.layerGroup(),
 				marker = L.marker([0, 0]);
 
@@ -21,7 +21,7 @@
 		});
 	});
 	describe("#clearLayers", function () {
-		it('removes all layers', function() {
+		it('removes all layers', function () {
 			var lg = L.layerGroup(),
 				marker = L.marker([0, 0]);
 
@@ -32,7 +32,7 @@
 		});
 	});
 	describe("#getLayers", function () {
-		it('gets all layers', function() {
+		it('gets all layers', function () {
 			var lg = L.layerGroup(),
 				marker = L.marker([0, 0]);
 
@@ -42,14 +42,14 @@
 		});
 	});
 	describe("#eachLayer", function () {
-		it('iterates over all layers', 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) {
+			lg.eachLayer(function (layer) {
 				expect(layer).to.eql(marker);
 				expect(this).to.eql(ctx);
 			}, ctx);

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

@@ -1,16 +1,76 @@
-describe('Popup', function() {
+describe('Popup', function () {
 
-	var map;
+	var c, map;
 
 	beforeEach(function () {
-		var c = document.createElement('div');
+		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("should trigger popupopen on marker when popup opens", function() {
+	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));
 
@@ -31,7 +91,7 @@ describe('Popup', function() {
 		expect(spy.called).to.be(true);
 	});
 
-	it("should trigger popupclose on marker when popup closes", function() {
+	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));
 

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

@@ -11,12 +11,14 @@ describe('TileLayer', 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);
+				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);
 			});
@@ -35,33 +37,32 @@ describe('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);
+				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);
+				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);
+				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);
+				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)
+				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() {
+				map.whenReady(function () {
 					expect(map.getMinZoom()).to.be(0);
 					expect(map.getMaxZoom()).to.be(25);
 

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

@@ -0,0 +1,94 @@
+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);
+		});
+	});
+});

data/lib/leaflet/spec/suites/layer/vector/CircleMarkerSpec.js

@@ -1,13 +1,13 @@
-describe('CircleMarker', function() {
-	describe("#_radius", function() {
+describe('CircleMarker', function () {
+	describe("#_radius", function () {
 		var map;
-		beforeEach(function() {
+		beforeEach(function () {
 			map = L.map(document.createElement('div'));
 			map.setView([0, 0], 1);
 		});
-		describe("when a CircleMarker is added to the map ", function() {
-			describe("with a radius set as an option", function() {
-				it("takes that radius", function() {
+		describe("when a CircleMarker is added to the map ", function () {
+			describe("with a radius set as an option", function () {
+				it("takes that radius", function () {
 					var marker = L.circleMarker([0, 0], { radius: 20 }).addTo(map);
 
 					expect(marker._radius).to.be(20);
@@ -33,7 +33,7 @@
 			});
 
 			describe("and setStyle is used to change the radius after adding", function () {
-				it("takes the given radius", function() {
+				it("takes the given radius", function () {
 					var marker = L.circleMarker([0, 0], { radius: 20 });
 					marker.addTo(map);
 					marker.setStyle({ radius: 15 });

data/lib/leaflet/spec/suites/layer/vector/PolygonSpec.js

@@ -1,4 +1,4 @@
-describe('Polygon', function() {
+describe('Polygon', function () {
 
 	var c = document.createElement('div');
 	c.style.width = '400px';
@@ -6,7 +6,7 @@ describe('Polygon', function() {
 	var map = new L.Map(c);
 	map.setView(new L.LatLng(55.8, 37.6), 6);
 
-	describe("#initialize", function() {
+	describe("#initialize", function () {
 		it("doesn't overwrite the given latlng array", function () {
 			var originalLatLngs = [
 				[1, 2],
@@ -19,6 +19,26 @@ describe('Polygon', function() {
 			expect(sourceLatLngs).to.eql(originalLatLngs);
 			expect(polygon._latlngs).to.not.eql(sourceLatLngs);
 		});
+
+		it("can be called with an empty array", function () {
+			var polygon = new L.Polygon([]);
+			expect(polygon.getLatLngs()).to.eql([]);
+		});
+
+		it("can be initialized with holes", function () {
+			var originalLatLngs = [
+				[ //external rink
+					[0, 10], [10, 10], [10, 0]
+				], [ //hole
+					[2, 3], [2, 4], [3, 4]
+				]
+			];
+
+			var polygon = new L.Polygon(originalLatLngs);
+
+			//getLatLngs() returns only external ring
+			expect(polygon.getLatLngs()).to.eql([L.latLng([0, 10]), L.latLng([10, 10]), L.latLng([10, 0])]);
+		});
 	});
 
 	describe("#setLatLngs", function () {
@@ -35,6 +55,22 @@ describe('Polygon', function() {
 
 			expect(sourceLatLngs).to.eql(originalLatLngs);
 		});
+
+		it("can be set external ring and holes", function () {
+			var latLngs = [
+				[ //external rink
+					[0, 10], [10, 10], [10, 0]
+				], [ //hole
+					[2, 3], [2, 4], [3, 4]
+				]
+			];
+
+			var polygon = new L.Polygon([]);
+			polygon.setLatLngs(latLngs);
+
+			//getLatLngs() returns only external ring
+			expect(polygon.getLatLngs()).to.eql([L.latLng([0, 10]), L.latLng([10, 10]), L.latLng([10, 0])]);
+		});
 	});
 
 	describe("#spliceLatLngs", function () {

data/lib/leaflet/spec/suites/layer/vector/PolylineGeometrySpec.js

@@ -1,4 +1,4 @@
-describe('PolylineGeometry', function() {
+describe('PolylineGeometry', function () {
 
 	var c = document.createElement('div');
 	c.style.width = '400px';
@@ -6,12 +6,12 @@ describe('PolylineGeometry', function() {
 	var map = new L.Map(c);
 	map.setView(new L.LatLng(55.8, 37.6), 6);
 
-	describe("#distanceTo", function() {
-		it("calculates distances to points", function() {
+	describe("#distanceTo", function () {
+		it("calculates distances to points", function () {
 			var p1 = map.latLngToLayerPoint(new L.LatLng(55.8, 37.6));
 			var p2 = map.latLngToLayerPoint(new L.LatLng(57.123076977278, 44.861962891635));
 			var latlngs = [[56.485503424111, 35.545556640339], [55.972522915346, 36.116845702918], [55.502459116923, 34.930322265253], [55.31534617509, 38.973291015816]]
-			.map(function(ll) {
+			.map(function (ll) {
 				return new L.LatLng(ll[0], ll[1]);
 			});
 			var polyline = new L.Polyline([], {

data/lib/leaflet/spec/suites/layer/vector/PolylineSpec.js

@@ -1,4 +1,4 @@
-describe('Polyline', function() {
+describe('Polyline', function () {
 
 	var c = document.createElement('div');
 	c.style.width = '400px';
@@ -6,7 +6,7 @@ describe('Polyline', function() {
 	var map = new L.Map(c);
 	map.setView(new L.LatLng(55.8, 37.6), 6);
 
-	describe("#initialize", function() {
+	describe("#initialize", function () {
 		it("doesn't overwrite the given latlng array", function () {
 			var originalLatLngs = [
 				[1, 2],

data/lib/leaflet/spec/suites/map/MapSpec.js

@@ -29,8 +29,8 @@ describe("Map", function () {
 				var container = document.createElement('div'),
 					map = new L.Map(container);
 				expect(function () {
-					new L.Map(container);
-				}).to.throwException(function(e) {
+					L.map(container);
+				}).to.throwException(function (e) {
 					expect(e.message).to.eql("Map container is already initialized.");
 				});
 				map.remove();
@@ -38,8 +38,8 @@ describe("Map", function () {
 
 			it("throws an exception if a container is not found", function () {
 				expect(function () {
-					new L.Map('nonexistentdivelement');
-				}).to.throwException(function(e) {
+					L.map('nonexistentdivelement');
+				}).to.throwException(function (e) {
 					expect(e.message).to.eql("Map container not found.");
 				});
 				map.remove();
@@ -72,11 +72,24 @@ describe("Map", function () {
 	});
 
 	describe('#getCenter', function () {
-		it ('throws if not set before', function () {
+		it('throws if not set before', function () {
 			expect(function () {
 				map.getCenter();
 			}).to.throwError();
 		});
+
+		it('returns a precise center when zoomed in after being set (#426)', function () {
+			var center = L.latLng(10, 10);
+			map.setView(center, 1);
+			map.setZoom(19);
+			expect(map.getCenter()).to.eql(center);
+		});
+
+		it('returns correct center after invalidateSize (#1919)', function () {
+			map.setView(L.latLng(10, 10), 1);
+			map.invalidateSize();
+			expect(map.getCenter()).not.to.eql(L.latLng(10, 10));
+		});
 	});
 
 	describe("#whenReady", function () {
@@ -108,6 +121,12 @@ describe("Map", function () {
 			expect(map.getZoom()).to.be(13);
 			expect(map.getCenter().distanceTo([51.505, -0.09])).to.be.lessThan(5);
 		});
+		it("can be passed without a zoom specified", function () {
+			map.setZoom(13);
+			expect(map.setView([51.605, -0.11])).to.be(map);
+			expect(map.getZoom()).to.be(13);
+			expect(map.getCenter().distanceTo([51.605, -0.11])).to.be.lessThan(5);
+		});
 	});
 
 	describe("#getBounds", function () {
@@ -120,24 +139,135 @@ describe("Map", function () {
 		});
 	});
 
+	describe('#setMaxBounds', function () {
+		it("aligns pixel-wise map view center with maxBounds center if it cannot move view bounds inside maxBounds (#1908)", function () {
+			var container = map.getContainer();
+			// large view, cannot fit within maxBounds
+			container.style.width = container.style.height = "1000px";
+			document.body.appendChild(container);
+			// maxBounds
+			var bounds = L.latLngBounds([51.5, -0.05], [51.55, 0.05]);
+			map.setMaxBounds(bounds, {animate: false});
+			// set view outside
+			map.setView(L.latLng([53.0, 0.15]), 12, {animate: false});
+			// get center of bounds in pixels
+			var boundsCenter = map.project(bounds.getCenter()).round();
+			expect(map.project(map.getCenter()).round()).to.eql(boundsCenter);
+			document.body.removeChild(container);
+		});
+		it("moves map view within maxBounds by changing one coordinate", function () {
+			var container = map.getContainer();
+			// small view, can fit within maxBounds
+			container.style.width = container.style.height = "200px";
+			document.body.appendChild(container);
+			// maxBounds
+			var bounds = L.latLngBounds([51, -0.2], [52, 0.2]);
+			map.setMaxBounds(bounds, {animate: false});
+			// set view outside maxBounds on one direction only
+			// leaves untouched the other coordinate (that is not already centered)
+			var initCenter = [53.0, 0.1];
+			map.setView(L.latLng(initCenter), 16, {animate: false});
+			// one pixel coordinate hasn't changed, the other has
+			var pixelCenter = map.project(map.getCenter()).round();
+			var pixelInit = map.project(initCenter).round();
+			expect(pixelCenter.x).to.eql(pixelInit.x);
+			expect(pixelCenter.y).not.to.eql(pixelInit.y);
+			// the view is inside the bounds
+			expect(bounds.contains(map.getBounds())).to.be(true);
+			document.body.removeChild(container);
+		});
+	});
+
 	describe("#getMinZoom and #getMaxZoom", function () {
+		describe('#getMinZoom', function () {
+			it('returns 0 if not set by Map options or TileLayer options', function () {
+				var map = L.map(document.createElement('div'));
+				expect(map.getMinZoom()).to.be(0);
+			});
+		});
+
 		it("minZoom and maxZoom options overrides any minZoom and maxZoom set on layers", function () {
-			var c = document.createElement('div'),
-			    map = L.map(c, { minZoom: 5, maxZoom: 10 });
-			L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
-			L.tileLayer("{z}{x}{y}", { minZoom:5, maxZoom: 15 }).addTo(map);
-			expect(map.getMinZoom()).to.be(5);
-			expect(map.getMaxZoom()).to.be(10);
+
+			var map = L.map(document.createElement('div'), {minZoom: 2, maxZoom: 20});
+
+			L.tileLayer("{z}{x}{y}", {minZoom: 4, maxZoom: 10}).addTo(map);
+			L.tileLayer("{z}{x}{y}", {minZoom: 6, maxZoom: 17}).addTo(map);
+			L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 22}).addTo(map);
+
+			expect(map.getMinZoom()).to.be(2);
+			expect(map.getMaxZoom()).to.be(20);
 		});
 	});
 
 	describe("#addLayer", function () {
+		it("calls layer.onAdd immediately if the map is ready", function () {
+			var layer = { onAdd: sinon.spy() };
+			map.setView([0, 0], 0);
+			map.addLayer(layer);
+			expect(layer.onAdd.called).to.be.ok();
+		});
+
+		it("calls layer.onAdd when the map becomes ready", function () {
+			var layer = { onAdd: sinon.spy() };
+			map.addLayer(layer);
+			expect(layer.onAdd.called).not.to.be.ok();
+			map.setView([0, 0], 0);
+			expect(layer.onAdd.called).to.be.ok();
+		});
+
+		it("does not call layer.onAdd if the layer is removed before the map becomes ready", function () {
+			var layer = { onAdd: sinon.spy(), onRemove: sinon.spy() };
+			map.addLayer(layer);
+			map.removeLayer(layer);
+			map.setView([0, 0], 0);
+			expect(layer.onAdd.called).not.to.be.ok();
+		});
+
+		it("fires a layeradd event immediately if the map is ready", function () {
+			var layer = { onAdd: sinon.spy() },
+			    spy = sinon.spy();
+			map.on('layeradd', spy);
+			map.setView([0, 0], 0);
+			map.addLayer(layer);
+			expect(spy.called).to.be.ok();
+		});
+
+		it("fires a layeradd event when the map becomes ready", function () {
+			var layer = { onAdd: sinon.spy() },
+			    spy = sinon.spy();
+			map.on('layeradd', spy);
+			map.addLayer(layer);
+			expect(spy.called).not.to.be.ok();
+			map.setView([0, 0], 0);
+			expect(spy.called).to.be.ok();
+		});
+
+		it("does not fire a layeradd event if the layer is removed before the map becomes ready", function () {
+			var layer = { onAdd: sinon.spy(), onRemove: sinon.spy() },
+			    spy = sinon.spy();
+			map.on('layeradd', spy);
+			map.addLayer(layer);
+			map.removeLayer(layer);
+			map.setView([0, 0], 0);
+			expect(spy.called).not.to.be.ok();
+		});
+
+		it("adds the layer before firing layeradd", function (done) {
+			var layer = { onAdd: sinon.spy(), onRemove: sinon.spy() };
+			map.on('layeradd', function () {
+				expect(map.hasLayer(layer)).to.be.ok();
+				done();
+			});
+			map.setView([0, 0], 0);
+			map.addLayer(layer);
+		});
+
 		describe("When the first layer is added to a map", function () {
 			it("fires a zoomlevelschange event", function () {
 				var spy = sinon.spy();
 				map.on("zoomlevelschange", spy);
 				expect(spy.called).not.to.be.ok();
-				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+				L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map);
 				expect(spy.called).to.be.ok();
 			});
 		});
@@ -145,10 +275,10 @@ describe("Map", function () {
 		describe("when a new layer with greater zoomlevel coverage than the current layer is added to a map", function () {
 			it("fires a zoomlevelschange event", function () {
 				var spy = sinon.spy();
-				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+				L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map);
 				map.on("zoomlevelschange", spy);
 				expect(spy.called).not.to.be.ok();
-				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 15 }).addTo(map);
+				L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 15}).addTo(map);
 				expect(spy.called).to.be.ok();
 			});
 		});
@@ -156,23 +286,84 @@ describe("Map", function () {
 		describe("when a new layer with the same or lower zoomlevel coverage as the current layer is added to a map", function () {
 			it("fires no zoomlevelschange event", function () {
 				var spy = sinon.spy();
-				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+				L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map);
 				map.on("zoomlevelschange", spy);
 				expect(spy.called).not.to.be.ok();
-				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+				L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map);
 				expect(spy.called).not.to.be.ok();
-				L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 5 }).addTo(map);
+				L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 5}).addTo(map);
 				expect(spy.called).not.to.be.ok();
 			});
 		});
 	});
 
 	describe("#removeLayer", function () {
+		it("calls layer.onRemove if the map is ready", function () {
+			var layer = { onAdd: sinon.spy(), onRemove: sinon.spy() };
+			map.setView([0, 0], 0);
+			map.addLayer(layer);
+			map.removeLayer(layer);
+			expect(layer.onRemove.called).to.be.ok();
+		});
+
+		it("does not call layer.onRemove if the layer was not added", function () {
+			var layer = { onAdd: sinon.spy(), onRemove: sinon.spy() };
+			map.setView([0, 0], 0);
+			map.removeLayer(layer);
+			expect(layer.onRemove.called).not.to.be.ok();
+		});
+
+		it("does not call layer.onRemove if the map is not ready", function () {
+			var layer = { onAdd: sinon.spy(), onRemove: sinon.spy() };
+			map.addLayer(layer);
+			map.removeLayer(layer);
+			expect(layer.onRemove.called).not.to.be.ok();
+		});
+
+		it("fires a layerremove event if the map is ready", function () {
+			var layer = { onAdd: sinon.spy(), onRemove: sinon.spy() },
+			    spy = sinon.spy();
+			map.on('layerremove', spy);
+			map.setView([0, 0], 0);
+			map.addLayer(layer);
+			map.removeLayer(layer);
+			expect(spy.called).to.be.ok();
+		});
+
+		it("does not fire a layerremove if the layer was not added", function () {
+			var layer = { onAdd: sinon.spy(), onRemove: sinon.spy() },
+			    spy = sinon.spy();
+			map.on('layerremove', spy);
+			map.setView([0, 0], 0);
+			map.removeLayer(layer);
+			expect(spy.called).not.to.be.ok();
+		});
+
+		it("does not fire a layerremove if the map is not ready", function () {
+			var layer = { onAdd: sinon.spy(), onRemove: sinon.spy() },
+			    spy = sinon.spy();
+			map.on('layerremove', spy);
+			map.addLayer(layer);
+			map.removeLayer(layer);
+			expect(spy.called).not.to.be.ok();
+		});
+
+		it("removes the layer before firing layerremove", function (done) {
+			var layer = { onAdd: sinon.spy(), onRemove: sinon.spy() };
+			map.on('layerremove', function () {
+				expect(map.hasLayer(layer)).not.to.be.ok();
+				done();
+			});
+			map.setView([0, 0], 0);
+			map.addLayer(layer);
+			map.removeLayer(layer);
+		});
+
 		describe("when the last tile layer on a map is removed", function () {
 			it("fires a zoomlevelschange event", function () {
-				map.whenReady(function(){
+				map.whenReady(function () {
 					var spy = sinon.spy();
-					var tl = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map);
+					var tl = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map);
 
 					map.on("zoomlevelschange", spy);
 					expect(spy.called).not.to.be.ok();
@@ -184,10 +375,10 @@ describe("Map", function () {
 
 		describe("when a tile layer is removed from a map and it had greater zoom level coverage than the remainding layer", function () {
 			it("fires a zoomlevelschange event", function () {
-				map.whenReady(function(){
+				map.whenReady(function () {
 					var spy = sinon.spy(),
-						tl = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map),
-					    t2 = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 15 }).addTo(map);
+						tl = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map),
+					    t2 = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 15}).addTo(map);
 
 					map.on("zoomlevelschange", spy);
 					expect(spy.called).to.not.be.ok();
@@ -199,10 +390,10 @@ describe("Map", function () {
 
 		describe("when a tile layer is removed from a map it and it had lesser or the sa,e zoom level coverage as the remainding layer(s)", function () {
 			it("fires no zoomlevelschange event", function () {
-				map.whenReady(function(){
-					var tl = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map),
-					    t2 = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 10 }).addTo(map),
-					    t3 = L.tileLayer("{z}{x}{y}", { minZoom:0, maxZoom: 5 }).addTo(map);
+				map.whenReady(function () {
+					var tl = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map),
+					    t2 = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map),
+					    t3 = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 5}).addTo(map);
 
 					map.on("zoomlevelschange", spy);
 					expect(spy).not.toHaveBeenCalled();
@@ -241,4 +432,105 @@ describe("Map", function () {
 			expect(spy.thisValues[0]).to.eql(map);
 		});
 	});
+
+	describe("#invalidateSize", function () {
+		var container,
+		    origWidth = 100,
+			clock;
+
+		beforeEach(function () {
+			container = map.getContainer();
+			container.style.width = origWidth + "px";
+			document.body.appendChild(container);
+			map.setView([0, 0], 0);
+			map.invalidateSize({pan: false});
+			clock = sinon.useFakeTimers();
+		});
+
+		afterEach(function () {
+			document.body.removeChild(container);
+			clock.restore();
+		});
+
+		it("pans by the right amount when growing in 1px increments", function () {
+			container.style.width = (origWidth + 1) + "px";
+			map.invalidateSize();
+			expect(map._getMapPanePos().x).to.be(1);
+
+			container.style.width = (origWidth + 2) + "px";
+			map.invalidateSize();
+			expect(map._getMapPanePos().x).to.be(1);
+
+			container.style.width = (origWidth + 3) + "px";
+			map.invalidateSize();
+			expect(map._getMapPanePos().x).to.be(2);
+		});
+
+		it("pans by the right amount when shrinking in 1px increments", function () {
+			container.style.width = (origWidth - 1) + "px";
+			map.invalidateSize();
+			expect(map._getMapPanePos().x).to.be(0);
+
+			container.style.width = (origWidth - 2) + "px";
+			map.invalidateSize();
+			expect(map._getMapPanePos().x).to.be(-1);
+
+			container.style.width = (origWidth - 3) + "px";
+			map.invalidateSize();
+			expect(map._getMapPanePos().x).to.be(-1);
+		});
+
+		it("pans back to the original position after growing by an odd size and back", function () {
+			container.style.width = (origWidth + 5) + "px";
+			map.invalidateSize();
+
+			container.style.width = origWidth + "px";
+			map.invalidateSize();
+
+			expect(map._getMapPanePos().x).to.be(0);
+		});
+
+		it("emits no move event if the size has not changed", function () {
+			var spy = sinon.spy();
+			map.on("move", spy);
+
+			map.invalidateSize();
+
+			expect(spy.called).not.to.be.ok();
+		});
+
+		it("emits a move event if the size has changed", function () {
+			var spy = sinon.spy();
+			map.on("move", spy);
+
+			container.style.width = (origWidth + 5) + "px";
+			map.invalidateSize();
+
+			expect(spy.called).to.be.ok();
+		});
+
+		it("emits a moveend event if the size has changed", function () {
+			var spy = sinon.spy();
+			map.on("moveend", spy);
+
+			container.style.width = (origWidth + 5) + "px";
+			map.invalidateSize();
+
+			expect(spy.called).to.be.ok();
+		});
+
+		it("debounces the moveend event if the debounceMoveend option is given", function () {
+			var spy = sinon.spy();
+			map.on("moveend", spy);
+
+			container.style.width = (origWidth + 5) + "px";
+			map.invalidateSize({debounceMoveend: true});
+
+			expect(spy.called).not.to.be.ok();
+
+			clock.tick(200);
+
+			expect(spy.called).to.be.ok();
+		});
+	});
 });