nativescript 9.1.0-alpha.4 → 9.1.0-alpha.7

package/node_modules/universal-analytics/test/pageview.js

@@ -0,0 +1,286 @@
+
+var qs = require("querystring");
+var uuid = require("uuid");
+var should = require("should");
+var sinon = require("sinon");
+var url = require("url");
+
+var ua = require("../lib/index.js");
+var utils = require("../lib/utils.js");
+var config = require("../lib/config.js");
+var request = require("../lib/request");
+
+
+describe("ua", function () {
+
+
+
+	describe("#pageview", function () {
+		var _enqueue;
+
+		beforeEach(function () {
+			_enqueue = sinon.stub(ua.Visitor.prototype, "_enqueue", function () {
+				if (arguments.length === 3 && typeof arguments[2] === 'function') {
+					arguments[2]();
+				}
+				return this;
+			});
+		});
+
+		afterEach(function () {
+			_enqueue.restore()
+		});
+
+
+		it("should be available via the #pv shortcut", function () {
+			var visitor = ua()
+			visitor.pv.should.equal(visitor.pageview)
+		});
+
+
+		it("should accept arguments (path)", function () {
+			var path = "/" + Math.random()
+
+			var visitor = ua("UA-XXXXX-XX")
+
+			var result = visitor.pageview(path)
+
+			visitor._context = result._context;
+			result.should.eql(visitor, "should return a visitor that is identical except for the context");
+
+			result.should.be.instanceof(ua.Visitor);
+			result._context.should.eql(_enqueue.args[0][1], "the pageview params should be persisted as the context of the visitor clone")
+
+			_enqueue.calledOnce.should.equal(true, "#_enqueue should have been called once");
+			_enqueue.args[0][0].should.equal("pageview");
+			_enqueue.args[0][1].should.have.keys("dp")
+			_enqueue.args[0][1].dp.should.equal(path);
+		});
+
+
+		it("should accept arguments (path, fn)", function () {
+			var path = "/" + Math.random();
+			var fn = sinon.spy();
+
+			var visitor = ua("UA-XXXXX-XX")
+
+			var result = visitor.pageview(path, fn)
+
+			visitor._context = result._context;
+			result.should.eql(visitor, "should return a visitor that is identical except for the context");
+
+			result.should.be.instanceof(ua.Visitor);
+			result._context.should.eql(_enqueue.args[0][1], "the pageview params should be persisted as the context of the visitor clone")
+
+			_enqueue.calledOnce.should.equal(true, "#_enqueue should have been called once");
+			_enqueue.args[0][0].should.equal("pageview");
+			_enqueue.args[0][1].should.have.keys("dp")
+			_enqueue.args[0][1].dp.should.equal(path);
+
+			fn.calledOnce.should.equal(true, "callback should have been called once");
+		});
+
+
+		it("should accept arguments (params)", function () {
+			var params = {
+				dp: "/" + Math.random()
+			};
+
+			var visitor = ua("UA-XXXXX-XX")
+
+			var result = visitor.pageview(params)
+
+			visitor._context = result._context;
+			result.should.eql(visitor, "should return a visitor that is identical except for the context");
+
+			result.should.be.instanceof(ua.Visitor);
+			result._context.should.eql(_enqueue.args[0][1], "the pageview params should be persisted as the context of the visitor clone")
+
+			_enqueue.calledOnce.should.equal(true, "#_enqueue should have been called once");
+			_enqueue.args[0][0].should.equal("pageview");
+			_enqueue.args[0][1].should.have.keys("dp")
+			_enqueue.args[0][1].dp.should.equal(params.dp);
+		});
+
+
+		it("should accept arguments (params, fn)", function () {
+			var params = {
+				dp: "/" + Math.random(),
+				empty: null // Should be removed
+			};
+			var json = JSON.stringify(params)
+			var fn = sinon.spy()
+
+			ua("UA-XXXXX-XX").pageview(params, fn)
+
+			_enqueue.calledOnce.should.equal(true, "#_enqueue should have been called once");
+			_enqueue.args[0][0].should.equal("pageview");
+			_enqueue.args[0][1].should.have.keys("dp")
+			_enqueue.args[0][1].dp.should.equal(params.dp);
+
+			fn.calledOnce.should.equal(true, "callback should have been called once");
+
+			JSON.stringify(params).should.equal(json, "params should not have been modified")
+		});
+
+
+		it("should accept arguments (path, hostname)", function () {
+			var path = Math.random().toString();
+			var hostname = Math.random().toString();
+
+			ua("UA-XXXXX-XX").pageview(path, hostname);
+
+			_enqueue.calledOnce.should.equal(true, "#_enqueue should have been called once");
+			_enqueue.args[0][0].should.equal("pageview");
+			_enqueue.args[0][1].should.have.keys("dp", "dh")
+			_enqueue.args[0][1].dp.should.equal(path);
+			_enqueue.args[0][1].dh.should.equal(hostname);
+		});
+
+
+		it("should accept arguments (path, hostname, fn)", function () {
+			var path = Math.random().toString();
+			var hostname = Math.random().toString();
+			var fn = sinon.spy()
+
+			ua("UA-XXXXX-XX").pageview(path, hostname, fn);
+
+			_enqueue.calledOnce.should.equal(true, "#_enqueue should have been called once");
+			_enqueue.args[0][0].should.equal("pageview");
+			_enqueue.args[0][1].should.have.keys("dp", "dh")
+			_enqueue.args[0][1].dp.should.equal(path);
+			_enqueue.args[0][1].dh.should.equal(hostname);
+
+			fn.calledOnce.should.equal(true, "callback should have been called once");
+		});
+
+
+		it("should accept arguments (path, hostname, title)", function () {
+			var path = Math.random().toString();
+			var hostname = Math.random().toString();
+			var title = Math.random().toString();
+
+			ua("UA-XXXXX-XX").pageview(path, hostname, title);
+
+			_enqueue.calledOnce.should.equal(true, "#_enqueue should have been called once");
+			_enqueue.args[0][0].should.equal("pageview");
+			_enqueue.args[0][1].should.have.keys("dp", "dh", "dt")
+			_enqueue.args[0][1].dp.should.equal(path);
+			_enqueue.args[0][1].dh.should.equal(hostname);
+			_enqueue.args[0][1].dt.should.equal(title);
+		});
+
+
+		it("should accept arguments (path, hostname, title, fn)", function () {
+			var path = Math.random().toString();
+			var hostname = Math.random().toString();
+			var title = Math.random().toString();
+			var fn = sinon.spy()
+
+			ua("UA-XXXXX-XX").pageview(path, hostname, title, fn);
+
+			_enqueue.calledOnce.should.equal(true, "#_enqueue should have been called once");
+			_enqueue.args[0][0].should.equal("pageview");
+			_enqueue.args[0][1].should.have.keys("dp", "dh", "dt")
+			_enqueue.args[0][1].dp.should.equal(path);
+			_enqueue.args[0][1].dh.should.equal(hostname);
+			_enqueue.args[0][1].dt.should.equal(title);
+
+			fn.calledOnce.should.equal(true, "callback should have been called once");
+		});
+
+
+		it("should allow daisy-chaining and re-using parameters", function () {
+			var path = "/" + Math.random()
+			var title = Math.random().toString();
+
+			ua("UA-XXXXX-XX").pageview(path, null, title).pageview()
+
+			_enqueue.calledTwice.should.equal(true, "#_enqueue should have been called twice, once for each pageview");
+
+			_enqueue.args[0][0].should.equal(_enqueue.args[1][0]);
+			_enqueue.args[0][1].should.eql(_enqueue.args[1][1]);
+		})
+
+
+		it("should extend and overwrite params when daisy-chaining", function () {
+			var path = "/" + Math.random()
+			var path2 = "/" + Math.random()
+			var title = Math.random().toString();
+			var title2 = Math.random().toString();
+			var foo = Math.random()
+
+			ua("UA-XXXXX-XX")
+				.pageview(path, null, title)
+				.pageview({
+					dt: title2,
+					dp: path2,
+					foo: foo
+				}).pageview(path)
+
+			_enqueue.calledThrice.should.equal(true, "#_enqueue should have been called three times, once for each pageview");
+
+			_enqueue.args[0][1].should.have.keys("dp", "dt")
+			_enqueue.args[0][1].dp.should.equal(path);
+			_enqueue.args[0][1].dt.should.equal(title);
+
+			_enqueue.args[1][1].should.have.keys("dp", "dt", "foo")
+			_enqueue.args[1][1].dp.should.equal(path2);
+			_enqueue.args[1][1].dt.should.equal(title2);
+			_enqueue.args[1][1].foo.should.equal(foo);
+
+			_enqueue.args[2][1].should.have.keys("dp", "dt")
+			_enqueue.args[2][1].dp.should.equal(path);
+			_enqueue.args[2][1].dt.should.equal(title2);
+		})
+
+		it("should accept document location instead of page path", function () {
+			var params = {
+				dl: "http://www.google.com/" + Math.random()
+			};
+			var json = JSON.stringify(params)
+			var fn = sinon.spy()
+
+			ua("UA-XXXXX-XX").pageview(params, fn)
+
+			_enqueue.calledOnce.should.equal(true, "#_enqueue should have been called once");
+			_enqueue.args[0][0].should.equal("pageview");
+			_enqueue.args[0][1].should.have.keys("dl")
+			_enqueue.args[0][1].dl.should.equal(params.dl);
+
+			fn.calledOnce.should.equal(true, "callback should have been called once");
+
+			JSON.stringify(params).should.equal(json, "params should not have been modified")
+		});
+
+		it("should fail without page path or document location", function () {
+			var fn = sinon.spy()
+			var visitor = ua()
+
+			var result = visitor.pageview(null, fn);
+
+			visitor._context = result._context;
+			result.should.eql(visitor, "should return a visitor that is identical except for the context");
+
+			result.should.be.instanceof(ua.Visitor);
+			result._context.should.eql({}, "the transaction params should not be persisted")
+
+			_enqueue.called.should.equal(false, "#_enqueue should have not been called once");
+			fn.calledOnce.should.equal(true, "callback should have been called once");
+			fn.args[0][0].should.be.instanceof(Error);
+			fn.thisValues[0].should.equal(visitor);
+		});
+
+	});
+
+});
+
+
+
+
+
+
+
+
+
+

