QUnit.test('returning a value from the before callback passes it to the after callback', function() {
expect(2);
var passthru1 = {};
var passthru2 = {};
subscribe('render', {
before(name, timestamp, payload) {
return passthru1;
},
after(name, timestamp, payload, beforeValue) {
strictEqual(beforeValue, passthru1);
}
});
subscribe('render', {
before(name, timestamp, payload) {
return passthru2;
},
after(name, timestamp, payload, beforeValue) {
strictEqual(beforeValue, passthru2);
}
});
instrument('render', null, function() {});
});
test('should instrument triggered events', function() {
let clicked = 0;
run(function () {
view = View.create({
click(evt) {
clicked++;
},
template: compile('<p>hello</p>')
}).appendTo(dispatcher.get('rootElement'));
});
view.$().trigger('click');
equal(clicked, 1, 'precond - The click handler was invoked');
let clickInstrumented = 0;
let clickSubscriber = subscribe('interaction.click', {
before() {
clickInstrumented++;
equal(clicked, 1, 'invoked before event is handled');
},
after() {
clickInstrumented++;
equal(clicked, 2, 'invoked after event is handled');
}
});
let keypressInstrumented = 0;
let keypressSubscriber = subscribe('interaction.keypress', {
before() {
keypressInstrumented++;
},
after() {
keypressInstrumented++;
}
});
try {
view.$().trigger('click');
view.$().trigger('change');
equal(clicked, 2, 'precond - The click handler was invoked');
equal(clickInstrumented, 2, 'The click was instrumented');
strictEqual(keypressInstrumented, 0, 'The keypress was not instrumented');
} finally {
unsubscribe(clickSubscriber);
unsubscribe(keypressSubscriber);
}
});
test('interaction event subscriber should be passed parameters', function(assert) {
assert.expect(2);
let actionParam = 'So krispy';
subscriber = subscribe('interaction.ember-action', {
before(name, timestamp, payload) {
assert.equal(payload.args[0], actionParam, 'instrumentation subscriber before function was passed closure action parameters');
},
after(name, timestamp, payload) {
assert.equal(payload.args[0], actionParam, 'instrumentation subscriber after function was passed closure action parameters');
}
});
registerTemplate('components/inner-component', '<button id="instrument-button" {{action "fireAction"}}>What it do</button>');
registerComponent('inner-component', EmberComponent.extend({
actions: {
fireAction() {
this.attrs.submit(actionParam);
}
}
}));
registerTemplate('components/outer-component', '{{inner-component submit=(action outerSubmit)}}');
registerComponent('outer-component', EmberComponent.extend({
innerComponent,
outerSubmit() {}
}));
view = appendViewFor(`{{outer-component}}`);
view.$('#instrument-button').trigger('click');
});
test('action should fire interaction event', function(assert) {
assert.expect(2);
subscriber = subscribe('interaction.ember-action', {
before() {
assert.ok(true, 'instrumentation subscriber was called');
}
});
registerTemplate('components/inner-component', '<button id="instrument-button" {{action "fireAction"}}>What it do</button>');
registerComponent('inner-component', EmberComponent.extend({
actions: {
fireAction() {
this.attrs.submit();
}
}
}));
registerTemplate('components/outer-component', '{{inner-component submit=(action outerSubmit)}}');
registerComponent('outer-component', EmberComponent.extend({
innerComponent,
outerSubmit() {
assert.ok(true, 'action is called');
}
}));
view = appendViewFor(`{{outer-component}}`);
view.$('#instrument-button').trigger('click');
});
['@test instruments triggered events'](assert) {
let clicked = 0;
this.registerComponent('x-foo', {
ComponentClass: Component.extend({
click(evt) {
clicked++;
}
}),
template: `<p>hello</p>`
});
this.render(`{{x-foo}}`);
this.$('div').trigger('click');
assert.equal(clicked, 1, 'precond - the click handler was invoked');
let clickInstrumented = 0;
subscribe('interaction.click', {
before() {
clickInstrumented++;
assert.equal(clicked, 1, 'invoked before event is handled');
},
after() {
clickInstrumented++;
assert.equal(clicked, 2, 'invoked after event is handled');
}
});
let keypressInstrumented = 0;
subscribe('interaction.keypress', {
before() {
keypressInstrumented++;
},
after() {
keypressInstrumented++;
}
});
this.$('div').trigger('click');
this.$('div').trigger('change');
assert.equal(clicked, 2, 'precond - The click handler was invoked');
assert.equal(clickInstrumented, 2, 'The click was instrumented');
assert.strictEqual(keypressInstrumented, 0, 'The keypress was not instrumented');
}
QUnit.test('instrument with 2 args (name, callback) no payload', function() {
expect(1);
subscribe('render', {
before(name, timestamp, payload) {
deepEqual(payload, {});
},
after() {}
});
instrument('render', function() {});
});
QUnit.test("instrument with 2 args (name, callback) no payload", function() {
expect(1);
subscribe("render", {
before: function(name, timestamp, payload) {
deepEqual(payload, {});
},
after: function() {}
});
instrument("render", function() {});
});
test("instrument with 3 args (name, payload, callback) with payload", function() {
expect(1);
var expectedPayload = { hi: 1 };
subscribe("render", {
before: function(name, timestamp, payload) {
deepEqual(payload, expectedPayload);
},
after: function() {}
});
instrument("render", expectedPayload, function() {});
});
QUnit.test('instrument with 3 args (name, payload, callback) with payload', function() {
expect(1);
var expectedPayload = { hi: 1 };
subscribe('render', {
before(name, timestamp, payload) {
deepEqual(payload, expectedPayload);
},
after() {}
});
instrument('render', expectedPayload, function() {});
});
QUnit.test('raising an exception in the instrumentation attaches it to the payload', function() {
expect(2);
var error = new Error('Instrumentation');
subscribe('render', {
before() {},
after(name, timestamp, payload) {
strictEqual(payload.exception, error);
}
});
subscribe('render', {
before() {},
after(name, timestamp, payload) {
strictEqual(payload.exception, error);
}
});
instrument('render.handlebars', null, function() {
throw error;
});
});
QUnit.test("it is possible to add a new subscriber after the first instrument", function() {
instrument("render.handlebars", null, function() {});
subscribe("render", {
before: function() {
ok(true, "Before callback was called");
},
after: function() {
ok(true, "After callback was called");
}
});
instrument("render.handlebars", null, function() {});
});
QUnit.test("raising an exception in the instrumentation attaches it to the payload", function() {
expect(2);
var error = new Error("Instrumentation");
subscribe("render", {
before: function() {},
after: function(name, timestamp, payload) {
strictEqual(payload.exception, error);
}
});
subscribe("render", {
before: function() {},
after: function(name, timestamp, payload) {
strictEqual(payload.exception, error);
}
});
instrument("render.handlebars", null, function() {
throw error;
});
});
test('Nodes without view instances are instrumented', function(assert) {
var called = false;
subscriber = subscribe('render', {
before() {
called = true;
},
after() {}
});
run(App, 'advanceReadiness');
assert.ok(called, 'Instrumentation called on first render');
called = false;
handleURL('/posts');
assert.ok(called, 'instrumentation called on transition to non-view backed route');
});
QUnit.test('it is possible to add a new subscriber after the first instrument', function() {
instrument('render.handlebars', null, function() {});
subscribe('render', {
before() {
ok(true, 'Before callback was called');
},
after() {
ok(true, 'After callback was called');
}
});
instrument('render.handlebars', null, function() {});
});
QUnit.test('instrument with 3 args (name, callback, binding) no payload', function() {
expect(2);
var binding = {};
subscribe('render', {
before(name, timestamp, payload) {
deepEqual(payload, {});
},
after() {}
});
instrument('render', function() {
deepEqual(this, binding);
}, binding);
});
test("instrument with 3 args (name, callback, binding) no payload", function() {
expect(2);
var binding = {};
subscribe("render", {
before: function(name, timestamp, payload) {
deepEqual(payload, {});
},
after: function() {}
});
instrument("render", function() {
deepEqual(this, binding);
}, binding);
});
QUnit.test("instrument with 4 args (name, payload, callback, binding) with payload", function() {
expect(2);
var expectedPayload = { hi: 1 };
var binding = {};
subscribe("render", {
before: function(name, timestamp, payload) {
deepEqual(payload, expectedPayload);
},
after: function() {}
});
instrument("render", expectedPayload, function() {
deepEqual(this, binding);
}, binding);
});
constructor() {
super();
this.resetEvents();
subscribe('render.component', {
before: (name, timestamp, payload) => {
if (payload.view !== this.component) {
this.actual.before.push(payload);
}
},
after: (name, timestamp, payload) => {
if (payload.view !== this.component) {
this.actual.after.push(payload);
}
}
});
}
QUnit.test('The {{link-to}} helper interaction event includes the transition in the after hook', function(assert) {
assert.expect(1);
Router.map(function(match) {
this.route('about');
});
bootApplication();
run(() => router.handleURL('/'));
subscribe('interaction.link-to', {
before() {},
after(name, timestamp, { transition }) {
assert.equal(transition.targetName, 'about', 'instrumentation subscriber was passed route name');
}
});
jQuery('#about-link', '#qunit-fixture').click();
});
setup: function () {
beforeCalls = [];
afterCalls = [];
subscribe("render", {
before: function(name, timestamp, payload) {
beforeCalls.push(payload);
},
after: function(name, timestamp, payload) {
afterCalls.push(payload);
}
});
view = EmberView.create({
_debugContainerKey: 'suchryzsd',
instrumentDisplay: 'asdfasdfmewj'
});
},
QUnit.test('The {{link-to}} helper fires an interaction event', function(assert) {
assert.expect(2);
Router.map(function(match) {
this.route('about');
});
bootApplication();
run(() => router.handleURL('/'));
subscribe('interaction.link-to', {
before() {
assert.ok(true, 'instrumentation subscriber was called');
},
after() {
assert.ok(true, 'instrumentation subscriber was called');
}
});
jQuery('#about-link', '#qunit-fixture').click();
});
['@test action should fire interaction event with proper params']() {
let subscriberCallCount = 0;
let subscriberPayload = null;
let ExampleComponent = Component.extend({
actions: {
foo() {}
}
});
this.registerComponent('example-component', {
ComponentClass: ExampleComponent,
template: '<button {{action "foo" "bar"}}>Click me</button>'
});
subscribe('interaction.ember-action', {
before() {
subscriberCallCount++;
},
after(name, time, payload) {
subscriberPayload = payload;
}
});
this.render('{{example-component}}');
this.assert.equal(subscriberCallCount, 0, 'subscriber has not been called');
this.runTask(() => this.rerender());
this.assert.equal(subscriberCallCount, 0, 'subscriber has not been called');
this.runTask(() => {
this.$('button').click();
});
this.assert.equal(subscriberCallCount, 1, 'subscriber has been called 1 time');
this.assert.equal(subscriberPayload.name, 'foo', 'subscriber called with correct name');
this.assert.equal(subscriberPayload.args[0], 'bar', 'subscriber called with correct args');
}
QUnit.test('subscribing to a simple path receives the listener', function() {
expect(12);
var sentPayload = {};
var count = 0;
subscribe('render', {
before(name, timestamp, payload) {
if (count === 0) {
strictEqual(name, 'render');
} else {
strictEqual(name, 'render.handlebars');
}
ok(typeof timestamp === 'number');
strictEqual(payload, sentPayload);
},
after(name, timestamp, payload) {
if (count === 0) {
strictEqual(name, 'render');
} else {
strictEqual(name, 'render.handlebars');
}
ok(typeof timestamp === 'number');
strictEqual(payload, sentPayload);
count++;
}
});
instrument('render', sentPayload, function() {
});
instrument('render.handlebars', sentPayload, function() {
});
});
test("subscribing to a simple path receives the listener", function() {
expect(12);
var sentPayload = {}, count = 0;
subscribe("render", {
before: function(name, timestamp, payload) {
if (count === 0) {
strictEqual(name, "render");
} else {
strictEqual(name, "render.handlebars");
}
ok(typeof timestamp === 'number');
strictEqual(payload, sentPayload);
},
after: function(name, timestamp, payload) {
if (count === 0) {
strictEqual(name, "render");
} else {
strictEqual(name, "render.handlebars");
}
ok(typeof timestamp === 'number');
strictEqual(payload, sentPayload);
count++;
}
});
instrument("render", sentPayload, function() {
});
instrument("render.handlebars", sentPayload, function() {
});
});
QUnit.test('it is possible to remove a subscriber', function() {
expect(4);
var count = 0;
var subscriber = subscribe('render', {
before() {
equal(count, 0);
ok(true, 'Before callback was called');
},
after() {
equal(count, 0);
ok(true, 'After callback was called');
count++;
}
});
instrument('render.handlebars', null, function() {});
unsubscribe(subscriber);
instrument('render.handlebars', null, function() {});
});
QUnit.test("it is possible to remove a subscriber", function() {
expect(4);
var count = 0;
var subscriber = subscribe("render", {
before: function() {
equal(count, 0);
ok(true, "Before callback was called");
},
after: function() {
equal(count, 0);
ok(true, "After callback was called");
count++;
}
});
instrument("render.handlebars", null, function() {});
unsubscribe(subscriber);
instrument("render.handlebars", null, function() {});
});
test('interaction event subscriber should be passed target', function(assert) {
assert.expect(2);
subscriber = subscribe('interaction.ember-action', {
before(name, timestamp, payload) {
assert.equal(payload.target.get('myProperty'), 'outer-thing', 'instrumentation subscriber before function was passed target');
},
after(name, timestamp, payload) {
assert.equal(payload.target.get('myProperty'), 'outer-thing', 'instrumentation subscriber after function was passed target');
}
});
registerTemplate('components/inner-component', '<button id="instrument-button" {{action "fireAction"}}>What it do</button>');
registerComponent('inner-component', EmberComponent.extend({
myProperty: 'inner-thing',
actions: {
fireAction() {
this.attrs.submit();
}
}
}));
registerTemplate('components/outer-component', '{{inner-component submit=(action outerSubmit)}}');
registerComponent('outer-component', EmberComponent.extend({
myProperty: 'outer-thing',
innerComponent,
outerSubmit() {}
}));
view = appendViewFor(`{{outer-component}}`);
view.$('#instrument-button').trigger('click');
});
function confirmPayload(payload, view) {
equal(payload && payload.object, view.toString(), 'payload object equals view.toString()');
equal(payload && payload.containerKey, view._debugContainerKey, 'payload contains the containerKey');
equal(payload && payload.view, view, 'payload contains the view itself');
}
QUnit.module('EmberView#instrumentation', {
setup() {
beforeCalls = [];
afterCalls = [];
subscribe('render', {
before(name, timestamp, payload) {
beforeCalls.push(payload);
},
after(name, timestamp, payload) {
afterCalls.push(payload);
}
});
view = EmberView.create({
_debugContainerKey: 'suchryzsd',
instrumentDisplay: 'asdfasdfmewj'
});
},
teardown() {
if (view) {
run(view, 'destroy');
}