leaflet-js 0.6.beta4

data/lib/leaflet/spec/suites/core/UtilSpec.js

@@ -0,0 +1,212 @@
+describe('Util', function() {
+
+	describe('#extend', function() {
+		var a;
+
+		beforeEach(function() {
+			a = {
+				foo: 5,
+				bar: 'asd'
+			};
+		});
+
+		it('extends the first argument with the properties of the second', function() {
+			L.Util.extend(a, {
+				bar: 7,
+				baz: 3
+			});
+
+			expect(a).to.eql({
+				foo: 5,
+				bar: 7,
+				baz: 3
+			});
+		});
+
+		it('accepts more than 2 arguments', function() {
+			L.Util.extend(a, {bar: 7}, {baz: 3});
+
+			expect(a).to.eql({
+				foo: 5,
+				bar: 7,
+				baz: 3
+			});
+		});
+	});
+
+	describe('#bind', function() {
+		it('returns the given function with the given context', function() {
+			var fn = function() {
+				return this;
+			};
+
+			var fn2 = L.Util.bind(fn, { foo: 'bar' });
+
+			expect(fn2()).to.eql({ foo: 'bar' });
+		});
+
+		it('passes additional arguments to the bound function', function () {
+			var fn = sinon.spy(),
+				foo = {},
+				a = {},
+				b = {};
+
+			var fn2 = L.Util.bind(fn, foo, a, b);
+
+			fn2();
+
+			expect(fn.calledWith(a, b)).to.be.ok();
+		});
+	});
+
+	describe('#stamp', function() {
+		it('sets a unique id on the given object and returns it', function() {
+			var a = {},
+				id = L.Util.stamp(a);
+
+			expect(typeof id).to.eql('number');
+			expect(L.Util.stamp(a)).to.eql(id);
+
+			var b = {},
+				id2 = L.Util.stamp(b);
+
+			expect(id2).not.to.eql(id);
+		});
+	});
+
+	describe('#invokeEach', function () {
+		it('calls the given method/context with each key/value and additional arguments', function () {
+			var spy = sinon.spy(),
+			    ctx = {};
+
+			var result = L.Util.invokeEach({
+				foo: 'bar',
+				yo: 'hey'
+			}, spy, ctx, 1, 2, 3);
+
+			expect(spy.firstCall.calledWith('foo', 'bar', 1, 2, 3)).to.be.ok();
+			expect(spy.secondCall.calledWith('yo', 'hey', 1, 2, 3)).to.be.ok();
+
+			expect(spy.firstCall.calledOn(ctx)).to.be.ok();
+			expect(spy.secondCall.calledOn(ctx)).to.be.ok();
+
+			expect(result).to.be(true);
+		});
+
+		it('returns false if the given agument is not object', function () {
+			var spy = sinon.spy();
+
+			expect(L.Util.invokeEach('foo', spy)).to.be(false);
+			expect(spy.called).to.be(false);
+		});
+	});
+
+	describe('#falseFn', function () {
+		it('returns false', function () {
+			expect(L.Util.falseFn()).to.be(false);
+		});
+	});
+
+	describe('#formatNum', function () {
+		it('formats numbers with a given precision', function () {
+			expect(L.Util.formatNum(13.12325555, 3)).to.eql(13.123);
+			expect(L.Util.formatNum(13.12325555)).to.eql(13.12326);
+		});
+	});
+
+
+	describe('#getParamString', function() {
+		it('creates a valid query string for appending depending on url input', function() {
+			var a = {
+				url: "http://example.com/get",
+				obj: {bar: 7, baz: 3},
+				result: "?bar=7&baz=3"
+			};
+
+			expect(L.Util.getParamString(a.obj,a.url)).to.eql(a.result);
+
+			var b = {
+				url: "http://example.com/get?justone=qs",
+				obj: {bar: 7, baz: 3},
+				result: "&bar=7&baz=3"
+			};
+
+			expect(L.Util.getParamString(b.obj,b.url)).to.eql(b.result);
+
+			var c = {
+				url: undefined,
+				obj: {bar: 7, baz: 3},
+				result: "?bar=7&baz=3"
+			};
+
+			expect(L.Util.getParamString(c.obj,c.url)).to.eql(c.result);
+		});
+	});
+
+	describe('#requestAnimFrame', function () {
+		it('calles a function on next frame, unless canceled', function (done) {
+			var spy = sinon.spy(),
+				spy2 = sinon.spy(),
+				foo = {};
+
+			L.Util.requestAnimFrame(spy);
+
+			L.Util.requestAnimFrame(function () {
+				expect(this).to.eql(foo);
+				done();
+			}, foo);
+
+			L.Util.cancelAnimFrame(spy);
+		});
+	});
+
+	describe('#limitExecByInterval', function() {
+		it('limits execution to not more often than specified time interval', function (done) {
+			var spy = sinon.spy();
+
+			var fn = L.Util.limitExecByInterval(spy, 20);
+
+			fn();
+			fn();
+			fn();
+
+			expect(spy.callCount).to.eql(1);
+
+			setTimeout(function () {
+				expect(spy.callCount).to.eql(2);
+				done();
+			}, 30);
+		});
+	});
+
+	describe('#splitWords', function () {
+		it('splits words into an array', function () {
+			expect(L.Util.splitWords('foo bar baz')).to.eql(['foo', 'bar', 'baz']);
+		});
+	});
+
+	// TODO setOptions
+
+	describe('#template', function () {
+		it('evaluates templates with a given data object', function () {
+			var tpl = 'Hello {foo} and {bar}!';
+
+			var str = L.Util.template(tpl, {
+				foo: 'Vlad',
+				bar: 'Dave'
+			});
+
+			expect(str).to.eql('Hello Vlad and Dave!');
+		});
+
+		it('does not modify text without a token variable', function () {
+			expect(L.Util.template('foo', {})).to.eql('foo');
+		});
+
+		it('throws when a template token is not given', function () {
+			expect(function () {
+				L.Util.template(tpl, {foo: 'bar'});
+			}).to.throwError();
+		});
+	});
+});

