test(Pipes): assert Date, Json & Slice are non pure

modules/angular2/test/core/pipes/date_pipe_spec.ts

@@ -12,6 +12,7 @@ import {
 
 import {DatePipe} from 'angular2/core';
 import {DateWrapper} from 'angular2/src/core/facade/lang';
+import {PipeResolver} from 'angular2/src/core/linker/pipe_resolver';
 
 export function main() {
   describe("DatePipe", () => {
@@ -23,6 +24,10 @@ export function main() {
       pipe = new DatePipe();
     });
 
+    it('should be marked as non-pure', () => {
+      expect(new PipeResolver().resolve(DatePipe).pure).toEqual(false);
+    });
+
     describe("supports", () => {
       it("should support date", () => { expect(pipe.supports(date)).toBe(true); });
       it("should support int", () => { expect(pipe.supports(123456789)).toBe(true); });

modules/angular2/test/core/pipes/json_pipe_spec.ts

@@ -10,11 +10,12 @@ import {
   AsyncTestCompleter,
   inject,
   proxy,
-  SpyObject
+  SpyObject,
+  TestComponentBuilder
 } from 'angular2/testing_internal';
 import {Json, RegExp, NumberWrapper, StringWrapper} from 'angular2/src/core/facade/lang';
 
-import {JsonPipe} from 'angular2/core';
+import {JsonPipe, Component} from 'angular2/core';
 
 export function main() {
   describe("JsonPipe", () => {
@@ -22,7 +23,6 @@ export function main() {
     var inceptionObj;
     var inceptionObjString;
     var pipe;
-    var collection: number[];
 
     function normalize(obj: string): string { return StringWrapper.replace(obj, regNewLine, ''); }
 
@@ -33,7 +33,6 @@ export function main() {
 
 
       pipe = new JsonPipe();
-      collection = [];
     });
 
     describe("transform", () => {
@@ -51,26 +50,29 @@ export function main() {
         var dream2 = normalize(Json.stringify(inceptionObj));
         expect(dream1).toEqual(dream2);
       });
+    });
 
-      it("should return same ref when nothing has changed since the last call", () => {
-        expect(pipe.transform(inceptionObj)).toEqual(inceptionObjString);
-        expect(pipe.transform(inceptionObj)).toEqual(inceptionObjString);
-      });
+    describe('integration', () => {
+      it('should work with mutable objects',
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+           tcb.createAsync(TestComp).then((rootTC) => {
+             let mutable: number[] = [1];
+             rootTC.debugElement.componentInstance.data = mutable;
+             rootTC.detectChanges();
+             expect(rootTC.debugElement.nativeElement).toHaveText("[\n  1\n]");
 
+             mutable.push(2);
+             rootTC.detectChanges();
+             expect(rootTC.debugElement.nativeElement).toHaveText("[\n  1,\n  2\n]");
 
-      it("should return a new value when something changed but the ref hasn't", () => {
-        var stringCollection = '[]';
-        var stringCollectionWith1 = '[\n' +
-                                    '  1' +
-                                    '\n]';
-
-        expect(pipe.transform(collection)).toEqual(stringCollection);
-
-        collection.push(1);
-
-        expect(pipe.transform(collection)).toEqual(stringCollectionWith1);
-      });
-
+             async.done();
+           });
+         }));
     });
   });
 }
+
+@Component({selector: 'test-comp', template: '{{data | json}}', pipes: [JsonPipe]})
+class TestComp {
+  data: any;
+}

modules/angular2/test/core/pipes/slice_pipe_spec.ts

@@ -0,0 +1,114 @@
+import {
+  ddescribe,
+  describe,
+  it,
+  iit,
+  xit,
+  expect,
+  beforeEach,
+  afterEach,
+  browserDetection,
+  inject,
+  TestComponentBuilder,
+  AsyncTestCompleter
+} from 'angular2/testing_internal';
+
+import {SlicePipe, Component} from 'angular2/core';
+
+export function main() {
+  describe("SlicePipe", () => {
+    var list: number[];
+    var str;
+    var pipe;
+
+    beforeEach(() => {
+      list = [1, 2, 3, 4, 5];
+      str = 'tuvwxyz';
+      pipe = new SlicePipe();
+    });
+
+    describe("supports", () => {
+      it("should support strings", () => { expect(pipe.supports(str)).toBe(true); });
+      it("should support lists", () => { expect(pipe.supports(list)).toBe(true); });
+
+      it("should not support other objects", () => {
+        expect(pipe.supports(new Object())).toBe(false);
+        expect(pipe.supports(null)).toBe(false);
+      });
+    });
+
+    describe("transform", () => {
+
+      it('should return all items after START index when START is positive and END is omitted',
+         () => {
+           expect(pipe.transform(list, [3])).toEqual([4, 5]);
+           expect(pipe.transform(str, [3])).toEqual('wxyz');
+         });
+
+      it('should return last START items when START is negative and END is omitted', () => {
+        expect(pipe.transform(list, [-3])).toEqual([3, 4, 5]);
+        expect(pipe.transform(str, [-3])).toEqual('xyz');
+      });
+
+      it('should return all items between START and END index when START and END are positive',
+         () => {
+           expect(pipe.transform(list, [1, 3])).toEqual([2, 3]);
+           expect(pipe.transform(str, [1, 3])).toEqual('uv');
+         });
+
+      it('should return all items between START and END from the end when START and END are negative',
+         () => {
+           expect(pipe.transform(list, [-4, -2])).toEqual([2, 3]);
+           expect(pipe.transform(str, [-4, -2])).toEqual('wx');
+         });
+
+      it('should return an empty value if START is greater than END', () => {
+        expect(pipe.transform(list, [4, 2])).toEqual([]);
+        expect(pipe.transform(str, [4, 2])).toEqual('');
+      });
+
+      it('should return an empty value if START greater than input length', () => {
+        expect(pipe.transform(list, [99])).toEqual([]);
+        expect(pipe.transform(str, [99])).toEqual('');
+      });
+
+      // Makes Edge to disconnect when running the full unit test campaign
+      // TODO: remove when issue is solved: https://github.com/angular/angular/issues/4756
+      if (!browserDetection.isEdge) {
+        it('should return entire input if START is negative and greater than input length', () => {
+          expect(pipe.transform(list, [-99])).toEqual([1, 2, 3, 4, 5]);
+          expect(pipe.transform(str, [-99])).toEqual('tuvwxyz');
+        });
+
+        it('should not modify the input list', () => {
+          expect(pipe.transform(list, [2])).toEqual([3, 4, 5]);
+          expect(list).toEqual([1, 2, 3, 4, 5]);
+        });
+      }
+
+    });
+
+    describe('integration', () => {
+      it('should work with mutable arrays',
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+           tcb.createAsync(TestComp).then((rootTC) => {
+             let mutable: number[] = [1, 2];
+             rootTC.debugElement.componentInstance.data = mutable;
+             rootTC.detectChanges();
+             expect(rootTC.debugElement.nativeElement).toHaveText('2');
+
+             mutable.push(3);
+             rootTC.detectChanges();
+             expect(rootTC.debugElement.nativeElement).toHaveText('2,3');
+
+             async.done();
+           });
+         }));
+    });
+  });
+}
+
+@Component({selector: 'test-comp', template: '{{(data | slice:1).join(",") }}', pipes: [SlicePipe]})
+class TestComp {
+  data: any;
+}