112 lines
4.3 KiB
TypeScript
112 lines
4.3 KiB
TypeScript
import {TestBed} from '@angular/core/testing';
|
|
import {firstValueFrom, of, Subject} from 'rxjs';
|
|
import {take} from 'rxjs/operators';
|
|
import {DbService} from '../../../services/db.service';
|
|
import {ShowDataService} from './show-data.service';
|
|
|
|
describe('ShowDataService', () => {
|
|
let service: ShowDataService;
|
|
let shows$: Subject<Array<{id: string; date: {toMillis: () => number}; archived?: boolean}>>;
|
|
let docUpdateSpy: jasmine.Spy<() => Promise<void>>;
|
|
let docSpy: jasmine.Spy;
|
|
let colAddSpy: jasmine.Spy<() => Promise<{id: string}>>;
|
|
let colSpy: jasmine.Spy;
|
|
let dbServiceSpy: jasmine.SpyObj<DbService>;
|
|
|
|
beforeEach(async () => {
|
|
shows$ = new Subject<Array<{id: string; date: {toMillis: () => number}; archived?: boolean}>>();
|
|
docUpdateSpy = jasmine.createSpy('update').and.resolveTo();
|
|
docSpy = jasmine.createSpy('doc').and.returnValue({update: docUpdateSpy});
|
|
colAddSpy = jasmine.createSpy('add').and.resolveTo({id: 'show-3'});
|
|
colSpy = jasmine.createSpy('col').and.returnValue({add: colAddSpy});
|
|
dbServiceSpy = jasmine.createSpyObj<DbService>('DbService', ['col$', 'doc$', 'doc', 'col']);
|
|
dbServiceSpy.col$.and.returnValue(shows$.asObservable());
|
|
dbServiceSpy.doc$.and.returnValue(of(null));
|
|
dbServiceSpy.doc.and.callFake(docSpy);
|
|
dbServiceSpy.col.and.callFake(colSpy);
|
|
|
|
await TestBed.configureTestingModule({
|
|
providers: [{provide: DbService, useValue: dbServiceSpy}],
|
|
});
|
|
|
|
service = TestBed.inject(ShowDataService);
|
|
});
|
|
|
|
it('should be created', () => {
|
|
expect(service).toBeTruthy();
|
|
});
|
|
|
|
it('should load the raw show list from the shows collection on creation', () => {
|
|
expect(dbServiceSpy.col$).toHaveBeenCalledWith('shows');
|
|
});
|
|
|
|
it('should sort the list by ascending show date', async () => {
|
|
const listPromise = firstValueFrom(service.list$.pipe(take(1)));
|
|
|
|
shows$.next([
|
|
{id: 'show-2', date: {toMillis: () => 200}},
|
|
{id: 'show-1', date: {toMillis: () => 100}},
|
|
{id: 'show-3', date: {toMillis: () => 300}},
|
|
]);
|
|
|
|
const list = await listPromise;
|
|
|
|
expect(list.map(show => show.id)).toEqual(['show-1', 'show-2', 'show-3']);
|
|
});
|
|
|
|
it('should replay the latest sorted list to late subscribers', async () => {
|
|
const initialSubscription = service.list$.subscribe();
|
|
|
|
shows$.next([
|
|
{id: 'show-2', date: {toMillis: () => 200}},
|
|
{id: 'show-1', date: {toMillis: () => 100}},
|
|
]);
|
|
|
|
const replayedList = await firstValueFrom(service.list$.pipe(take(1)));
|
|
|
|
expect(replayedList.map(show => show.id)).toEqual(['show-1', 'show-2']);
|
|
|
|
initialSubscription.unsubscribe();
|
|
});
|
|
|
|
it('should expose the raw list without sorting via listRaw$', () => {
|
|
service.listRaw$().subscribe();
|
|
|
|
expect(dbServiceSpy.col$).toHaveBeenCalledWith('shows');
|
|
});
|
|
|
|
it('should request only published recent shows and filter archived entries', async () => {
|
|
const publicShows$ = of([{id: 'show-1', archived: false}, {id: 'show-2', archived: true}, {id: 'show-3'}]);
|
|
dbServiceSpy.col$.and.returnValue(publicShows$ as never);
|
|
|
|
const result = await firstValueFrom(service.listPublicSince$(3));
|
|
|
|
expect(dbServiceSpy.col$).toHaveBeenCalledWith('shows', jasmine.any(Array));
|
|
const [, queryConstraints] = dbServiceSpy.col$.calls.mostRecent().args as [string, unknown[]];
|
|
expect(queryConstraints.length).toBe(3);
|
|
expect(result.map(show => show.id)).toEqual(['show-1', 'show-3']);
|
|
});
|
|
|
|
it('should read a single show by id', () => {
|
|
service.read$('show-7').subscribe();
|
|
|
|
expect(dbServiceSpy.doc$).toHaveBeenCalledWith('shows/show-7');
|
|
});
|
|
|
|
it('should update a show at the expected document path', async () => {
|
|
await service.update('show-8', {archived: true});
|
|
|
|
expect(docSpy).toHaveBeenCalledWith('shows/show-8');
|
|
const [updatePayload] = docUpdateSpy.calls.mostRecent().args as unknown as [Record<string, unknown>];
|
|
expect(updatePayload).toEqual({archived: true});
|
|
});
|
|
|
|
it('should add a show to the shows collection and return the new id', async () => {
|
|
await expectAsync(service.add({published: true})).toBeResolvedTo('show-3');
|
|
|
|
expect(colSpy).toHaveBeenCalledWith('shows');
|
|
const [addPayload] = colAddSpy.calls.mostRecent().args as unknown as [Record<string, unknown>];
|
|
expect(addPayload).toEqual({published: true});
|
|
});
|
|
});
|