data/lib/leaflet/spec/suites/dom/DomEventSpec.js

@@ -0,0 +1,102 @@
+describe('DomEvent', function() {
+	var el;
+
+	function simulateClick(el) {
+		if (document.createEvent) {
+			var e = document.createEvent('MouseEvents');
+			e.initMouseEvent('click', true, true, window, 
+					0, 0, 0, 0, 0, false, false, false, false, 0, null);
+			return el.dispatchEvent(e);
+		} else if (el.fireEvent) {
+			return el.fireEvent('onclick');
+		}
+	}
+
+	beforeEach(function() {
+		el = document.createElement('div');
+		el.style.position = 'absolute';
+		el.style.top = el.style.left = '-10000px';
+		document.body.appendChild(el);
+	});
+
+	afterEach(function() {
+		document.body.removeChild(el);
+	});
+
+	describe('#addListener', function() {
+		it('adds a listener and calls it on event', function() {
+			var listener1 = sinon.spy(),
+				listener2 = sinon.spy();
+
+			L.DomEvent.addListener(el, 'click', listener1);
+			L.DomEvent.addListener(el, 'click', listener2);
+
+			simulateClick(el);
+
+			expect(listener1.called).to.be.ok();
+			expect(listener2.called).to.be.ok();
+		});
+
+		it('binds "this" to the given context', function() {
+			var obj = {foo: 'bar'},
+				result;
+
+			L.DomEvent.addListener(el, 'click', function() {
+				result = this;
+			}, obj);
+
+			simulateClick(el);
+
+			expect(result).to.eql(obj);
+		});
+
+		it('passes an event object to the listener', function() {
+			var type;
+
+			L.DomEvent.addListener(el, 'click', function(e) {
+				type = e && e.type;
+			});
+			simulateClick(el);
+
+			expect(type).to.eql('click');
+		});
+	});
+
+	describe('#removeListener', function() {
+		it('removes a previously added listener', function() {
+			var listener = sinon.spy();
+
+			L.DomEvent.addListener(el, 'click', listener);
+			L.DomEvent.removeListener(el, 'click', listener);
+
+			simulateClick(el);
+
+			expect(listener.called).to.not.be.ok();
+		});
+	});
+
+	describe('#stopPropagation', function() {
+		it('stops propagation of the given event', function() {
+			var child = document.createElement('div'),
+				listener = sinon.spy();
+
+			el.appendChild(child);
+
+			L.DomEvent.addListener(child, 'click', L.DomEvent.stopPropagation);
+			L.DomEvent.addListener(el, 'click', listener);
+
+			simulateClick(child);
+
+			expect(listener.called).to.not.be.ok();
+
+			el.removeChild(child);
+		});
+	});
+	describe('#preventDefault', function() {
+		it('prevents the default action of event', function() {
+			L.DomEvent.addListener(el, 'click', L.DomEvent.preventDefault);
+
+			expect(simulateClick(el)).to.be(false);
+		});
+	});
+});

