michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: "use strict";
michael@0: 
michael@0: var Trait = require("sdk/deprecated/light-traits").Trait;
michael@0: var utils = require("./utils");
michael@0: var Data = utils.Data;
michael@0: var Method = utils.Method;
michael@0: var Accessor = utils.Accessor;
michael@0: var Required = utils.Required;
michael@0: var Conflict = utils.Conflict;
michael@0: 
michael@0: function method() {}
michael@0: 
michael@0: exports.Assert = require("./assert").Assert;
michael@0: 
michael@0: exports["test empty trait"] = function (assert) {
michael@0:   assert.equalTraits(Trait({}), {});
michael@0: };
michael@0: 
michael@0: exports["test simple trait"] = function (assert) {
michael@0:   var expected = {
michael@0:     a: Data(0, true, true, true),
michael@0:     b: Method(method, true, true, true)
michael@0:   };
michael@0: 
michael@0:   assert.equalTraits(Trait({ a: 0, b: method }), expected);
michael@0: };
michael@0: 
michael@0: exports["test simple trait with Trait.required property"] = function (assert) {
michael@0:   var actual = Trait({ a: Trait.required, b: 1 });
michael@0:   var expected = { a: Required("a"), b: Data(1) };
michael@0: 
michael@0:   assert.equalTraits(actual, expected);
michael@0: };
michael@0: 
michael@0: exports["test ordering of trait properties is irrelevant"] = function (assert) {
michael@0:   var actual = Trait({ a: 0, b: 1, c: Trait.required });
michael@0:   var expected = Trait({ b: 1, c: Trait.required, a: 0 });
michael@0: 
michael@0:   assert.equalTraits(actual, expected);
michael@0: };
michael@0: 
michael@0: exports["test trait with accessor property"] = function (assert) {
michael@0:   var record = { get a() {}, set a(v) {} };
michael@0:   var get = Object.getOwnPropertyDescriptor(record, "a").get;
michael@0:   var set = Object.getOwnPropertyDescriptor(record, "a").set;
michael@0: 
michael@0:   assert.equalTraits(Trait(record), { a: Accessor(get, set) });
michael@0: };
michael@0: 
michael@0: exports["test simple composition"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait({ a: 0, b: 1 }), Trait({ c: 2, d: method }));
michael@0:   var expected = { a: Data(0), b: Data(1), c: Data(2), d: Method(method) };
michael@0: 
michael@0:   assert.equalTraits(actual, expected);
michael@0: };
michael@0: 
michael@0: exports["test composition with conflict"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait({ a: 0, b: 1 }), Trait({ a: 2, c: method }));
michael@0:   var expected = { a: Conflict("a"), b: Data(1), c: Method(method) };
michael@0: 
michael@0:   assert.equalTraits(actual, expected);
michael@0: };
michael@0: 
michael@0: exports["test composition of identical props does not cause conflict"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait({ a: 0, b: 1 }), Trait({ a: 0, c: method }));
michael@0: 
michael@0:   assert.equalTraits(actual, { a: Data(0), b: Data(1), c: Method(method) });
michael@0: };
michael@0: 
michael@0: exports["test composition with identical Trait.required props"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait({ a: Trait.required, b: 1 }),
michael@0:                              Trait({ a: Trait.required, c: method }));
michael@0: 
michael@0:   assert.equalTraits(actual, { a: Required(), b: Data(1), c: Method(method) });
michael@0: };
michael@0: 
michael@0: exports["test composition satisfying a Trait.required prop"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait({ a: Trait.required, b: 1 }),
michael@0:                              Trait({ a: method }));
michael@0: 
michael@0:   assert.equalTraits(actual, { a: Method(method), b: Data(1) });
michael@0: };
michael@0: 
michael@0: exports["test compose is neutral wrt conflicts"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait.compose(Trait({ a: 1 }), Trait({ a: 2 })),
michael@0:                              Trait({ b: 0 }));
michael@0: 
michael@0:   assert.equalTraits(actual, { a: Conflict("a"), b: Data(0) });
michael@0: };
michael@0: 
michael@0: exports["test conflicting prop overrides Trait.required prop"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait.compose(Trait({ a: 1 }),
michael@0:                                            Trait({ a: 2 })),
michael@0:                              Trait({ a: Trait.required }));
michael@0: 
michael@0:   assert.equalTraits(actual, { a: Conflict("a") });
michael@0: };
michael@0: 
michael@0: exports["test compose is commutative"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait({ a: 0, b: 1 }), Trait({ c: 2, d: method }));
michael@0:   var expected = Trait.compose(Trait({ c: 2, d: method }),
michael@0:                                Trait({ a: 0, b: 1 }));
michael@0: 
michael@0:   assert.equalTraits(actual, expected);
michael@0: };
michael@0: 
michael@0: exports["test compose is commutative, also for Trait.required/conflicting props"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait({ a: 0, b: 1, c: 3, e: Trait.required }),
michael@0:                              Trait({ c: 2, d: method }));
michael@0: 
michael@0:   var expected = Trait.compose(Trait({ c: 2, d: method }),
michael@0:                                Trait({ a: 0, b: 1, c: 3, e: Trait.required }));
michael@0: 
michael@0:   assert.equalTraits(actual, expected);
michael@0: };
michael@0: 
michael@0: exports["test compose is associative"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait({ a: 0, b: 1, c: 3, d: Trait.required }),
michael@0:                              Trait.compose(Trait({ c: 3, d: Trait.required }),
michael@0:                                            Trait({ c: 2, d: method,
michael@0:                                                     e: "foo" })));
michael@0: 
michael@0:   var expected = Trait.compose(
michael@0:     Trait.compose(Trait({ a: 0, b: 1, c: 3, d: Trait.required }),
michael@0:                   Trait({ c: 3, d: Trait.required })),
michael@0:     Trait({ c: 2, d: method, e: "foo" }));
michael@0: 
michael@0:   assert.equalTraits(actual, expected);
michael@0: };
michael@0: 
michael@0: exports["test diamond import of same prop does not generate conflict"] = function (assert) {
michael@0:   var actual = Trait.compose(Trait.compose(Trait({ b: 2 }), Trait({ a: 1 })),
michael@0:                              Trait.compose(Trait({ c: 3 }), Trait({ a: 1 })),
michael@0:                              Trait({ d: 4 }));
michael@0:   var expected = { a: Data(1), b: Data(2), c: Data(3), d: Data(4) };
michael@0: 
michael@0:   assert.equalTraits(actual, expected);
michael@0: };
michael@0: 
michael@0: exports["test resolve with empty resolutions has no effect"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1, b: Trait.required, c: method }).resolve({}),
michael@0:                     { a: Data(1), b: Required(), c: Method(method) });
michael@0: };
michael@0: 
michael@0: exports["test resolve: renaming"] = function (assert) {
michael@0:   var actual = Trait({ a: 1, b: Trait.required, c: method });
michael@0: 
michael@0:   assert.equalTraits(actual.resolve({ a: "A", c: "C" }),
michael@0:                     { A: Data(1), b: Required(), C: Method(method),
michael@0:                       a: Required(), c: Required() });
michael@0: };
michael@0: 
michael@0: exports["test resolve: renaming to conflicting name causes conflict, order 1"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1, b: 2 }).resolve({ a: "b" }),
michael@0:                     { b: Conflict("b"), a: Required() });
michael@0: };
michael@0: 
michael@0: exports["test resolve: renaming to conflicting name causes conflict, order 2"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ b: 2, a: 1 }).resolve({ a: "b" }),
michael@0:                     { b: Conflict("b"), a: Required() });
michael@0: };
michael@0: 
michael@0: exports["test resolve: simple exclusion"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1, b: 2 }).resolve({ a: undefined }),
michael@0:                     { a: Required(), b: Data(2) });
michael@0: };
michael@0: 
michael@0: exports["test resolve: exclusion to empty trait"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1, b: 2 }).resolve({ a: null, b: undefined }),
michael@0:                     { a: Required(), b: Required() });
michael@0: };
michael@0: 
michael@0: exports["test resolve: exclusion and renaming of disjoint props"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1, b: 2 }).resolve({ a: undefined, b: "c" }),
michael@0:                     { a: Required(), c: Data(2), b: Required() });
michael@0: };
michael@0: 
michael@0: exports["test resolve: exclusion and renaming of overlapping props"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1, b: 2 }).resolve({ a: undefined, b: "a" }),
michael@0:                      { a: Data(2), b: Required() });
michael@0: };
michael@0: 
michael@0: exports["test resolve: renaming to a common alias causes conflict"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1, b: 2 }).resolve({ a: "c", b: "c" }),
michael@0:                      { c: Conflict("c"), a: Required(), b: Required() });
michael@0: };
michael@0: 
michael@0: exports["test resolve: renaming overrides Trait.required target"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: Trait.required, b: 2 }).resolve({ b: "a" }),
michael@0:                      { a: Data(2), b: Required() });
michael@0: };
michael@0: 
michael@0: exports["test resolve: renaming Trait.required properties has no effect"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 2, b: Trait.required }).resolve({ b: "a" }),
michael@0:                      { a: Data(2), b: Required() });
michael@0: };
michael@0: 
michael@0: exports["test resolve: renaming of non-existent props has no effect"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1, b: 2 }).resolve({ a: "c", d: "c" }),
michael@0:                      { c: Data(1), b: Data(2), a: Required() });
michael@0: };
michael@0: 
michael@0: exports["test resolve: exclusion of non-existent props has no effect"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1 }).resolve({ b: undefined }), { a: Data(1) });
michael@0: };
michael@0: 
michael@0: exports["test resolve is neutral w.r.t. Trait.required properties"] = function (assert) {
michael@0:   var actual = Trait({ a: Trait.required, b: Trait.required, c: "foo", d: 1 });
michael@0:   var expected = { a: Required(), b: Required(), c: Data("foo"), d: Data(1) };
michael@0:   assert.equalTraits(actual.resolve({ a: "c", b: undefined }), expected);
michael@0: };
michael@0: 
michael@0: exports["test resolve supports swapping of property names, ordering 1"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1, b: 2 }).resolve({ a: "b", b: "a" }),
michael@0:                      { a: Data(2), b: Data(1) });
michael@0: };
michael@0: 
michael@0: exports["test resolve supports swapping of property names, ordering 2"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ a: 1, b: 2 }).resolve({ b: "a", a: "b" }),
michael@0:                      { a: Data(2), b: Data(1) });
michael@0: };
michael@0: 
michael@0: exports["test resolve supports swapping of property names, ordering 3"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ b: 2, a: 1 }).resolve({ b: "a", a: "b" }),
michael@0:                      { a: Data(2), b: Data(1) });
michael@0: };
michael@0: 
michael@0: exports["test resolve supports swapping of property names, ordering 4"] = function (assert) {
michael@0:   assert.equalTraits(Trait({ b: 2, a: 1 }).resolve({ a: "b", b: "a" }),
michael@0:                      { a: Data(2), b: Data(1) });
michael@0: };
michael@0: 
michael@0: exports["test create simple"] = function (assert) {
michael@0:   var o1 = Trait({
michael@0:     a: 1,
michael@0:     b: function () {
michael@0:       return this.a;
michael@0:     }
michael@0:   }).create(Object.prototype);
michael@0: 
michael@0:   assert.equal(Object.getPrototypeOf(o1), Object.prototype, "o1 prototype");
michael@0:   assert.equal(1, o1.a, "o1.a");
michael@0:   assert.equal(1, o1.b(), "o1.b()");
michael@0:   assert.equal(Object.keys(o1).length, 2, "Object.keys(o1).length === 2");
michael@0: };
michael@0: 
michael@0: exports["test create with Array.prototype"] = function (assert) {
michael@0:   var o2 = Trait({}).create(Array.prototype);
michael@0:   assert.equal(Object.getPrototypeOf(o2), Array.prototype, "o2 prototype");
michael@0: };
michael@0: 
michael@0: exports["test exception for incomplete required properties"] = function (assert) {
michael@0:   assert.throws(function () {
michael@0:     Trait({ foo: Trait.required }).create(Object.prototype);
michael@0:   }, /Missing required property: `foo`/, "required prop error");
michael@0: };
michael@0: 
michael@0: exports["test exception for unresolved conflicts"] = function (assert) {
michael@0:   assert.throws(function () {
michael@0:     Trait.compose(Trait({ a: 0 }), Trait({ a: 1 })).create({});
michael@0:   }, /Remaining conflicting property: `a`/, "conflicting prop error");
michael@0: };
michael@0: 
michael@0: exports["test verify that required properties are present but undefined"] = function (assert) {
michael@0:   var o4 = Object.create(Object.prototype, Trait({ foo: Trait.required }));
michael@0: 
michael@0:   assert.ok("foo" in o4, "required property present");
michael@0:   assert.throws(function () {
michael@0:     o4.foo;
michael@0:   }, /Missing required property: `foo`/, "required prop error");
michael@0: };
michael@0: 
michael@0: exports["test verify that conflicting properties are present"] = function (assert) {
michael@0:   var o5 = Object.create(Object.prototype, Trait.compose(Trait({ a: 0 }),
michael@0:                                                          Trait({ a: 1 })));
michael@0: 
michael@0:   assert.ok("a" in o5, "conflicting property present");
michael@0:   assert.throws(function () {
michael@0:     o5.a;
michael@0:   }, /Remaining conflicting property: `a`/, "conflicting prop access error");
michael@0: };
michael@0: 
michael@0: exports["test diamond with conflicts"] = function (assert) {
michael@0:   function makeT1(x) {
michael@0:     return Trait({
michael@0:       m: function () {
michael@0:         return x
michael@0:       }
michael@0:     })
michael@0:   };
michael@0: 
michael@0:   function makeT2(x) {
michael@0:     return Trait.compose(Trait({
michael@0:       t2: "foo"
michael@0:     }), makeT1(x));
michael@0:   };
michael@0: 
michael@0:   function makeT3(x) {
michael@0:     return Trait.compose(Trait({
michael@0:       t3: "bar"
michael@0:     }), makeT1(x));
michael@0:   };
michael@0: 
michael@0:   var T4 = Trait.compose(makeT2(5), makeT3(5));
michael@0: 
michael@0:   assert.throws(function () {
michael@0:     T4.create(Object.prototype);
michael@0:   }, /Remaining conflicting property: `m`/, "diamond prop conflict");
michael@0: };
michael@0: 
michael@0: exports["test providing requirements through proto"] = function (assert) {
michael@0:   var t = Trait({ required: Trait.required }).create({ required: "test" });
michael@0:   assert.equal(t.required, "test", "property from proto is inherited");
michael@0: };
michael@0: 
michael@0: if (module == require.main)
michael@0:   require("test").run(exports);