package/node_modules/universal-analytics/test/send.js

@@ -0,0 +1,232 @@
+
+var qs = require("querystring");
+var uuid = require("uuid");
+var should = require("should");
+var sinon = require("sinon");
+var url = require("url");
+
+var ua = require("../lib/index.js");
+var utils = require("../lib/utils.js")
+var config = require("../lib/config.js")
+var request = require("../lib/request.js");
+
+
+describe("ua", function () {
+
+	describe("#send", function () {
+		var post;
+
+		beforeEach(function () {
+			post = sinon.stub(request, "post").callsArg(3);
+		});
+
+		afterEach(function () {
+			post.restore()
+		});
+
+		it("should immidiately return with an empty queue", function () {
+			var visitor = ua();
+			var fn = sinon.spy();
+
+			visitor.send(fn);
+
+			post.called.should.equal(false, "no request should have been sent")
+			fn.calledOnce.should.equal(true, "callback should have been called once")
+			fn.thisValues[0].should.equal(visitor, "callback should be called in the context of the visitor instance");
+			fn.args[0].should.eql([null, 0], "no error, no requests");
+		});
+
+		it("should include data in POST body", function (done) {
+			var paramSets = [
+				{first: "123"}
+			]
+
+			var fn = sinon.spy(function () {
+				fn.calledOnce.should.equal(true, "callback should have been called once")
+				fn.thisValues[0].should.equal(visitor, "callback should be called in the context of the visitor instance");
+				fn.args[0].should.eql([null, 1], "no error, 1 requests");
+
+				post.callCount.should.equal(paramSets.length, "each param set should have been POSTed");
+
+				for (var i = 0; i < paramSets.length; i++) {
+					var params = paramSets[i];
+					var args = post.args[i];
+
+					var parsedUrl = url.parse(args[0]);
+
+					Math.random(); // I have absolutely no idea why it fails unless there was some processing to be done after url.parse…
+
+					(parsedUrl.protocol + "//" + parsedUrl.host).should.equal(config.hostname);
+					args[1].should.equal(qs.stringify(params));
+				}
+
+				done();
+			});
+
+			var visitor = ua();
+			visitor._queue.push.apply(visitor._queue, paramSets);
+			visitor.send(fn);
+		});
+
+		it("should send individual requests when batchting is false", function(done) {
+			var paramSets = [
+				{first: Math.random()},
+				{second: Math.random()},
+				{third: Math.random()}
+			]
+
+			var fn = sinon.spy(function () {
+				fn.calledOnce.should.equal(true, "callback should have been called once")
+				fn.thisValues[0].should.equal(visitor, "callback should be called in the context of the visitor instance");
+
+				fn.args[0].should.eql([null, 3], "no error, 3 requests");
+
+				done();
+			});
+
+			var visitor = ua({enableBatching:false});
+			visitor._queue.push.apply(visitor._queue, paramSets)
+			visitor.send(fn);
+		});
+
+		describe("#batching is true", function() {
+			it("should send request to collect path when only one payload", function(done) {
+				var paramSets = [
+					{first: Math.random()}
+				]
+
+				var fn = sinon.spy(function () {
+					fn.args[0].should.eql([null, 1], "no error, 1 requests");
+					var args = post.args[0];
+
+					var parsedUrl = url.parse(args[0]);
+
+					parsedUrl.pathname.should.eql(config.path);
+					done();
+				});
+
+				var visitor = ua({enableBatching:true});
+				visitor._queue.push.apply(visitor._queue, paramSets)
+				visitor.send(fn);
+			});
+
+			it("should send request to batch path when more than one payload sent", function(done) {
+				var paramSets = [
+					{first: Math.random()},
+					{second: Math.random()},
+					{third: Math.random()}
+				]
+
+				var fn = sinon.spy(function () {
+					fn.args[0].should.eql([null, 1], "no error, 1 requests");
+					var args = post.args[0];
+
+					var parsedUrl = url.parse(args[0]);
+
+					parsedUrl.pathname.should.eql(config.batchPath);
+					done();
+				});
+
+				var visitor = ua({enableBatching:true});
+				visitor._queue.push.apply(visitor._queue, paramSets)
+				visitor.send(fn);
+			});
+
+			it("should batch data in Post form", function(done) {
+				var paramSets = [
+					{first: Math.random()},
+					{second: Math.random()},
+					{third: Math.random()}
+				]
+
+				var fn = sinon.spy(function () {
+					fn.calledOnce.should.equal(true, "callback should have been called once")
+					fn.thisValues[0].should.equal(visitor, "callback should be called in the context of the visitor instance");
+
+					fn.args[0].should.eql([null, 1], "no error, 1 requests");
+					var args = post.args[0];
+
+					var params = paramSets;
+					var formParams = args[1].split("\n");
+					formParams.should.have.lengthOf(3);
+					formParams[0].should.equal(qs.stringify(params[0]));
+
+					done();
+				});
+
+				var visitor = ua({enableBatching:true});
+				visitor._queue.push.apply(visitor._queue, paramSets)
+				visitor.send(fn);
+			})
+
+			it("should batch data based on batchSize", function(done) {
+				var paramSets = [
+					{first: Math.random()},
+					{second: Math.random()},
+					{third: Math.random()}
+				]
+
+				var fn = sinon.spy(function () {
+					fn.calledOnce.should.equal(true, "callback should have been called once")
+					fn.thisValues[0].should.equal(visitor, "callback should be called in the context of the visitor instance");
+
+					fn.args[0].should.eql([null, 2], "no error, 2 requests");
+
+					var body = post.args[0][1];
+
+					body.split("\n").should.have.lengthOf(2);
+
+					done();
+				});
+
+				var visitor = ua({enableBatching:true, batchSize: 2});
+				visitor._queue.push.apply(visitor._queue, paramSets)
+				visitor.send(fn);
+			});
+		});
+
+
+
+
+
+
+		it("should add custom headers to request header", function (done) {
+			var fn = sinon.spy(function () {
+				fn.calledOnce.should.equal(true, "callback should have been called once");
+				fn.thisValues[0].should.equal(visitor, "callback should be called in the context of the visitor instance");
+
+				post.calledOnce.should.equal(true, "request should have been POSTed");
+
+				var parsedUrl = url.parse(post.args[0][0]);
+				var headers = post.args[0][2];
+
+				(parsedUrl.protocol + "//" + parsedUrl.host).should.equal(config.hostname);
+
+				headers.should.have.key("User-Agent");
+				headers["User-Agent"].should.equal("Test User Agent");
+
+				done();
+			});
+
+			var visitor = ua({
+				headers: {'User-Agent': 'Test User Agent'}
+			});
+			visitor._queue.push({});
+			visitor.send(fn);
+		});
+
+
+
+	})
+
+});
+
+
+
+
+
+
+
+
+
+