data/lib/leaflet/spec/suites/dom/DomUtilSpec.js

@@ -0,0 +1,89 @@
+describe('DomUtil', function() {
+	var el;
+
+	beforeEach(function() {
+		el = document.createElement('div');
+		el.style.position = 'absolute';
+		el.style.top = el.style.left = '-10000px';
+		document.body.appendChild(el);
+	});
+
+	afterEach(function() {
+		document.body.removeChild(el);
+	});
+
+	describe('#get', function() {
+		it('gets element by id if the given argument is string', function() {
+			el.id = 'testId';
+			expect(L.DomUtil.get(el.id)).to.eql(el);
+		});
+
+		it('returns the element if it is given as an argument', function() {
+			expect(L.DomUtil.get(el)).to.eql(el);
+		});
+	});
+
+	describe('#addClass, #removeClass, #hasClass', function() {
+		it('has defined class for test element', function() {
+			el.className = 'bar foo baz ';
+			expect(L.DomUtil.hasClass(el, 'foo')).to.be.ok();
+			expect(L.DomUtil.hasClass(el, 'bar')).to.be.ok();
+			expect(L.DomUtil.hasClass(el, 'baz')).to.be.ok();
+			expect(L.DomUtil.hasClass(el, 'boo')).to.not.be.ok();
+		});
+
+		it('adds or removes the class', function() {
+			el.className = '';
+			L.DomUtil.addClass(el, 'foo');
+
+			expect(el.className).to.eql('foo');
+			expect(L.DomUtil.hasClass(el, 'foo')).to.be.ok();
+
+			L.DomUtil.addClass(el, 'bar');
+			expect(el.className).to.eql('foo bar');
+			expect(L.DomUtil.hasClass(el, 'foo')).to.be.ok();
+
+			L.DomUtil.removeClass(el, 'foo');
+			expect(el.className).to.eql('bar');
+			expect(L.DomUtil.hasClass(el, 'foo')).to.not.be.ok();
+
+			el.className = 'foo bar barz';
+			L.DomUtil.removeClass(el, 'bar');
+			expect(el.className).to.eql('foo barz');
+		});
+	});
+
+	describe('#documentIsLtr', function () {
+		it('returns true if doc direction is ltr', function () {
+			expect(L.DomUtil.documentIsLtr()).to.eql(true);
+			expect(L.DomUtil.documentIsLtr()).to.eql(true); // cached
+		});
+	});
+
+	describe('#getViewportOffset', function () {
+		it('calculates the viewport offset of an element', function () {
+			var div = document.createElement('div');
+			div.style.position = 'absolute';
+			div.style.top = '100px';
+			div.style.left = '200px';
+			div.style.border = '10px solid black';
+			div.style.padding = '50px';
+			div.style.visibility = 'hidden';
+
+			var div2 = document.createElement('div');
+			div.style.marginTop = '100px';
+
+			div.appendChild(div2);
+
+			document.body.appendChild(div);
+
+			expect(L.DomUtil.getViewportOffset(div2)).to.eql(new L.Point(260, 260));
+
+			document.body.removeChild(div);
+		});
+	});
+
+	// describe('#setPosition', noSpecs);
+
+	// describe('#getStyle', noSpecs);
+});

data/lib/leaflet/spec/suites/geo/LatLngBoundsSpec.js

