feat(form): implemented an imperative way of updating the view by updating the value of a control

modules/angular2/test/forms/directives_spec.ts

@@ -79,7 +79,7 @@ export function main() {
         });
 
         it("should write value to the DOM", () => {
-          formModel.find(["login"]).value = "initValue";
+          formModel.find(["login"]).updateValue("initValue");
 
           form.addControl(loginControlDir);
 
@@ -104,7 +104,7 @@ export function main() {
         it("should update dom values of all the directives", () => {
           form.addControl(loginControlDir);
 
-          formModel.find(["login"]).value = "new value";
+          formModel.find(["login"]).updateValue("new value");
 
           form.onChange(null);
 
@@ -180,7 +180,7 @@ export function main() {
         expect(control.valid).toBe(true);
 
         // this will add the required validator and recalculate the validity
-        controlDir.onChange(null);
+        controlDir.onChange({});
 
         expect(control.valid).toBe(false);
       });

modules/angular2/test/forms/integration_spec.ts

@@ -114,6 +114,30 @@ export function main() {
              });
        }));
 
+    it("should update DOM elements when updating the value of a control",
+       inject([TestBed, AsyncTestCompleter], (tb, async) => {
+         var login = new Control("oldValue");
+         var form = new ControlGroup({"login": login});
+         var ctx = MyComp.create({form: form});
+
+         var t = `<div [form-model]="form">
+                <input type="text" control="login">
+               </div>`;
+
+         tb.createView(MyComp, {context: ctx, html: t})
+             .then((view) => {
+               view.detectChanges();
+
+               login.updateValue("newValue");
+
+               view.detectChanges();
+
+               var input = view.querySelector("input");
+               expect(input.value).toEqual("newValue");
+               async.done();
+             });
+       }));
+
     describe("different control types", () => {
       it("should support <input type=text>", inject([TestBed, AsyncTestCompleter], (tb, async) => {
            var ctx = MyComp.create({form: new ControlGroup({"text": new Control("old")})});

modules/angular2/test/forms/model_spec.ts

@@ -9,6 +9,9 @@ import {
   afterEach,
   el,
   AsyncTestCompleter,
+  fakeAsync,
+  flushMicrotasks,
+  tick,
   inject
 } from 'angular2/test_lib';
 import {ControlGroup, Control, ControlArray, Validators} from 'angular2/forms';
@@ -62,6 +65,54 @@ export function main() {
         });
       });
 
+      describe("updateValue", () => {
+        var g, c;
+        beforeEach(() => {
+          c = new Control("oldValue");
+          g = new ControlGroup({"one": c});
+        });
+
+        it("should update the value of the control", () => {
+          c.updateValue("newValue");
+          expect(c.value).toEqual("newValue");
+        });
+
+        it("should invoke onChange if it is present", () => {
+          var onChange;
+          c.registerOnChange((v) => onChange = ["invoked", v]);
+
+          c.updateValue("newValue");
+
+          expect(onChange).toEqual(["invoked", "newValue"]);
+        });
+
+        it("should update the parent", () => {
+          c.updateValue("newValue");
+          expect(g.value).toEqual({"one": "newValue"});
+        });
+
+        it("should not update the parent when explicitly specified", () => {
+          c.updateValue("newValue", {onlySelf: true});
+          expect(g.value).toEqual({"one": "oldValue"});
+        });
+
+        it("should fire an event", fakeAsync(() => {
+             ObservableWrapper.subscribe(c.valueChanges,
+                                         (value) => { expect(value).toEqual("newValue"); });
+
+             c.updateValue("newValue");
+             tick();
+           }));
+
+        it("should not fire an event when explicitly specified", fakeAsync(() => {
+             ObservableWrapper.subscribe(c.valueChanges, (value) => { throw "Should not happen"; });
+
+             c.updateValue("newValue", {emitEvent: false});
+
+             tick();
+           }));
+      });
+
       describe("valueChanges", () => {
         var c;
 
@@ -302,8 +353,8 @@ export function main() {
 
                  if (loggedValues.length == 2) {
                    expect(loggedValues)
-                       .toEqual([{"one": "new1", "two": "old2"}, {"one": "new1", "two": "new2"}])
-                           async.done();
+                       .toEqual([{"one": "new1", "two": "old2"}, {"one": "new1", "two": "new2"}]);
+                   async.done();
                  }
                });