Repository navigation
Expand file tree
/
Copy pathtest_lib_spec.ts
More file actions
140 lines (112 loc) · 4.19 KB
/
Copy pathtest_lib_spec.ts
File metadata and controls
140 lines (112 loc) · 4.19 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
import {
describe,
it,
iit,
ddescribe,
expect,
tick,
SpyObject,
beforeEach,
proxy,
containsRegexp
} from 'angular2/test_lib';
import {MapWrapper} from 'angular2/src/facade/collection';
import {IMPLEMENTS, RegExpWrapper} from 'angular2/src/facade/lang';
class TestObj {
prop;
constructor(prop) { this.prop = prop; }
someFunc(): number { return -1; }
someComplexFunc(a) { return a; }
}
@proxy
@IMPLEMENTS(TestObj)
class SpyTestObj extends SpyObject {
constructor() { super(TestObj); }
noSuchMethod(m) { return super.noSuchMethod(m) }
}
export function main() {
describe('test_lib', () => {
describe('equality', () => {
it('should structurally compare objects', () => {
var expected = new TestObj(new TestObj({'one': [1, 2]}));
var actual = new TestObj(new TestObj({'one': [1, 2]}));
var falseActual = new TestObj(new TestObj({'one': [1, 3]}));
expect(actual).toEqual(expected);
expect(falseActual).not.toEqual(expected);
});
});
describe('toEqual for Maps', () => {
it('should detect equality for same reference', () => {
var m1 = MapWrapper.createFromStringMap({'a': 1});
expect(m1).toEqual(m1);
});
it('should detect equality for same content', () => {
expect(MapWrapper.createFromStringMap({'a': 1}))
.toEqual(MapWrapper.createFromStringMap({'a': 1}));
});
it('should detect missing entries', () => {
expect(MapWrapper.createFromStringMap({'a': 1}))
.not.toEqual(MapWrapper.createFromStringMap({}));
});
it('should detect different values', () => {
expect(MapWrapper.createFromStringMap({'a': 1}))
.not.toEqual(MapWrapper.createFromStringMap({'a': 2}));
});
it('should detect additional entries', () => {
expect(MapWrapper.createFromStringMap({'a': 1}))
.not.toEqual(MapWrapper.createFromStringMap({'a': 1, 'b': 1}));
});
});
describe("spy objects", () => {
var spyObj;
beforeEach(() => { spyObj = <any>new SpyTestObj(); });
it("should pass the runtime check", () => {
var t: TestObj = spyObj;
expect(t).toBeDefined();
});
it("should return a new spy func with no calls",
() => { expect(spyObj.spy("someFunc")).not.toHaveBeenCalled(); });
it("should record function calls", () => {
spyObj.spy("someFunc").andCallFake((a, b) => {return a + b});
expect(spyObj.someFunc(1, 2)).toEqual(3);
expect(spyObj.spy("someFunc")).toHaveBeenCalledWith(1, 2);
});
it("should match multiple function calls", () => {
spyObj.someFunc(1, 2);
spyObj.someFunc(3, 4);
expect(spyObj.spy("someFunc")).toHaveBeenCalledWith(1, 2);
expect(spyObj.spy("someFunc")).toHaveBeenCalledWith(3, 4);
});
it("should match null arguments", () => {
spyObj.someFunc(null, "hello");
expect(spyObj.spy("someFunc")).toHaveBeenCalledWith(null, "hello");
});
it("should match using deep equality", () => {
spyObj.someComplexFunc([1]);
expect(spyObj.spy("someComplexFunc")).toHaveBeenCalledWith([1]);
});
it("should support stubs", () => {
var s = SpyObject.stub({"a": 1}, {"b": 2});
expect(s.a()).toEqual(1);
expect(s.b()).toEqual(2);
});
it('should create spys for all methods',
() => { expect(() => spyObj.someFunc()).not.toThrow(); });
it('should create a default spy that does not fail for numbers', () => {
// Need to return null instead of undefined so that rtts assert does
// not fail...
expect(spyObj.someFunc()).toBe(null);
});
});
describe('containsRegexp', () => {
it('should allow any prefix and suffix', () => {
expect(RegExpWrapper.firstMatch(containsRegexp('b'), 'abc')).toBeTruthy();
expect(RegExpWrapper.firstMatch(containsRegexp('b'), 'adc')).toBeFalsy();
});
it('should match various special characters', () => {
expect(RegExpWrapper.firstMatch(containsRegexp('a.b'), 'a.b')).toBeTruthy();
expect(RegExpWrapper.firstMatch(containsRegexp('axb'), 'a.b')).toBeFalsy();
});
});
});
}