@@ -0,0 +1,136 @@
+describe('LatLngBounds', function() {
+	var a, c;
+
+	beforeEach(function() {
+		a = new L.LatLngBounds(
+			new L.LatLng(14, 12),
+			new L.LatLng(30, 40));
+		c = new L.LatLngBounds();
+	});
+
+	describe('constructor', function () {
+		it('instantiates either passing two latlngs or an array of latlngs', function () {
+			var b = new L.LatLngBounds([
+				new L.LatLng(14, 12),
+				new L.LatLng(30, 40)
+			]);
+			expect(b).to.eql(a);
+			expect(b.getNorthWest()).to.eql(new L.LatLng(30, 12));
+		});
+	});
+
+	describe('#extend', function () {
+		it('extends the bounds by a given point', function () {
+			a.extend(new L.LatLng(20, 50));
+			expect(a.getNorthEast()).to.eql(new L.LatLng(30, 50));
+		});
+
+		it('extends the bounds by given bounds', function () {
+			a.extend([[20, 50], [8, 40]]);
+
+			expect(a.getSouthEast()).to.eql(new L.LatLng(8, 50));
+		});
+	});
+
+	describe('#getCenter', function () {
+		it('returns the bounds center', function () {
+			expect(a.getCenter()).to.eql(new L.LatLng(22, 26));
+		});
+	});
+
+	describe('#pad', function () {
+		it('pads the bounds by a given ratio', function () {
+			var b = a.pad(0.5);
+
+			expect(b).to.eql(L.latLngBounds([[6, -2], [38, 54]]));
+		});
+	});
+
+	describe('#equals', function () {
+		it('returns true if bounds equal', function () {
+			expect(a.equals([[14, 12], [30, 40]])).to.eql(true);
+			expect(a.equals([[14, 13], [30, 40]])).to.eql(false);
+			expect(a.equals(null)).to.eql(false);
+		});
+	});
+
+	describe('#isValid', function() {
+		it('returns true if properly set up', function() {
+			expect(a.isValid()).to.be.ok();
+		});
+		it('returns false if is invalid', function() {
+			expect(c.isValid()).to.not.be.ok();
+		});
+		it('returns true if extended', function() {
+			c.extend([0, 0]);
+			expect(c.isValid()).to.be.ok();
+		});
+	});
+
+	describe('#getWest', function () {
+		it('returns a proper bbox west value', function() {
+			expect(a.getWest()).to.eql(12);
+		});
+	});
+
+	describe('#getSouth', function () {
+		it('returns a proper bbox south value', function() {
+			expect(a.getSouth()).to.eql(14);
+		});
+
+	});
+
+	describe('#getEast', function () {
+		it('returns a proper bbox east value', function() {
+			expect(a.getEast()).to.eql(40);
+		});
+
+	});
+
+	describe('#getNorth', function () {
+		it('returns a proper bbox north value', function() {
+			expect(a.getNorth()).to.eql(30);
+		});
+
+	});
+
+	describe('#toBBoxString', function () {
+		it('returns a proper left,bottom,right,top bbox', function() {
+			expect(a.toBBoxString()).to.eql("12,14,40,30");
+		});
+
+	});
+
+	describe('#getNorthWest', function () {
+		it('returns a proper north-west LatLng', function() {
+			expect(a.getNorthWest()).to.eql(new L.LatLng(a.getNorth(), a.getWest()));
+		});
+
+	});
+
+	describe('#getSouthEast', function () {
+		it('returns a proper south-east LatLng', function() {
+			expect(a.getSouthEast()).to.eql(new L.LatLng(a.getSouth(), a.getEast()));
+		});
+	});
+
+	describe('#contains', function () {
+		it('returns true if contains latlng point', function () {
+			expect(a.contains([16, 20])).to.eql(true);
+			expect(L.latLngBounds(a).contains([5, 20])).to.eql(false);
+		});
+
+		it('returns true if contains bounds', function () {
+			expect(a.contains([[16, 20], [20, 40]])).to.eql(true);
+			expect(a.contains([[16, 50], [8, 40]])).to.eql(false);
+		});
+	});
+
+	describe('#intersects', function () {
+		it('returns true if intersects the given bounds', function () {
+			expect(a.intersects([[16, 20], [50, 60]])).to.eql(true);
+			expect(a.contains([[40, 50], [50, 60]])).to.eql(false);
+		});
+	});
+
+});