Commits

Art Lowel authored d75b158ee1a Merge
Merge remote-tracking branch 'contributions/fix-api-undefined-issue-7.6' into w2p-113560_edit-item-add-relationships-one-by-one
No tags

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

Modified
88 88
89 89 const timeStamp = new Date().getTime();
90 90 const msToLive = 15 * 60 * 1000;
91 91 const payload = { foo: 'bar' };
92 92 const statusCodeSuccess = 200;
93 93 const statusCodeError = 404;
94 94 const errorMessage = 'not found';
95 95 remoteDataMocks = {
96 96 RequestPending: new RemoteData(undefined, msToLive, timeStamp, RequestEntryState.RequestPending, undefined, undefined, undefined),
97 97 ResponsePending: new RemoteData(undefined, msToLive, timeStamp, RequestEntryState.ResponsePending, undefined, undefined, undefined),
98 + ResponsePendingStale: new RemoteData(undefined, msToLive, timeStamp, RequestEntryState.ResponsePendingStale, undefined, undefined, undefined),
98 99 Success: new RemoteData(timeStamp, msToLive, timeStamp, RequestEntryState.Success, undefined, payload, statusCodeSuccess),
99 100 SuccessStale: new RemoteData(timeStamp, msToLive, timeStamp, RequestEntryState.SuccessStale, undefined, payload, statusCodeSuccess),
100 101 Error: new RemoteData(timeStamp, msToLive, timeStamp, RequestEntryState.Error, errorMessage, undefined, statusCodeError),
101 102 ErrorStale: new RemoteData(timeStamp, msToLive, timeStamp, RequestEntryState.ErrorStale, errorMessage, undefined, statusCodeError),
102 103 };
103 104
104 105 return new TestService(
105 106 requestService,
106 107 rdbService,
107 108 objectCache,
296 297 d: remoteDataMocks.Success,
297 298 e: remoteDataMocks.SuccessStale,
298 299 };
299 300
300 301 expectObservable(service.findByHref(selfLink, true, true, ...linksToFollow)).toBe(expected, values);
301 302 });
302 303 });
303 304
304 305 it(`should not emit a cached stale RemoteData, but only start emitting after the state first changes to RequestPending`, () => {
305 306 testScheduler.run(({ cold, expectObservable }) => {
306 - spyOn(rdbService, 'buildSingle').and.returnValue(cold('a-b-c-d-e', {
307 - a: remoteDataMocks.SuccessStale,
308 - b: remoteDataMocks.RequestPending,
309 - c: remoteDataMocks.ResponsePending,
310 - d: remoteDataMocks.Success,
311 - e: remoteDataMocks.SuccessStale,
307 + spyOn(rdbService, 'buildSingle').and.returnValue(cold('a-b-c-d-e-f-g', {
308 + a: remoteDataMocks.ResponsePendingStale,
309 + b: remoteDataMocks.SuccessStale,
310 + c: remoteDataMocks.ErrorStale,
311 + d: remoteDataMocks.RequestPending,
312 + e: remoteDataMocks.ResponsePending,
313 + f: remoteDataMocks.Success,
314 + g: remoteDataMocks.SuccessStale,
312 315 }));
313 - const expected = '--b-c-d-e';
316 + const expected = '------d-e-f-g';
314 317 const values = {
315 - b: remoteDataMocks.RequestPending,
316 - c: remoteDataMocks.ResponsePending,
317 - d: remoteDataMocks.Success,
318 - e: remoteDataMocks.SuccessStale,
318 + d: remoteDataMocks.RequestPending,
319 + e: remoteDataMocks.ResponsePending,
320 + f: remoteDataMocks.Success,
321 + g: remoteDataMocks.SuccessStale,
319 322 };
320 323
321 324 expectObservable(service.findByHref(selfLink, true, true, ...linksToFollow)).toBe(expected, values);
322 325 });
323 326 });
324 327
325 328 });
326 329
327 330 describe(`when useCachedVersionIfAvailable is false`, () => {
328 331 beforeEach(() => {
347 350 d: remoteDataMocks.Success,
348 351 e: remoteDataMocks.SuccessStale,
349 352 };
350 353
351 354 expectObservable(service.findByHref(selfLink, false, true, ...linksToFollow)).toBe(expected, values);
352 355 });
353 356 });
354 357
355 358 it(`should not emit a cached stale RemoteData, but only start emitting after the state first changes to RequestPending`, () => {
356 359 testScheduler.run(({ cold, expectObservable }) => {
357 - spyOn(rdbService, 'buildSingle').and.returnValue(cold('a-b-c-d-e', {
358 - a: remoteDataMocks.SuccessStale,
359 - b: remoteDataMocks.RequestPending,
360 - c: remoteDataMocks.ResponsePending,
361 - d: remoteDataMocks.Success,
362 - e: remoteDataMocks.SuccessStale,
360 + spyOn(rdbService, 'buildSingle').and.returnValue(cold('a-b-c-d-e-f-g', {
361 + a: remoteDataMocks.ResponsePendingStale,
362 + b: remoteDataMocks.SuccessStale,
363 + c: remoteDataMocks.ErrorStale,
364 + d: remoteDataMocks.RequestPending,
365 + e: remoteDataMocks.ResponsePending,
366 + f: remoteDataMocks.Success,
367 + g: remoteDataMocks.SuccessStale,
363 368 }));
364 - const expected = '--b-c-d-e';
369 + const expected = '------d-e-f-g';
365 370 const values = {
366 - b: remoteDataMocks.RequestPending,
367 - c: remoteDataMocks.ResponsePending,
368 - d: remoteDataMocks.Success,
369 - e: remoteDataMocks.SuccessStale,
371 + d: remoteDataMocks.RequestPending,
372 + e: remoteDataMocks.ResponsePending,
373 + f: remoteDataMocks.Success,
374 + g: remoteDataMocks.SuccessStale,
370 375 };
371 376
372 377 expectObservable(service.findByHref(selfLink, false, true, ...linksToFollow)).toBe(expected, values);
373 378 });
374 379 });
375 380
376 381 });
377 382
378 383 });
379 384
480 485 d: remoteDataMocks.Success,
481 486 e: remoteDataMocks.SuccessStale,
482 487 };
483 488
484 489 expectObservable(service.findListByHref(selfLink, findListOptions, true, true, ...linksToFollow)).toBe(expected, values);
485 490 });
486 491 });
487 492
488 493 it(`should not emit a cached stale RemoteData, but only start emitting after the state first changes to RequestPending`, () => {
489 494 testScheduler.run(({ cold, expectObservable }) => {
490 - spyOn(rdbService, 'buildList').and.returnValue(cold('a-b-c-d-e', {
491 - a: remoteDataMocks.SuccessStale,
492 - b: remoteDataMocks.RequestPending,
493 - c: remoteDataMocks.ResponsePending,
494 - d: remoteDataMocks.Success,
495 - e: remoteDataMocks.SuccessStale,
495 + spyOn(rdbService, 'buildList').and.returnValue(cold('a-b-c-d-e-f-g', {
496 + a: remoteDataMocks.ResponsePendingStale,
497 + b: remoteDataMocks.SuccessStale,
498 + c: remoteDataMocks.ErrorStale,
499 + d: remoteDataMocks.RequestPending,
500 + e: remoteDataMocks.ResponsePending,
501 + f: remoteDataMocks.Success,
502 + g: remoteDataMocks.SuccessStale,
496 503 }));
497 - const expected = '--b-c-d-e';
504 + const expected = '------d-e-f-g';
498 505 const values = {
499 - b: remoteDataMocks.RequestPending,
500 - c: remoteDataMocks.ResponsePending,
501 - d: remoteDataMocks.Success,
502 - e: remoteDataMocks.SuccessStale,
506 + d: remoteDataMocks.RequestPending,
507 + e: remoteDataMocks.ResponsePending,
508 + f: remoteDataMocks.Success,
509 + g: remoteDataMocks.SuccessStale,
503 510 };
504 511
505 512 expectObservable(service.findListByHref(selfLink, findListOptions, true, true, ...linksToFollow)).toBe(expected, values);
506 513 });
507 514 });
508 515
509 516 });
510 517
511 518 describe(`when useCachedVersionIfAvailable is false`, () => {
512 519 beforeEach(() => {
531 538 d: remoteDataMocks.Success,
532 539 e: remoteDataMocks.SuccessStale,
533 540 };
534 541
535 542 expectObservable(service.findListByHref(selfLink, findListOptions, false, true, ...linksToFollow)).toBe(expected, values);
536 543 });
537 544 });
538 545
539 546 it(`should not emit a cached stale RemoteData, but only start emitting after the state first changes to RequestPending`, () => {
540 547 testScheduler.run(({ cold, expectObservable }) => {
541 - spyOn(rdbService, 'buildList').and.returnValue(cold('a-b-c-d-e', {
542 - a: remoteDataMocks.SuccessStale,
543 - b: remoteDataMocks.RequestPending,
544 - c: remoteDataMocks.ResponsePending,
545 - d: remoteDataMocks.Success,
546 - e: remoteDataMocks.SuccessStale,
548 + spyOn(rdbService, 'buildList').and.returnValue(cold('a-b-c-d-e-f-g', {
549 + a: remoteDataMocks.ResponsePendingStale,
550 + b: remoteDataMocks.SuccessStale,
551 + c: remoteDataMocks.ErrorStale,
552 + d: remoteDataMocks.RequestPending,
553 + e: remoteDataMocks.ResponsePending,
554 + f: remoteDataMocks.Success,
555 + g: remoteDataMocks.SuccessStale,
547 556 }));
548 - const expected = '--b-c-d-e';
557 + const expected = '------d-e-f-g';
549 558 const values = {
550 - b: remoteDataMocks.RequestPending,
551 - c: remoteDataMocks.ResponsePending,
552 - d: remoteDataMocks.Success,
553 - e: remoteDataMocks.SuccessStale,
559 + d: remoteDataMocks.RequestPending,
560 + e: remoteDataMocks.ResponsePending,
561 + f: remoteDataMocks.Success,
562 + g: remoteDataMocks.SuccessStale,
554 563 };
555 564
565 +
556 566 expectObservable(service.findListByHref(selfLink, findListOptions, false, true, ...linksToFollow)).toBe(expected, values);
557 567 });
558 568 });
559 569
560 570 });
561 571 });
562 572
563 573 describe('invalidateByHref', () => {
564 574 let getByHrefSpy: jasmine.Spy;
565 575

Everything looks good. We'll let you know here if there's anything you should know about.

Add shortcut