package/node_modules/universal-analytics/test/set.js

@@ -0,0 +1,68 @@
+
+var qs = require("querystring");
+var uuid = require("uuid");
+var should = require("should");
+var sinon = require("sinon");
+var url = require("url");
+
+var ua = require("../lib/index.js");
+var utils = require("../lib/utils.js");
+var config = require("../lib/config.js");
+var request = require("../lib/request");
+
+
+describe("ua", function () {
+
+
+
+	describe("#set", function () {
+		var _enqueue;
+
+		beforeEach(function () {
+			_enqueue = sinon.stub(ua.Visitor.prototype, "_enqueue", function () {
+				if (arguments.length === 3 && typeof arguments[2] === 'function') {
+					arguments[2]();
+				}
+				return this;
+			});
+		});
+
+		afterEach(function () {
+			_enqueue.restore()
+		});
+
+
+		it("should set persistent parameter", function () {
+
+			var visitor = ua("UA-XXXXX-XX")
+			visitor.set("cd1", "bar")
+			visitor.pageview("/foo")
+
+
+			_enqueue.calledOnce.should.equal(true, "#_enqueue should have been called once");
+			_enqueue.args[0][0].should.equal("pageview");
+			_enqueue.args[0][1].should.have.keys("dp", "cd1")
+
+
+			visitor.pageview("/foo/foo").event("Test Event", "Action")
+
+			_enqueue.args[1][0].should.equal("pageview");
+			_enqueue.args[1][1].should.have.keys("dp", "cd1")
+
+			_enqueue.args[2][0].should.equal("event");
+			_enqueue.args[2][1].should.have.keys("ec", "ea", "p", "cd1")
+		});
+
+	});
+
+});
+
+
+
+
+
+
+
+
+
+