test("raises if a dependency with a period is requested", function() {
var container = new Container();
container.register('controller:big.bird', Controller.extend());
container.register('controller:foo', Controller.extend({
needs: 'big.bird'
}));
expectAssertion(function() {
container.lookup('controller:foo');
}, /needs must not specify dependencies with periods in their names \(big\.bird\)/,
'throws if periods used');
});
test("{{render}} helper should not have assertion if template is supplied in block-form", function() {
var template = "<h1>HI</h1>{{#render 'good'}} {{name}}{{/render}}";
var controller = EmberController.extend({container: container});
container.register('controller:good', EmberController.extend({ name: 'Rob'}));
view = EmberView.create({
controller: controller.create(),
template: compile(template)
});
appendView(view);
equal(view.$().text(), 'HI Rob');
});
test("If a controller specifies a dependency, it is accessible", function() {
var container = new Container();
container.register('controller:post', Controller.extend({
needs: 'posts'
}));
container.register('controller:posts', Controller.extend());
var postController = container.lookup('controller:post'),
postsController = container.lookup('controller:posts');
equal(postsController, postController.get('controllers.posts'), "controller.posts must be auto synthesized");
});
test("{{render}} helper with a supplied model should not fire observers on the controller", function () {
var template = "<h1>HI</h1>{{render 'post' post}}";
var post = {
title: "Rails is omakase"
};
view = EmberView.create({
controller: EmberController.create({
container: container,
post: post
}),
template: compile(template)
});
var PostController = EmberObjectController.extend({
contentDidChange: observer('content', function(){
contentDidChange++;
})
});
container.register('controller:post', PostController);
Ember.TEMPLATES['post'] = compile("<p>{{title}}</p>");
var contentDidChange = 0;
appendView(view);
equal(contentDidChange, 0, "content observer did not fire");
});
test("if a ContainerView is created with a currentView, it is rendered as a child view", function() {
var context = null;
var templateData = null;
var mainView = View.create({
template: function(ctx, opts) {
context = ctx;
templateData = opts.data;
return "This is the main view.";
}
});
var controller = Controller.create();
container = ContainerView.create({
currentView: mainView,
controller: controller
});
run(function() {
container.appendTo('#qunit-fixture');
});
equal(container.$().text(), "This is the main view.", "should render its child");
equal(get(container, 'length'), 1, "should have one child view");
equal(container.objectAt(0), mainView, "should have the currentView as the only child view");
equal(mainView.get('parentView'), container, "parentView is setup");
equal(context, container.get('context'), 'context preserved');
equal(templateData.keywords.controller, controller, 'templateData is setup');
equal(templateData.keywords.view, mainView, 'templateData is setup');
});
test("the default ContainerDebugAdapter catalogs controller entries", function(){
App.PostController = EmberController.extend();
var controllerClasses = adapter.catalogEntriesByType('controller');
equal(controllerClasses.length, 1, "found 1 class");
equal(controllerClasses[0], 'post', "found the right class");
});
test("handles whitelisted modifier keys", function() {
var eventHandlerWasCalled = false, shortcutHandlerWasCalled = false;
var controller = EmberController.extend({
actions: {
edit: function() { eventHandlerWasCalled = true; },
shortcut: function() { shortcutHandlerWasCalled = true; }
}
}).create();
view = EmberView.create({
controller: controller,
template: EmberHandlebars.compile('<a href="#" {{action "edit" allowedKeys="alt"}}>click me</a> <div {{action "shortcut" allowedKeys="any"}}>click me too</div>')
});
appendView();
var actionId = view.$('a[data-ember-action]').attr('data-ember-action');
ok(ActionHelper.registeredActions[actionId], "The action was registered");
var e = jQuery.Event('click');
e.altKey = true;
view.$('a').trigger(e);
ok(eventHandlerWasCalled, "The event handler was called");
e = jQuery.Event('click');
e.ctrlKey = true;
view.$('div').trigger(e);
ok(shortcutHandlerWasCalled, "The \"any\" shortcut's event handler was called");
});
test("a quoteless parameter that also exists as an action name functions properly", function(){
Ember.TESTING_DEPRECATION = true;
var triggeredAction;
view = EmberView.create({
template: compile("<a id='oops-bound-param'' {{action ohNoeNotValid}}>Hi</a>")
});
var controller = EmberController.extend({
actions: {
ohNoeNotValid: function() {
triggeredAction = true;
}
}
}).create();
run(function() {
view.set('controller', controller);
view.appendTo('#qunit-fixture');
});
run(function(){
view.$("#oops-bound-param").click();
});
ok(triggeredAction, 'the action was triggered');
});
test("should allow multiple contexts to be specified", function() {
var passedContexts,
models = [EmberObject.create(), EmberObject.create()];
var controller = EmberController.extend({
actions: {
edit: function() {
passedContexts = [].slice.call(arguments);
}
}
}).create();
view = EmberView.create({
controller: controller,
modelA: models[0],
modelB: models[1],
template: EmberHandlebars.compile('<button {{action "edit" view.modelA view.modelB}}>edit</button>')
});
appendView();
view.$('button').trigger('click');
deepEqual(passedContexts, models, "the action was called with the passed contexts");
});
test("it can trigger actions for keyboard events", function() {
var showCalled = false;
view = EmberView.create({
template: compile("<input type='text' {{action 'show' on='keyUp'}}>")
});
var controller = EmberController.extend({
actions: {
show: function() {
showCalled = true;
}
}
}).create();
run(function() {
view.set('controller', controller);
view.appendTo('#qunit-fixture');
});
var event = jQuery.Event("keyup");
event.char = 'a';
event.which = 65;
view.$('input').trigger(event);
ok(showCalled, "should call action with keyup");
});
test("itemController's parentController property, when the ArrayController has a parentController", function() {
var PersonController = ObjectController.extend({
controllerName: computed(function() {
return "controller:" + get(this, 'content.name') + ' of ' + get(this, 'parentController.company');
})
}),
PeopleController = ArrayController.extend({
content: people,
itemController: 'person',
parentController: computed(function(){
return this.container.lookup('controller:company');
}),
company: 'Yapp'
}),
CompanyController = EmberController.extend();
container.register('controller:company', CompanyController);
container.register('controller:people', PeopleController);
container.register('controller:person', PersonController);
run(function() { view.destroy(); }); // destroy existing view
view = EmberView.create({
container: container,
template: templateFor('{{#each}}{{controllerName}}{{/each}}'),
controller: container.lookup('controller:people')
});
append(view);
equal(view.$().text(), "controller:Steve Holt of Yappcontroller:Annabelle of Yapp");
});
test("a quoteless parameter that also exists as an action name results in an assertion", function(){
var triggeredAction;
view = EmberView.create({
template: compile("<a id='oops-bound-param' {{action ohNoeNotValid}}>Hi</a>")
});
var controller = EmberController.extend({
actions: {
ohNoeNotValid: function() {
triggeredAction = true;
}
}
}).create();
run(function() {
view.set('controller', controller);
view.appendTo('#qunit-fixture');
});
var oldAssert = Ember.assert;
Ember.assert = function(message, test){
ok(test, message + " -- was properly asserted");
};
run(function(){
view.$("#oops-bound-param").click();
});
ok(triggeredAction, 'the action was triggered');
Ember.assert = oldAssert;
});
test("it supports itemController when using a custom keyword", function() {
var Controller = EmberController.extend({
controllerName: computed(function() {
return "controller:"+this.get('content.name');
})
});
container.register('controller:array', ArrayController.extend());
run(function() { view.destroy(); }); // destroy existing view
view = EmberView.create({
container: container,
template: templateFor('{{#each person in view.people itemController="person"}}{{person.controllerName}}{{/each}}'),
people: people,
controller: {
container: container
}
});
container.register('controller:person', Controller);
append(view);
equal(view.$().text(), "controller:Steve Holtcontroller:Annabelle");
run(function() {
view.rerender();
});
equal(view.$().text(), "controller:Steve Holtcontroller:Annabelle");
});
test("{{render}} helper should be able to render a template again when it was removed", function() {
var template = "<h1>HI</h1>{{outlet}}";
var controller = EmberController.extend({container: container});
view = EmberView.create({
template: compile(template)
});
Ember.TEMPLATES['home'] = compile("<p>BYE</p>");
appendView(view);
run(function() {
view.connectOutlet('main', EmberView.create({
controller: controller.create(),
template: compile("<p>1{{render 'home'}}</p>")
}));
});
equal(view.$().text(), 'HI1BYE');
run(function() {
view.connectOutlet('main', EmberView.create({
controller: controller.create(),
template: compile("<p>2{{render 'home'}}</p>")
}));
});
equal(view.$().text(), 'HI2BYE');
});
test("{{render}} helper should not treat invocations with falsy contexts as context-less", function() {
var template = "<h1>HI</h1> {{render 'post' zero}} {{render 'post' nonexistent}}";
view = EmberView.create({
controller: EmberController.createWithMixins({
container: container,
zero: false
}),
template: compile(template)
});
var PostController = EmberObjectController.extend();
container.register('controller:post', PostController, {singleton: false});
Ember.TEMPLATES['post'] = compile("<p>{{#unless content}}NOTHING{{/unless}}</p>");
appendView(view);
var postController1 = view.get('_childViews')[0].get('controller');
var postController2 = view.get('_childViews')[1].get('controller');
ok(view.$().text().match(/^HI ?NOTHING ?NOTHING$/));
equal(postController1.get('model'), 0);
equal(postController2.get('model'), undefined);
});
test("should send the view, event and current Handlebars context to the action", function() {
var passedTarget;
var passedContext;
var aTarget = EmberController.extend({
actions: {
edit: function(context) {
passedTarget = this;
passedContext = context;
}
}
}).create();
var aContext = { aTarget: aTarget };
view = EmberView.create({
aContext: aContext,
template: EmberHandlebars.compile('{{#with view.aContext}}<a id="edit" href="#" {{action "edit" this target="aTarget"}}>edit</a>{{/with}}')
});
appendView();
view.$('#edit').trigger('click');
strictEqual(passedTarget, aTarget, "the action is called with the target as this");
strictEqual(passedContext, aContext, "the parameter is passed along");
});
test("a quoteless parameter that also exists as an action name in deprecated action in controller style results in an assertion", function(){
var dropDeprecatedActionStyleOrig = Ember.FEATURES['ember-routing-drop-deprecated-action-style'];
Ember.FEATURES['ember-routing-drop-deprecated-action-style'] = false;
var triggeredAction;
view = EmberView.create({
template: compile("<a id='oops-bound-param' {{action ohNoeNotValid}}>Hi</a>")
});
var controller = EmberController.extend({
ohNoeNotValid: function() {
triggeredAction = true;
}
}).create();
run(function() {
view.set('controller', controller);
view.appendTo('#qunit-fixture');
});
var oldAssert = Ember.assert;
Ember.assert = function(message, test){
ok(test, message + " -- was properly asserted");
};
run(function(){
view.$("#oops-bound-param").click();
});
ok(triggeredAction, 'the action was triggered');
Ember.assert = oldAssert;
Ember.FEATURES['ember-routing-drop-deprecated-action-style'] = dropDeprecatedActionStyleOrig;
});
test("generateController should create App.Controller if provided", function() {
var controller;
namespace.Controller = Controller.extend();
controller = generateController(container, 'home');
ok(controller instanceof namespace.Controller, 'should create controller');
});
test('the default resolver can look things up in other namespaces', function() {
var UserInterface = Ember.lookup.UserInterface = Namespace.create();
UserInterface.NavigationController = Controller.extend();
var nav = locator.lookup('controller:userInterface/navigation');
ok(nav instanceof UserInterface.NavigationController, "the result should be an instance of the specified class");
});
test("If a controller specifies a dependency, but does not have a container it should error", function(){
var AController = Controller.extend({
needs: 'posts'
});
expectAssertion(function(){
AController.create();
}, /specifies `needs`, but does not have a container. Please ensure this controller was instantiated with a container./);
});
test("If a controller specifies an unavailable dependency, it raises", function() {
var container = new Container();
container.register('controller:post', Controller.extend({
needs: ['comments']
}));
throws(function() {
container.lookup('controller:post');
}, /controller:comments/);
container.register('controller:blog', Controller.extend({
needs: ['posts', 'comments']
}));
throws(function() {
container.lookup('controller:blog');
}, /controller:posts, controller:comments/);
});
test("{{render}} helper should have assertion if neither template nor view exists", function() {
var template = "<h1>HI</h1>{{render 'oops'}}";
var controller = EmberController.extend({container: container});
view = EmberView.create({
controller: controller.create(),
template: compile(template)
});
expectAssertion(function() {
appendView(view);
}, 'You used `{{render \'oops\'}}`, but \'oops\' can not be found as either a template or a view.');
});
test ("setting the value of a controller dependency should not be possible", function(){
var container = new Container();
container.register('controller:post', Controller.extend({
needs: 'posts'
}));
container.register('controller:posts', Controller.extend());
var postController = container.lookup('controller:post'),
postsController = container.lookup('controller:posts');
throws(function(){
postController.set('controllers.posts', 'epic-self-troll');
},
/You cannot overwrite the value of `controllers.posts` of .+/,
'should raise when attempting to set the value of a controller dependency property');
postController.set('controllers.posts.title', "A Troll's Life");
equal(postController.get('controllers.posts.title'), "A Troll's Life", "can set the value of controllers.posts.title");
});
test("passing a function for the actions hash triggers an assertion", function() {
expect(1);
var controller = Controller.extend({
actions: function(){}
});
expectAssertion(function(){
run(function(){
controller.create();
});
});
});
test("it supports itemController", function() {
var Controller = EmberController.extend({
controllerName: computed(function() {
return "controller:"+this.get('content.name');
})
});
var container = new Container();
run(function() { view.destroy(); }); // destroy existing view
var parentController = {
container: container
};
container.register('controller:array', ArrayController.extend());
view = EmberView.create({
container: container,
template: templateFor('{{#each view.people itemController="person"}}{{controllerName}}{{/each}}'),
people: people,
controller: parentController
});
container.register('controller:person', Controller);
append(view);
equal(view.$().text(), "controller:Steve Holtcontroller:Annabelle");
run(function() {
view.rerender();
});
assertText(view, "controller:Steve Holtcontroller:Annabelle");
run(function() {
people.pushObject({ name: "Yehuda Katz" });
});
assertText(view, "controller:Steve Holtcontroller:Annabellecontroller:Yehuda Katz");
run(function() {
set(view, 'people', A([{ name: "Trek Glowacki" }, { name: "Geoffrey Grosenbach" }]));
});
assertText(view, "controller:Trek Glowackicontroller:Geoffrey Grosenbach");
var controller = view.get('_childViews')[0].get('controller');
strictEqual(view.get('_childViews')[0].get('_arrayController.target'), parentController, "the target property of the child controllers are set correctly");
});
test("{{render}} helper should not have assertion if view exists without a template", function() {
var template = "<h1>HI</h1>{{render 'oops'}}";
var controller = EmberController.extend({container: container});
view = EmberView.create({
controller: controller.create(),
template: compile(template)
});
container.register('view:oops', EmberView.extend());
appendView(view);
equal(view.$().text(), 'HI');
});
test("raises if trying to get a controller that was not pre-defined in `needs`", function() {
var container = new Container();
container.register('controller:foo', Controller.extend());
container.register('controller:bar', Controller.extend({
needs: 'foo'
}));
var fooController = container.lookup('controller:foo');
var barController = container.lookup('controller:bar');
throws(function(){
fooController.get('controllers.bar');
}, /#needs does not include `bar`/,
'throws if controllers is accesed but needs not defined');
equal(barController.get('controllers.foo'), fooController, 'correctly needed controllers should continue to work');
throws(function(){
barController.get('controllers.baz');
}, /#needs does not include `baz`/,
'should throw if no such controller was needed');
});
test("{{render}} helper should render a template without a model only once", function() {
var template = "<h1>HI</h1>{{render 'home'}}<hr/>{{render home}}";
var controller = EmberController.extend({container: container});
view = EmberView.create({
controller: controller.create(),
template: compile(template)
});
Ember.TEMPLATES['home'] = compile("<p>BYE</p>");
expectAssertion(function() {
appendView(view);
}, /\{\{render\}\} helper once/i);
});
test("{{render}} helper should raise an error when a given controller name does not resolve to a controller", function() {
var template = '<h1>HI</h1>{{render "home" controller="postss"}}';
var controller = EmberController.extend({container: container});
container.register('controller:posts', EmberArrayController.extend());
view = EmberView.create({
controller: controller.create(),
template: compile(template)
});
Ember.TEMPLATES['home'] = compile("<p>BYE</p>");
expectAssertion(function() {
appendView(view);
}, 'The controller name you supplied \'postss\' did not resolve to a controller.');
});
test("Using quoteless templateName works properly (DEPRECATED)", function(){
var template = '<h1>HI</h1>{{render home}}';
var controller = EmberController.extend({container: container});
view = EmberView.create({
controller: controller.create(),
template: compile(template)
});
Ember.TEMPLATES['home'] = compile("<p>BYE</p>");
expectDeprecation("Using a quoteless parameter with {{render}} is deprecated. Please update to quoted usage '{{render \"home\"}}.");
appendView(view);
equal(view.$('p:contains(BYE)').length, 1, "template was rendered");
});