1 | import { Observable } from 'rxjs';
|
2 |
|
3 | import { mock, IMockedRequest } from './mockAsync';
|
4 | import { rlFakeAsync } from './fakeAsync';
|
5 |
|
6 | interface ITestType {
|
7 | value: number;
|
8 | }
|
9 |
|
10 | interface ITestDataService {
|
11 | request1: IMockedRequest<ITestType>;
|
12 | request2: IMockedRequest<ITestType>;
|
13 | }
|
14 |
|
15 | describe('mockAsync', () => {
|
16 | it('should create a request that resolves when flushed', rlFakeAsync(() => {
|
17 | let mockedObservable: IMockedRequest<ITestType> = mock.request({ value: 10 });
|
18 | mockedObservable()
|
19 | .subscribe((result: ITestType) => {
|
20 | expect(result.value).to.equal(10);
|
21 | });
|
22 |
|
23 | mockedObservable.flush();
|
24 | }));
|
25 |
|
26 | it('should create a request that resolves with dynamic content when flushed', rlFakeAsync(() => {
|
27 | let mockedObservable: IMockedRequest<ITestType> = mock.request((value1: number, value2: number) => {
|
28 | return { value: value1 + value2 };
|
29 | });
|
30 |
|
31 | mockedObservable(5, 3)
|
32 | .subscribe((result: ITestType) => {
|
33 | expect(result.value).to.equal(8);
|
34 | });
|
35 |
|
36 | mockedObservable.flush();
|
37 | }));
|
38 |
|
39 | it('should create a request that is rejected', rlFakeAsync(() => {
|
40 | let mockedObservable: IMockedRequest<ITestType> = mock.rejectedRequest<ITestType>(new Error('an error'));
|
41 |
|
42 | mockedObservable()
|
43 | .subscribe(() => {
|
44 | assert.fail(null, null, 'Request should be rejected, not resolved');
|
45 | }, (error: Error) => {
|
46 | expect(error.message).to.equal('an error');
|
47 | });
|
48 |
|
49 | mockedObservable.flush();
|
50 | }));
|
51 |
|
52 | it('should create a request and set it to be rejected', rlFakeAsync(() => {
|
53 | let mockedObservable: IMockedRequest<ITestType> = mock.request<ITestType>({ value: 3 });
|
54 | mockedObservable.reject(new Error('error message'));
|
55 |
|
56 | mockedObservable()
|
57 | .subscribe(() => {
|
58 | assert.fail(null, null, 'Observable should be rejected, not resolved');
|
59 | }, (error: Error) => {
|
60 | expect(error.message).to.equal('error message');
|
61 | });
|
62 |
|
63 | mockedObservable.flush();
|
64 | }));
|
65 |
|
66 | it('should be able to reuse mocked requests', rlFakeAsync(() => {
|
67 | let mockedObservable: IMockedRequest<ITestType> = mock.request<ITestType>({ value: 3 }, true);
|
68 |
|
69 | mockedObservable()
|
70 | .subscribe((result1: ITestType) => {
|
71 | expect(result1.value).to.equal(3);
|
72 |
|
73 | mockedObservable()
|
74 | .subscribe((result2: ITestType) => {
|
75 | expect(result2.value).to.equal(3);
|
76 | });
|
77 |
|
78 | mockedObservable.flush();
|
79 | });
|
80 |
|
81 | mockedObservable.flush();
|
82 | }));
|
83 |
|
84 | it('should allow unique parameters with successive calls', rlFakeAsync(() => {
|
85 | let mockedObservable: IMockedRequest<ITestType> = mock.request((value1: number, value2: number) => {
|
86 | return { value: value1 + value2 };
|
87 | }, true);
|
88 |
|
89 | mockedObservable(5, 3)
|
90 | .subscribe((result: ITestType) => {
|
91 | expect(result.value).to.equal(8);
|
92 |
|
93 | mockedObservable(8, 2)
|
94 | .subscribe((result: ITestType) => {
|
95 | expect(result.value).to.equal(10);
|
96 | });
|
97 |
|
98 | mockedObservable.flush();
|
99 | });
|
100 |
|
101 | mockedObservable.flush();
|
102 | }));
|
103 |
|
104 | it('should reuse a pending request when sharing', (): void => {
|
105 | let mockedObservable: IMockedRequest<ITestType> = mock.request({ value: 3 }, true);
|
106 | expect(mockedObservable()).to.equal(mockedObservable());
|
107 | });
|
108 |
|
109 | it('should not reuse a pending request by default or not sharing', (): void => {
|
110 | let mockedObservable: IMockedRequest<ITestType> = mock.request({ value: 3 });
|
111 | expect(mockedObservable()).to.not.equal(mockedObservable());
|
112 |
|
113 | mockedObservable = mock.request({ value: 3 }, false);
|
114 | expect(mockedObservable()).to.not.equal(mockedObservable());
|
115 | });
|
116 |
|
117 | it('should flush all requests on an unshared mock request', rlFakeAsync((): void => {
|
118 | let mockedObservable: IMockedRequest<number> = mock.request(result => result);
|
119 | Observable.forkJoin<number[]>([
|
120 | mockedObservable(5),
|
121 | mockedObservable(10),
|
122 | ]).subscribe(([result1, result2]: number[]): void => {
|
123 | expect(result1).to.equal(5);
|
124 | expect(result2).to.equal(10);
|
125 | });
|
126 |
|
127 | mockedObservable.flush();
|
128 | }));
|
129 |
|
130 | it('should spy on the request function', (): void => {
|
131 | let mockedObservable: IMockedRequest<ITestType> = mock.request({ value: 3 });
|
132 | mockedObservable(6);
|
133 | sinon.assert.calledOnce(mockedObservable);
|
134 | sinon.assert.calledWith(mockedObservable, 6);
|
135 | });
|
136 |
|
137 | it('should flush all request on an object', rlFakeAsync((): void => {
|
138 | let service: ITestDataService = {
|
139 | request1: mock.request({ value: 3 }),
|
140 | request2: mock.request({ value: 4 }),
|
141 | };
|
142 | Observable.forkJoin<ITestType[]>([
|
143 | service.request1(),
|
144 | service.request2(),
|
145 | ]).subscribe(([result1, result2]: ITestType[]): void => {
|
146 | expect(result1.value).to.equal(3);
|
147 | expect(result2.value).to.equal(4);
|
148 | });
|
149 | mock.flushAll(service);
|
150 | }));
|
151 |
|
152 | it('should work with Observable.from and Observable.forkJoin', rlFakeAsync((): void => {
|
153 | const mockedObservables: IMockedRequest<number>[] = [
|
154 | mock.request(5),
|
155 | mock.request(10),
|
156 | ];
|
157 |
|
158 | const whens: Observable<number>[] = mockedObservables.map((mocked: IMockedRequest<number>) => Observable.from(mocked()));
|
159 |
|
160 | Observable.forkJoin<number[]>(whens).subscribe(([result1, result2]: number[]): void => {
|
161 | expect(result1).to.equal(5);
|
162 | expect(result2).to.equal(10);
|
163 | });
|
164 |
|
165 | mock.flushAll(mockedObservables);
|
166 | }));
|
167 |
|
168 | it('should work with toPromise', rlFakeAsync((): void => {
|
169 | let mockedObservable: IMockedRequest<ITestType> = mock.request({ value: 10 });
|
170 | mockedObservable()
|
171 | .toPromise()
|
172 | .then((result: ITestType) => {
|
173 | expect(result.value).to.equal(10);
|
174 | });
|
175 |
|
176 | mockedObservable.flush();
|
177 | }));
|
178 | });
|