test('degToRad', function() {
for (var i = 0; i < tab.length; i++) {
var deg = tab[i][0], rad = tab[i][1];
assert(degToRad(deg) === rad);
assert(degToRad(-deg) === -rad);
}
});
test('radToDeg', function() {
for (var i = 0; i < tab.length; i++) {
var deg = tab[i][0], rad = tab[i][1];
assert(radToDeg(rad) === deg);
assert(radToDeg(-rad) === -deg);
}
});
it('should support methods', function() {
var arr = [];
var s = stub(arr, 'push');
s(1, 2, 3);
assert(equals(arr, []));
assert(arr.push.calledWith(1, 2, 3));
});
it('should be true only when the function was called once', function() {
assert(!s.calledOnce);
s(1);
assert(s.calledOnce);
s(1);
assert(!s.calledOnce);
});
test('empty graph', function() {
var finder = new GraphFinder(equals, hash);
var neighFun = neighborsFun.bind(null, empty);
finder.start(0, neighFun, yesFun);
assert(finder.next() === 0);
assert(finder.next() === null);
});
test('zero', function() {
var fn = chain();
var spy = sinon.spy();
fn(1, 2, 3, spy);
assert(spy.calledOnce);
assert(spy.calledWith(null, 1, 2, 3));
});
it('Should log and gracefully handle missing templates', function() {
dust.onLoad('nonexistent', options, callback);
assert(mockConfig.log.warn.calledOnce);
assert.match(mockConfig.log.warn.lastCall.args[0], /nonexistent$/i);
assert(callback.calledOnce);
assert.strictEqual(callback.lastCall.args[0], null);
assert.strictEqual(callback.lastCall.args[1], '');
});
it('should be true when called twice', function() {
assert(!s.calledTwice);
s(1);
assert(!s.calledTwice);
s(1);
assert(s.calledTwice);
s(1);
assert(!s.calledTwice);
});
it('should be true when called three times', function() {
assert(!s.calledThrice);
s(1);
assert(!s.calledThrice);
s(1);
assert(!s.calledThrice);
s(1);
assert(s.calledThrice);
});
it('should restore methods with `.restore()`', function() {
var arr = [];
var orig = arr.push;
var s = stub(arr, 'push');
s(1);
assert(arr.push.calledWith(1));
s.restore();
assert(orig === arr.push);
});
it('should assert return values correctly', function() {
var s = stub(window.encodeURIComponent);
s('testing 4 u');
assert(s.returned('testing%204%20u'));
assert(s.returns[0] === 'testing%204%20u');
s('testing 4 u 2');
assert(s.returned('testing%204%20u%202'));
assert(s.returns[1] === 'testing%204%20u%202');
});
it('should add a list of unbundled integrations when `addBundledMetadata` and `unbundledIntegrations` are set', function() {
segment.options.addBundledMetadata = true;
segment.options.unbundledIntegrations = [ 'other2' ];
segment.normalize(object);
assert(object);
assert(object._metadata);
assert.deepEqual(object._metadata.unbundled, [ 'other2' ]);
});
analytics.compare = function(A, B) {
var a = new A();
var b = new B();
// name
assert(
a.name === b.name,
fmt('Expected name to be "%s", but it was "%s".', b.name, a.name)
);
// options
var aDefaults = a.defaults;
var bDefaults = b.defaults;
// TODO(ndhoule): Confirm this can be an `each` call and convert it
// eslint-disable-next-line guard-for-in
for (var key in bDefaults) {
assert(
aDefaults.hasOwnProperty(key),
fmt('The integration does not have an option named "%s".', key)
);
assert.deepEqual(
aDefaults[key], bDefaults[key],
fmt(
'Expected option "%s" to default to "%s", but it defaults to "%s".',
key, bDefaults[key], aDefaults[key]
)
);
}
// globals
var aGlobals = a.globals;
var bGlobals = b.globals;
each(function(key) {
assert(
contains(key, aGlobals),
fmt('Expected global "%s" to be registered.', key)
);
}, bGlobals);
// assumesPageview
assert(
a._assumesPageview === b._assumesPageview,
'Expected the integration to assume a pageview.'
);
// readyOnInitialize
assert(
a._readyOnInitialize === b._readyOnInitialize,
'Expected the integration to be ready on initialize.'
);
// readyOnLoad
assert(
a._readyOnLoad === b._readyOnLoad,
'Expected integration to be ready on load.'
);
};
it('should support custom functions', function() {
var arr = [];
var tmp;
var fn = function() { tmp = [].slice.call(arguments); };
var s = stub(arr, 'push', fn);
s(1, 2, 3);
assert(equals(arr, []));
assert(equals(tmp, [1, 2, 3]));
assert(arr.push.calledWith(1, 2, 3));
});
it('should add a list of bundled integrations when `addBundledMetadata` is set', function() {
segment.options.addBundledMetadata = true;
segment.normalize(object);
assert(object);
assert(object._metadata);
assert.deepEqual(object._metadata.bundled, [
'Segment.io',
'other'
]);
});
test('state reset after search', function() {
// Depends on internals
var finder = new GraphFinder(equals, hash);
var neighFun = neighborsFun.bind(empty);
finder.start(0, neighFun, yesFun);
finder.next();
finder.next();
assert(finder._neighborsFun === null);
assert(finder._exploreFun === null);
assert(finder._queue.length === 0);
assert(finder._visited.size() === 0);
});
analytics.didNotReturn = function(spy, value) {
assert(
contains(spy, this.spies),
'You must call `.spy(object, method)` prior to calling `.didNotReturn()`.'
);
assert(
!spy.returned(value),
fmt('Expected "%s" not to have returned "%o".', spy.name, value)
);
return this;
};
test('explore even', function() {
var finder = new GraphFinder(equals, hash);
var neighFun = neighborsFun.bind(null, konigsberg);
finder.start(0, neighFun, evenFun);
var node, nodeList = [];
while ((node = finder.next()) !== null) {
nodeList.push(node);
}
assert(nodeList.indexOf(0) >= 0);
assert(nodeList.indexOf(2) >= 0);
assert(nodeList.length === 2);
});
it('should move all toplevel keys to the message', function() {
var date = opts.timestamp = new Date();
opts.anonymousId = 'anonymous-id';
opts.integrations = { foo: 1 };
opts.context = { context: 1 };
var out = normalize(msg, list);
assert(out.timestamp.getTime() === date.getTime());
assert(out.anonymousId === 'anonymous-id');
assert.deepEqual(out.integrations, { foo: 1 });
assert.deepEqual(out.context, { context: 1 });
});
ajs.ready(function() {
var segment = ajs._integrations['Segment.io'];
segment.ontrack = sinon.spy();
ajs.track('event', {}, { All: false });
assert(segment.ontrack.calledOnce);
done();
});
it('should retry on HTTP errors', function() {
var clock = lolex.createClock(0);
var spy = sinon.spy();
Schedule.setClock(clock);
xhr.onCreate = spy;
segment.enqueue('/i', { userId: '1' });
assert(spy.calledOnce);
var req = spy.getCall(0).args[0];
req.respond(500, null, 'segment machine broke');
clock.tick(segment._lsqueue.getDelay(1));
assert(spy.calledTwice);
});
it('should convert the page to track with event', function() {
var page = new Page({
anonymousId: 'anon-id',
userId: 'user-id',
timestamp: new Date(1388534400000),
context: { ip: '0.0.0.0' },
properties: { prop: true },
category: 'category',
name: 'name'
});
assert.deepEqual(page.track('event').anonymousId(), 'anon-id');
assert.deepEqual(page.track('event').userId(), 'user-id');
assert(page.track('event') instanceof Track);
assert.deepEqual(page.track().event(), 'Loaded a Page');
assert.deepEqual(page.track('name').event(), 'Viewed name Page');
assert.deepEqual(page.track('category').event(), 'Viewed category Page');
assert.deepEqual(page.track('category').event(), 'Viewed category Page');
assert.deepEqual(page.track('category').timestamp(), new Date(1388534400000));
assert.deepEqual(page.track('category').context(), page.context());
assert.deepEqual(
page.track('event').properties(),
{ category: 'category', name: 'name', prop: true }
);
});
test('initial state', function() {
var stage = new MockStage();
var loop = new RenderLoop(stage);
stage.emit('renderInvalid');
fakeTickFrame();
assert(stage.render.notCalled);
});
test('renderOnNextFrame', function() {
var stage = new MockStage();
var loop = new RenderLoop(stage);
loop.start();
loop.renderOnNextFrame();
fakeTickFrame();
assert(stage.render.called);
});
test('start', function() {
var stage = new MockStage();
var loop = new RenderLoop(stage);
loop.start();
stage.emit('renderInvalid');
fakeTickFrame();
assert(stage.render.called);
});
analytics.loaded = function(integration, str) {
if (typeof integration === 'string') {
str = integration;
integration = this.integration();
}
var tags = [];
assert(
contains(integration.load, this.spies),
'You must call `.spy(integration, \'load\')` prior to calling `.loaded()`.'
);
// collect all Image or HTMLElement objects
// in an array of stringified elements, for human-readable assertions.
each(function(el) {
var tag = {};
if (el instanceof HTMLImageElement) {
tag.type = 'img';
tag.attrs = { src: el.src };
} else if (type(el) === 'element') {
tag.type = el.tagName.toLowerCase();
tag.attrs = stripAttrs(tag.type, attributes(el));
}
if (tag.type) tags.push(stringify(tag.type, tag.attrs));
}, integration.load.returns);
// normalize formatting
var tag = objectify(str);
// strip unwanted attrs we do not control before we assert
tag.attrs = stripAttrs(tag.type, tag.attrs);
var expected = stringify(tag.type, tag.attrs);
if (!tags.length) {
assert(false, fmt('No tags were returned.\nExpected %s.', expected));
} else {
// show the closest match
assert(
contains(expected, tags),
fmt('\nExpected %s.\nFound %s', expected, tags.join('\n'))
);
}
};
it('should record returned values', function() {
s(1, 2, 3);
s(4, 5, 6);
s(7, 8, 9);
assert(equals(s.returns, [
undefined,
undefined,
undefined
]));
});
it('should record arguments', function() {
s(1, 2, 3);
s(4, 5, 6);
s(7, 8, 9);
assert(equals(s.args, [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]));
});
it('Should load a given template from its keyname in the dust cache', function() {
var templateStub = sinon.stub();
dust.cache = createMockCache({
foo: templateStub
});
dust.onLoad('foo', options, callback);
assert(callback.calledOnce);
assert.strictEqual(callback.lastCall.args[0], null);
assert.strictEqual(callback.lastCall.args[1], templateStub);
});
it('should enqueue to `api.segment.io/v1` by default', sinon.test(function() {
var spy = sinon.spy();
xhr.onCreate = spy;
protocol('https:');
segment.enqueue('/i', { userId: 'id' });
assert(spy.calledOnce);
var req = spy.getCall(0).args[0];
assert.strictEqual(req.url, 'https://api.segment.io/v1/i');
}));