Skip to content

Commit 359d452

Browse files
alexandrevryghemalexandrevryghem
committed
Merge remote-tracking branch 'upstream/main' into feature-process_polling
# Conflicts: # src/app/core/data/base/base-data.service.spec.ts
2 parents 86d3883 + 610062b commit 359d452

11 files changed

Lines changed: 668 additions & 145 deletions

‎src/app/core/data/base/base-data.service.spec.ts‎

Lines changed: 55 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -101,6 +101,7 @@ describe('BaseDataService', () => {
101101
remoteDataMocks = {
102102
RequestPending: new RemoteData(undefined, msToLive, timeStamp, RequestEntryState.RequestPending, undefined, undefined, undefined),
103103
ResponsePending: new RemoteData(undefined, msToLive, timeStamp, RequestEntryState.ResponsePending, undefined, undefined, undefined),
104+
ResponsePendingStale: new RemoteData(undefined, msToLive, timeStamp, RequestEntryState.ResponsePendingStale, undefined, undefined, undefined),
104105
Success: new RemoteData(timeStamp, msToLive, timeStamp, RequestEntryState.Success, undefined, payload, statusCodeSuccess),
105106
SuccessStale: new RemoteData(timeStamp, msToLive, timeStamp, RequestEntryState.SuccessStale, undefined, payload, statusCodeSuccess),
106107
Error: new RemoteData(timeStamp, msToLive, timeStamp, RequestEntryState.Error, errorMessage, undefined, statusCodeError),
@@ -109,6 +110,7 @@ describe('BaseDataService', () => {
109110
remoteDataPageMocks = {
110111
RequestPending: new RemoteData(undefined, msToLive, timeStamp, RequestEntryState.RequestPending, undefined, undefined, undefined),
111112
ResponsePending: new RemoteData(undefined, msToLive, timeStamp, RequestEntryState.ResponsePending, undefined, undefined, undefined),
113+
ResponsePendingStale: new RemoteData(undefined, msToLive, timeStamp, RequestEntryState.ResponsePendingStale, undefined, undefined, undefined),
112114
Success: new RemoteData(timeStamp, msToLive, timeStamp, RequestEntryState.Success, undefined, createPaginatedList([payload]), statusCodeSuccess),
113115
SuccessStale: new RemoteData(timeStamp, msToLive, timeStamp, RequestEntryState.SuccessStale, undefined, createPaginatedList([payload]), statusCodeSuccess),
114116
Error: new RemoteData(timeStamp, msToLive, timeStamp, RequestEntryState.Error, errorMessage, undefined, statusCodeError),
@@ -317,19 +319,21 @@ describe('BaseDataService', () => {
317319

318320
it(`should not emit a cached stale RemoteData, but only start emitting after the state first changes to RequestPending`, () => {
319321
testScheduler.run(({ cold, expectObservable }) => {
320-
spyOn(rdbService, 'buildSingle').and.returnValue(cold('a-b-c-d-e', {
321-
a: remoteDataMocks.SuccessStale,
322-
b: remoteDataMocks.RequestPending,
323-
c: remoteDataMocks.ResponsePending,
324-
d: remoteDataMocks.Success,
325-
e: remoteDataMocks.SuccessStale,
322+
spyOn(rdbService, 'buildSingle').and.returnValue(cold('a-b-c-d-e-f-g', {
323+
a: remoteDataMocks.ResponsePendingStale,
324+
b: remoteDataMocks.SuccessStale,
325+
c: remoteDataMocks.ErrorStale,
326+
d: remoteDataMocks.RequestPending,
327+
e: remoteDataMocks.ResponsePending,
328+
f: remoteDataMocks.Success,
329+
g: remoteDataMocks.SuccessStale,
326330
}));
327-
const expected = '--b-c-d-e';
331+
const expected = '------d-e-f-g';
328332
const values = {
329-
b: remoteDataMocks.RequestPending,
330-
c: remoteDataMocks.ResponsePending,
331-
d: remoteDataMocks.Success,
332-
e: remoteDataMocks.SuccessStale,
333+
d: remoteDataMocks.RequestPending,
334+
e: remoteDataMocks.ResponsePending,
335+
f: remoteDataMocks.Success,
336+
g: remoteDataMocks.SuccessStale,
333337
};
334338

335339
expectObservable(service.findByHref(selfLink, true, true, ...linksToFollow)).toBe(expected, values);
@@ -368,19 +372,21 @@ describe('BaseDataService', () => {
368372

369373
it(`should not emit a cached stale RemoteData, but only start emitting after the state first changes to RequestPending`, () => {
370374
testScheduler.run(({ cold, expectObservable }) => {
371-
spyOn(rdbService, 'buildSingle').and.returnValue(cold('a-b-c-d-e', {
372-
a: remoteDataMocks.SuccessStale,
373-
b: remoteDataMocks.RequestPending,
374-
c: remoteDataMocks.ResponsePending,
375-
d: remoteDataMocks.Success,
376-
e: remoteDataMocks.SuccessStale,
375+
spyOn(rdbService, 'buildSingle').and.returnValue(cold('a-b-c-d-e-f-g', {
376+
a: remoteDataMocks.ResponsePendingStale,
377+
b: remoteDataMocks.SuccessStale,
378+
c: remoteDataMocks.ErrorStale,
379+
d: remoteDataMocks.RequestPending,
380+
e: remoteDataMocks.ResponsePending,
381+
f: remoteDataMocks.Success,
382+
g: remoteDataMocks.SuccessStale,
377383
}));
378-
const expected = '--b-c-d-e';
384+
const expected = '------d-e-f-g';
379385
const values = {
380-
b: remoteDataMocks.RequestPending,
381-
c: remoteDataMocks.ResponsePending,
382-
d: remoteDataMocks.Success,
383-
e: remoteDataMocks.SuccessStale,
386+
d: remoteDataMocks.RequestPending,
387+
e: remoteDataMocks.ResponsePending,
388+
f: remoteDataMocks.Success,
389+
g: remoteDataMocks.SuccessStale,
384390
};
385391

386392
expectObservable(service.findByHref(selfLink, false, true, ...linksToFollow)).toBe(expected, values);
@@ -522,19 +528,21 @@ describe('BaseDataService', () => {
522528

523529
it(`should not emit a cached stale RemoteData, but only start emitting after the state first changes to RequestPending`, () => {
524530
testScheduler.run(({ cold, expectObservable }) => {
525-
spyOn(rdbService, 'buildList').and.returnValue(cold('a-b-c-d-e', {
526-
a: remoteDataPageMocks.SuccessStale,
527-
b: remoteDataPageMocks.RequestPending,
528-
c: remoteDataPageMocks.ResponsePending,
529-
d: remoteDataPageMocks.Success,
530-
e: remoteDataPageMocks.SuccessStale,
531+
spyOn(rdbService, 'buildList').and.returnValue(cold('a-b-c-d-e-f-g', {
532+
a: remoteDataPageMocks.ResponsePendingStale,
533+
b: remoteDataPageMocks.SuccessStale,
534+
c: remoteDataPageMocks.ErrorStale,
535+
d: remoteDataPageMocks.RequestPending,
536+
e: remoteDataPageMocks.ResponsePending,
537+
f: remoteDataPageMocks.Success,
538+
g: remoteDataPageMocks.SuccessStale,
531539
}));
532-
const expected = '--b-c-d-e';
540+
const expected = '------d-e-f-g';
533541
const values = {
534-
b: remoteDataPageMocks.RequestPending,
535-
c: remoteDataPageMocks.ResponsePending,
536-
d: remoteDataPageMocks.Success,
537-
e: remoteDataPageMocks.SuccessStale,
542+
d: remoteDataPageMocks.RequestPending,
543+
e: remoteDataPageMocks.ResponsePending,
544+
f: remoteDataPageMocks.Success,
545+
g: remoteDataPageMocks.SuccessStale,
538546
};
539547

540548
expectObservable(service.findListByHref(selfLink, findListOptions, true, true, ...linksToFollow)).toBe(expected, values);
@@ -573,21 +581,24 @@ describe('BaseDataService', () => {
573581

574582
it(`should not emit a cached stale RemoteData, but only start emitting after the state first changes to RequestPending`, () => {
575583
testScheduler.run(({ cold, expectObservable }) => {
576-
spyOn(rdbService, 'buildList').and.returnValue(cold('a-b-c-d-e', {
577-
a: remoteDataPageMocks.SuccessStale,
578-
b: remoteDataPageMocks.RequestPending,
579-
c: remoteDataPageMocks.ResponsePending,
580-
d: remoteDataPageMocks.Success,
581-
e: remoteDataPageMocks.SuccessStale,
584+
spyOn(rdbService, 'buildList').and.returnValue(cold('a-b-c-d-e-f-g', {
585+
a: remoteDataPageMocks.ResponsePendingStale,
586+
b: remoteDataPageMocks.SuccessStale,
587+
c: remoteDataPageMocks.ErrorStale,
588+
d: remoteDataPageMocks.RequestPending,
589+
e: remoteDataPageMocks.ResponsePending,
590+
f: remoteDataPageMocks.Success,
591+
g: remoteDataPageMocks.SuccessStale,
582592
}));
583-
const expected = '--b-c-d-e';
593+
const expected = '------d-e-f-g';
584594
const values = {
585-
b: remoteDataPageMocks.RequestPending,
586-
c: remoteDataPageMocks.ResponsePending,
587-
d: remoteDataPageMocks.Success,
588-
e: remoteDataPageMocks.SuccessStale,
595+
d: remoteDataPageMocks.RequestPending,
596+
e: remoteDataPageMocks.ResponsePending,
597+
f: remoteDataPageMocks.Success,
598+
g: remoteDataPageMocks.SuccessStale,
589599
};
590600

601+
591602
expectObservable(service.findListByHref(selfLink, findListOptions, false, true, ...linksToFollow)).toBe(expected, values);
592603
});
593604
});

‎src/app/core/data/base/base-data.service.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -274,7 +274,7 @@ export class BaseDataService<T extends CacheableObject> implements HALDataServic
274274
// call it isn't immediately returned, but we wait until the remote data for the new request
275275
// is created. If useCachedVersionIfAvailable is false it also ensures you don't get a
276276
// cached completed object
277-
skipWhile((rd: RemoteData<T>) => useCachedVersionIfAvailable ? rd.isStale : rd.hasCompleted),
277+
skipWhile((rd: RemoteData<T>) => rd.isStale || (!useCachedVersionIfAvailable && rd.hasCompleted)),
278278
this.reRequestStaleRemoteData(reRequestOnStale, () =>
279279
this.findByHref(href$, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow)),
280280
);
@@ -324,7 +324,7 @@ export class BaseDataService<T extends CacheableObject> implements HALDataServic
324324
// call it isn't immediately returned, but we wait until the remote data for the new request
325325
// is created. If useCachedVersionIfAvailable is false it also ensures you don't get a
326326
// cached completed object
327-
skipWhile((rd: RemoteData<PaginatedList<T>>) => useCachedVersionIfAvailable ? rd.isStale : rd.hasCompleted),
327+
skipWhile((rd: RemoteData<PaginatedList<T>>) => rd.isStale || (!useCachedVersionIfAvailable && rd.hasCompleted)),
328328
this.reRequestStaleRemoteData(reRequestOnStale, () =>
329329
this.findListByHref(href$, options, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow)),
330330
);

‎src/app/core/data/request-entry-state.model.spec.ts‎

Lines changed: 186 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,186 @@
1+
import {
2+
isRequestPending,
3+
isError,
4+
isSuccess,
5+
isErrorStale,
6+
isSuccessStale,
7+
isResponsePending,
8+
isResponsePendingStale,
9+
isLoading,
10+
isStale,
11+
hasFailed,
12+
hasSucceeded,
13+
hasCompleted,
14+
RequestEntryState
15+
} from './request-entry-state.model';
16+
17+
describe(`isRequestPending`, () => {
18+
it(`should only return true if the given state is RequestPending`, () => {
19+
expect(isRequestPending(RequestEntryState.RequestPending)).toBeTrue();
20+
21+
expect(isRequestPending(RequestEntryState.ResponsePending)).toBeFalse();
22+
expect(isRequestPending(RequestEntryState.Error)).toBeFalse();
23+
expect(isRequestPending(RequestEntryState.Success)).toBeFalse();
24+
expect(isRequestPending(RequestEntryState.ResponsePendingStale)).toBeFalse();
25+
expect(isRequestPending(RequestEntryState.ErrorStale)).toBeFalse();
26+
expect(isRequestPending(RequestEntryState.SuccessStale)).toBeFalse();
27+
});
28+
});
29+
30+
describe(`isError`, () => {
31+
it(`should only return true if the given state is Error`, () => {
32+
expect(isError(RequestEntryState.Error)).toBeTrue();
33+
34+
expect(isError(RequestEntryState.RequestPending)).toBeFalse();
35+
expect(isError(RequestEntryState.ResponsePending)).toBeFalse();
36+
expect(isError(RequestEntryState.Success)).toBeFalse();
37+
expect(isError(RequestEntryState.ResponsePendingStale)).toBeFalse();
38+
expect(isError(RequestEntryState.ErrorStale)).toBeFalse();
39+
expect(isError(RequestEntryState.SuccessStale)).toBeFalse();
40+
});
41+
});
42+
43+
describe(`isSuccess`, () => {
44+
it(`should only return true if the given state is Success`, () => {
45+
expect(isSuccess(RequestEntryState.Success)).toBeTrue();
46+
47+
expect(isSuccess(RequestEntryState.RequestPending)).toBeFalse();
48+
expect(isSuccess(RequestEntryState.ResponsePending)).toBeFalse();
49+
expect(isSuccess(RequestEntryState.Error)).toBeFalse();
50+
expect(isSuccess(RequestEntryState.ResponsePendingStale)).toBeFalse();
51+
expect(isSuccess(RequestEntryState.ErrorStale)).toBeFalse();
52+
expect(isSuccess(RequestEntryState.SuccessStale)).toBeFalse();
53+
});
54+
});
55+
56+
describe(`isErrorStale`, () => {
57+
it(`should only return true if the given state is ErrorStale`, () => {
58+
expect(isErrorStale(RequestEntryState.ErrorStale)).toBeTrue();
59+
60+
expect(isErrorStale(RequestEntryState.RequestPending)).toBeFalse();
61+
expect(isErrorStale(RequestEntryState.ResponsePending)).toBeFalse();
62+
expect(isErrorStale(RequestEntryState.Error)).toBeFalse();
63+
expect(isErrorStale(RequestEntryState.Success)).toBeFalse();
64+
expect(isErrorStale(RequestEntryState.ResponsePendingStale)).toBeFalse();
65+
expect(isErrorStale(RequestEntryState.SuccessStale)).toBeFalse();
66+
});
67+
});
68+
69+
describe(`isSuccessStale`, () => {
70+
it(`should only return true if the given state is SuccessStale`, () => {
71+
expect(isSuccessStale(RequestEntryState.SuccessStale)).toBeTrue();
72+
73+
expect(isSuccessStale(RequestEntryState.RequestPending)).toBeFalse();
74+
expect(isSuccessStale(RequestEntryState.ResponsePending)).toBeFalse();
75+
expect(isSuccessStale(RequestEntryState.Error)).toBeFalse();
76+
expect(isSuccessStale(RequestEntryState.Success)).toBeFalse();
77+
expect(isSuccessStale(RequestEntryState.ResponsePendingStale)).toBeFalse();
78+
expect(isSuccessStale(RequestEntryState.ErrorStale)).toBeFalse();
79+
});
80+
});
81+
82+
describe(`isResponsePending`, () => {
83+
it(`should only return true if the given state is ResponsePending`, () => {
84+
expect(isResponsePending(RequestEntryState.ResponsePending)).toBeTrue();
85+
86+
expect(isResponsePending(RequestEntryState.RequestPending)).toBeFalse();
87+
expect(isResponsePending(RequestEntryState.Error)).toBeFalse();
88+
expect(isResponsePending(RequestEntryState.Success)).toBeFalse();
89+
expect(isResponsePending(RequestEntryState.ResponsePendingStale)).toBeFalse();
90+
expect(isResponsePending(RequestEntryState.ErrorStale)).toBeFalse();
91+
expect(isResponsePending(RequestEntryState.SuccessStale)).toBeFalse();
92+
});
93+
});
94+
95+
describe(`isResponsePendingStale`, () => {
96+
it(`should only return true if the given state is requestPending`, () => {
97+
expect(isResponsePendingStale(RequestEntryState.ResponsePendingStale)).toBeTrue();
98+
99+
expect(isResponsePendingStale(RequestEntryState.RequestPending)).toBeFalse();
100+
expect(isResponsePendingStale(RequestEntryState.ResponsePending)).toBeFalse();
101+
expect(isResponsePendingStale(RequestEntryState.Error)).toBeFalse();
102+
expect(isResponsePendingStale(RequestEntryState.Success)).toBeFalse();
103+
expect(isResponsePendingStale(RequestEntryState.ErrorStale)).toBeFalse();
104+
expect(isResponsePendingStale(RequestEntryState.SuccessStale)).toBeFalse();
105+
});
106+
});
107+
108+
describe(`isLoading`, () => {
109+
it(`should only return true if the given state is RequestPending, ResponsePending or ResponsePendingStale`, () => {
110+
expect(isLoading(RequestEntryState.RequestPending)).toBeTrue();
111+
expect(isLoading(RequestEntryState.ResponsePending)).toBeTrue();
112+
expect(isLoading(RequestEntryState.ResponsePendingStale)).toBeTrue();
113+
114+
expect(isLoading(RequestEntryState.Error)).toBeFalse();
115+
expect(isLoading(RequestEntryState.Success)).toBeFalse();
116+
expect(isLoading(RequestEntryState.ErrorStale)).toBeFalse();
117+
expect(isLoading(RequestEntryState.SuccessStale)).toBeFalse();
118+
});
119+
});
120+
121+
describe(`hasFailed`, () => {
122+
describe(`when the state is loading`, () => {
123+
it(`should return undefined`, () => {
124+
expect(hasFailed(RequestEntryState.RequestPending)).toBeUndefined();
125+
expect(hasFailed(RequestEntryState.ResponsePending)).toBeUndefined();
126+
expect(hasFailed(RequestEntryState.ResponsePendingStale)).toBeUndefined();
127+
});
128+
});
129+
130+
describe(`when the state has completed`, () => {
131+
it(`should only return true if the given state is Error or ErrorStale`, () => {
132+
expect(hasFailed(RequestEntryState.Error)).toBeTrue();
133+
expect(hasFailed(RequestEntryState.ErrorStale)).toBeTrue();
134+
135+
expect(hasFailed(RequestEntryState.Success)).toBeFalse();
136+
expect(hasFailed(RequestEntryState.SuccessStale)).toBeFalse();
137+
});
138+
});
139+
});
140+
141+
describe(`hasSucceeded`, () => {
142+
describe(`when the state is loading`, () => {
143+
it(`should return undefined`, () => {
144+
expect(hasSucceeded(RequestEntryState.RequestPending)).toBeUndefined();
145+
expect(hasSucceeded(RequestEntryState.ResponsePending)).toBeUndefined();
146+
expect(hasSucceeded(RequestEntryState.ResponsePendingStale)).toBeUndefined();
147+
});
148+
});
149+
150+
describe(`when the state has completed`, () => {
151+
it(`should only return true if the given state is Error or ErrorStale`, () => {
152+
expect(hasSucceeded(RequestEntryState.Success)).toBeTrue();
153+
expect(hasSucceeded(RequestEntryState.SuccessStale)).toBeTrue();
154+
155+
expect(hasSucceeded(RequestEntryState.Error)).toBeFalse();
156+
expect(hasSucceeded(RequestEntryState.ErrorStale)).toBeFalse();
157+
});
158+
});
159+
});
160+
161+
162+
describe(`hasCompleted`, () => {
163+
it(`should only return true if the given state is Error, Success, ErrorStale or SuccessStale`, () => {
164+
expect(hasCompleted(RequestEntryState.Error)).toBeTrue();
165+
expect(hasCompleted(RequestEntryState.Success)).toBeTrue();
166+
expect(hasCompleted(RequestEntryState.ErrorStale)).toBeTrue();
167+
expect(hasCompleted(RequestEntryState.SuccessStale)).toBeTrue();
168+
169+
expect(hasCompleted(RequestEntryState.RequestPending)).toBeFalse();
170+
expect(hasCompleted(RequestEntryState.ResponsePending)).toBeFalse();
171+
expect(hasCompleted(RequestEntryState.ResponsePendingStale)).toBeFalse();
172+
});
173+
});
174+
175+
describe(`isStale`, () => {
176+
it(`should only return true if the given state is ResponsePendingStale, SuccessStale or ErrorStale`, () => {
177+
expect(isStale(RequestEntryState.ResponsePendingStale)).toBeTrue();
178+
expect(isStale(RequestEntryState.SuccessStale)).toBeTrue();
179+
expect(isStale(RequestEntryState.ErrorStale)).toBeTrue();
180+
181+
expect(isStale(RequestEntryState.RequestPending)).toBeFalse();
182+
expect(isStale(RequestEntryState.ResponsePending)).toBeFalse();
183+
expect(isStale(RequestEntryState.Error)).toBeFalse();
184+
expect(isStale(RequestEntryState.Success)).toBeFalse();
185+
});
186+
});

0 commit comments

Comments
 (0)