count = 0;
var item = ary.objectAt(2);
set(item, 'isDone', !get(item, 'isDone'));
equal(count, 1, '@each.isDone should have notified');
});
testBoth("should be clear caches for computed properties that have dependent keys on arrays that are changed after object initialization", function(get, set) {
var obj = EmberObject.createWithMixins({
init: function() {
set(this, 'resources', Ember.A());
},
common: computed(function() {
return get(get(this, 'resources').objectAt(0), 'common');
}).property('*****@*****.**')
});
get(obj, 'resources').pushObject(EmberObject.create({ common: "HI!" }));
equal("HI!", get(obj, 'common'));
set(get(obj, 'resources').objectAt(0), 'common', "BYE!");
equal("BYE!", get(obj, 'common'));
});
testBoth("observers that contain @each in the path should fire only once the first time they are accessed", function(get, set) {
var count = 0;
var obj = EmberObject.createWithMixins({
init: function() {
// Observer does not fire on init
testBoth("can iterate over a list of computed properties for a class", function(get, set) {
var MyClass = EmberObject.extend({
foo: computed(function() {
}),
fooDidChange: observer('foo', function() {
}),
bar: computed(function() {
})
});
var SubClass = MyClass.extend({
baz: computed(function() {
})
});
SubClass.reopen({
bat: computed(function() {
}).meta({ iAmBat: true })
});
var list = [];
MyClass.eachComputedProperty(function(name) {
list.push(name);
});
deepEqual(list.sort(), ['bar', 'foo'], "watched and unwatched computed properties are iterated");
list = [];
SubClass.eachComputedProperty(function(name, meta) {
list.push(name);
if (name === 'bat') {
deepEqual(meta, { iAmBat: true });
} else {
deepEqual(meta, {});
}
});
deepEqual(list.sort(), ['bar', 'bat', 'baz', 'foo'], "all inherited properties are included");
});
import {testWithDefault, testBoth} from 'ember-runtime/tests/props_helper';
QUnit.module('Function.prototype.observes() helper');
testBoth('global observer helper takes multiple params', function(get, set) {
if (Ember.EXTEND_PROTOTYPES === false) {
ok("undefined" === typeof Function.prototype.observes, 'Function.prototype helper disabled');
return ;
}
var MyMixin = Ember.Mixin.create({
count: 0,
foo: function() {
set(this, 'count', get(this, 'count')+1);
}.observes('bar', 'baz')
});
var obj = Ember.mixin({}, MyMixin);
equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
set(obj, 'bar', "BAZ");
set(obj, 'baz', "BAZ");
equal(get(obj, 'count'), 2, 'should invoke observer after change');
});
QUnit.module('Function.prototype.on() helper');
testBoth('sets up an event listener, and can trigger the function on multiple events', function(get, set) {
endPropertyChanges
} from "ember-metal/property_events";
import objectKeys from "ember-metal/keys";
import { testBoth } from 'ember-runtime/tests/props_helper';
import EmberObject from 'ember-runtime/system/object';
QUnit.module('ember-runtime/system/object/destroy_test');
testBoth("should schedule objects to be destroyed at the end of the run loop", function(get, set) {
var obj = EmberObject.create();
var meta;
run(function() {
obj.destroy();
meta = obj['__ember_meta__'];
ok(meta, "meta is not destroyed immediately");
ok(get(obj, 'isDestroying'), "object is marked as destroying immediately");
ok(!get(obj, 'isDestroyed'), "object is not destroyed immediately");
});
meta = obj['__ember_meta__'];
ok(!meta, "meta is destroyed after run loop finishes");
ok(get(obj, 'isDestroyed'), "object is destroyed after run loop finishes");
});
test("should raise an exception when modifying watched properties on a destroyed object", function() {
if (platform.hasAccessors) {
var obj = EmberObject.createWithMixins({
foo: "bar",
fooDidChange: observer('foo', function() { })
});
import {computed} from "ember-metal/computed";
import {isWatching} from "ember-metal/watching";
import {testBoth} from 'ember-runtime/tests/props_helper';
import ObjectProxy from "ember-runtime/system/object_proxy";
QUnit.module("ObjectProxy");
testBoth("should not proxy properties passed to create", function (get, set) {
var Proxy = ObjectProxy.extend({
cp: computed(function (key, value) {
if (value) {
this._cp = value;
}
return this._cp;
})
});
var proxy = Proxy.create({
prop: 'Foo',
cp: 'Bar'
});
equal(get(proxy, 'prop'), 'Foo', 'should not have tried to proxy set');
equal(proxy._cp, 'Bar', 'should use CP setter');
});
testBoth("should proxy properties to content", function(get, set) {
var content = {
firstName: 'Tom',
lastName: 'Dale',
unknownProperty: function (key) { return key + ' unknown';}
},