sky/tests/js/classes.sky

<sky>
<import src="../resources/chai.sky" />
<import src="../resources/mocha.sky" />
<script>
describe("ES6 classes", function() {
  it("should create instances", function() {
    class Example {}
    var instance = new Example();
    assert.instanceOf(instance, Example);
  });

  it("should create subclasses", function() {
    class Parent {}
    class Child extends Parent {}
    var instance = new Child();
    assert.instanceOf(instance, Child);
    assert.instanceOf(instance, Parent);
  });

  it("should create anonymous classes", function() {
    var Parent = class {}
    var Child = class extends Parent {}
    var instance = new Child();
    assert.instanceOf(instance, Child);
    assert.instanceOf(instance, Parent);
  });

  it("should put methods on the prototype", function() {
    class Test {
      exampleMethod() { }
    }
    var instance = new Test();
    assert.isFalse(instance.hasOwnProperty("exampleMethod"));
    var proto = Object.getPrototypeOf(instance);
    assert.isTrue(proto.hasOwnProperty("exampleMethod"));
  });

  it("should call methods with |this|", function() {
    class Adder {
      constructor(value) {
        this.value = value;
      }
      add(other) {
        return this.value + other;
      }
    }

    var adder = new Adder(10);
    assert.equal(adder.add(15), 25);
  });

  it("should let toMethod rebind super", function() {
    var getValue = function() {
      assert.isFunction(this.value);
      assert.isFunction(this.superValue);
      return this.value() + super.superValue();
    }

    class HolderParent {
      superValue() {
        return 5;
      }
    }

    class Holder extends HolderParent {
      constructor() {
        this.value_ = 5;
      }
      value() {
        return this.value_;
      }
    }

    var holder = new Holder();
    var getValueMethod = getValue.toMethod(Holder.prototype);
    assert.equal(getValueMethod.call(holder), 10);
  });

  it("should support super() constructor calls", function() {
    class Parent {
      constructor(value) {
        this.value = value;
      }
    }

    class Child extends Parent {
      constructor(value) {
        super(value + 5);
      }
    }

    var child = new Child(10);
    assert.equal(child.value, 15);
  });

  it("should automatically call super() in default constructor", function() {
    class Parent {
      constructor() {
        this.value = 10;
      }
    }

    class Child extends Parent {
    }

    var child = new Child();
    assert.equal(child.value, 10);
  });

  it("should call super.method()", function() {
    class Parent {
      value() {
        return 10;
      }
    }

    class Child extends Parent {
      value() {
        return super.value() + 5;
      }
    }

    var child = new Child();
    assert.equal(child.value(), 15);
  });

  it("should support getters and setters", function() {
    class Variable {
      constructor(value) {
        this.value_ = value;
      }

      get value() {
        return this.value_;
      }

      set value(newValue) {
        this.value_ = newValue;
      }
    }

    var variable = new Variable("first");

    // Methods are on the prototype.
    var proto = Object.getPrototypeOf(variable);
    var descriptor = Object.getOwnPropertyDescriptor(proto, "value");
    assert.isObject(descriptor);
    assert.isFunction(descriptor.get);
    assert.isFunction(descriptor.set);
    assert.isUndefined(descriptor.value);

    // Getter and setter should not be on the instance.
    assert.isUndefined(Object.getOwnPropertyDescriptor(variable, "value"));

    assert.equal(variable.value, "first");
    assert.equal(variable.value_, "first");
    variable.value = "second";
    assert.equal(variable.value, "second");
    assert.equal(variable.value_, "second");
  });
});
</script>
</sky>