migrate angular 21 tests

src/app/modules/shows/services/show-data.service.spec.ts

@@ -1,12 +1,115 @@
 import {TestBed} from '@angular/core/testing';
-
+import {firstValueFrom, of, Subject} from 'rxjs';
+import {skip, take} from 'rxjs/operators';
+import {DbService} from '../../../services/db.service';
 import {ShowDataService} from './show-data.service';
 
 describe('ShowDataService', () => {
-  beforeEach(() => void TestBed.configureTestingModule({}));
+  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(() => {
+    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);
+
+    void TestBed.configureTestingModule({
+      providers: [{provide: DbService, useValue: dbServiceSpy}],
+    });
+
+    service = TestBed.inject(ShowDataService);
+  });
 
   it('should be created', () => {
-    const service: ShowDataService = TestBed.inject(ShowDataService);
-    void expect(service).toBeTruthy();
+    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});
   });
 });

src/app/modules/shows/services/show-data.service.ts

@@ -3,7 +3,7 @@ import {Observable} from 'rxjs';
 import {DbService} from '../../../services/db.service';
 import {Show} from './show';
 import {map, shareReplay} from 'rxjs/operators';
-import {orderBy, QueryConstraint, Timestamp, where} from '@angular/fire/firestore';
+import {orderBy, QueryConstraint, Timestamp, where} from 'firebase/firestore';
 
 @Injectable({
   providedIn: 'root',

src/app/modules/shows/services/show-song-data.service.spec.ts

@@ -1,16 +1,98 @@
 import {TestBed} from '@angular/core/testing';
-
+import {of} from 'rxjs';
+import {DbService} from '../../../services/db.service';
 import {ShowSongDataService} from './show-song-data.service';
 
 describe('ShowSongDataService', () => {
   let service: ShowSongDataService;
+  let docUpdateSpy: jasmine.Spy<() => Promise<void>>;
+  let docDeleteSpy: 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(() => {
-    void TestBed.configureTestingModule({});
+    docUpdateSpy = jasmine.createSpy('update').and.resolveTo();
+    docDeleteSpy = jasmine.createSpy('delete').and.resolveTo();
+    docSpy = jasmine.createSpy('doc').and.returnValue({
+      update: docUpdateSpy,
+      delete: docDeleteSpy,
+    });
+    colAddSpy = jasmine.createSpy('add').and.resolveTo({id: 'show-song-3'});
+    colSpy = jasmine.createSpy('col').and.returnValue({add: colAddSpy});
+    dbServiceSpy = jasmine.createSpyObj<DbService>('DbService', ['col$', 'doc$', 'doc', 'col']);
+    dbServiceSpy.col$.and.callFake(() => of([{id: 'show-song-1'}]) as never);
+    dbServiceSpy.doc$.and.returnValue(of({id: 'show-song-1'}) as never);
+    dbServiceSpy.doc.and.callFake(docSpy);
+    dbServiceSpy.col.and.callFake(colSpy);
+
+    void TestBed.configureTestingModule({
+      providers: [{provide: DbService, useValue: dbServiceSpy}],
+    });
+
     service = TestBed.inject(ShowSongDataService);
   });
 
   it('should be created', () => {
-    void expect(service).toBeTruthy();
+    expect(service).toBeTruthy();
+  });
+
+  it('should cache the list observable per show id when no query constraints are passed', () => {
+    const first = service.list$('show-1');
+    const second = service.list$('show-1');
+
+    expect(first).toBe(second);
+    expect(dbServiceSpy.col$).toHaveBeenCalledTimes(1);
+    expect(dbServiceSpy.col$).toHaveBeenCalledWith('shows/show-1/songs');
+  });
+
+  it('should not reuse the cache when query constraints are passed', () => {
+    const constraints = [{}] as never[];
+
+    const first = service.list$('show-1', constraints as never);
+    const second = service.list$('show-1', constraints as never);
+
+    expect(first).not.toBe(second);
+    expect(dbServiceSpy.col$).toHaveBeenCalledTimes(2);
+    expect(dbServiceSpy.col$).toHaveBeenCalledWith('shows/show-1/songs', constraints as never);
+  });
+
+  it('should keep separate caches for different shows', () => {
+    service.list$('show-1');
+    service.list$('show-2');
+
+    expect(dbServiceSpy.col$).toHaveBeenCalledTimes(2);
+    expect(dbServiceSpy.col$).toHaveBeenCalledWith('shows/show-1/songs');
+    expect(dbServiceSpy.col$).toHaveBeenCalledWith('shows/show-2/songs');
+  });
+
+  it('should read a single show song by nested document path', () => {
+    service.read$('show-4', 'song-5').subscribe();
+
+    expect(dbServiceSpy.doc$).toHaveBeenCalledWith('shows/show-4/songs/song-5');
+  });
+
+  it('should update a nested show song document', async () => {
+    await service.update$('show-4', 'song-5', {title: 'Updated'} as never);
+
+    expect(docSpy).toHaveBeenCalledWith('shows/show-4/songs/song-5');
+    const [updatePayload] = docUpdateSpy.calls.mostRecent().args as unknown as [Record<string, unknown>];
+    expect(updatePayload).toEqual({title: 'Updated'});
+  });
+
+  it('should delete a nested show song document', async () => {
+    await service.delete('show-4', 'song-5');
+
+    expect(docSpy).toHaveBeenCalledWith('shows/show-4/songs/song-5');
+    expect(docDeleteSpy).toHaveBeenCalled();
+  });
+
+  it('should add a song to the nested show songs collection and return the id', async () => {
+    await expectAsync(service.add('show-4', {songId: 'song-5'} as never)).toBeResolvedTo('show-song-3');
+
+    expect(colSpy).toHaveBeenCalledWith('shows/show-4/songs');
+    const [addPayload] = colAddSpy.calls.mostRecent().args as unknown as [Record<string, unknown>];
+    expect(addPayload).toEqual({songId: 'song-5'});
   });
 });

src/app/modules/shows/services/show-song.service.spec.ts

@@ -1,16 +1,131 @@
 import {TestBed} from '@angular/core/testing';
-
+import {BehaviorSubject, of} from 'rxjs';
+import {SongDataService} from '../../songs/services/song-data.service';
+import {UserService} from '../../../services/user/user.service';
+import {ShowService} from './show.service';
+import {ShowSongDataService} from './show-song-data.service';
 import {ShowSongService} from './show-song.service';
 
 describe('ShowSongService', () => {
   let service: ShowSongService;
+  let showSongDataServiceSpy: jasmine.SpyObj<ShowSongDataService>;
+  let songDataServiceSpy: jasmine.SpyObj<SongDataService>;
+  let userServiceSpy: jasmine.SpyObj<UserService>;
+  let showServiceSpy: jasmine.SpyObj<ShowService>;
+  let user$: BehaviorSubject<any>;
+  const song = {id: 'song-1', key: 'G', title: 'Amazing Grace'} as any;
+  const showSong = {id: 'show-song-1', songId: 'song-1'} as any;
+  const show = {id: 'show-1', order: ['show-song-1', 'show-song-2']} as any;
 
   beforeEach(() => {
-    void TestBed.configureTestingModule({});
+    user$ = new BehaviorSubject<any>({id: 'user-1', name: 'Benjamin', role: 'editor', chordMode: 'letters', songUsage: {}});
+    showSongDataServiceSpy = jasmine.createSpyObj<ShowSongDataService>('ShowSongDataService', ['add', 'read$', 'list$', 'delete', 'update$']);
+    songDataServiceSpy = jasmine.createSpyObj<SongDataService>('SongDataService', ['read$']);
+    userServiceSpy = jasmine.createSpyObj<UserService>('UserService', ['incSongCount', 'decSongCount'], {
+      user$: user$.asObservable(),
+    });
+    showServiceSpy = jasmine.createSpyObj<ShowService>('ShowService', ['read$', 'update$']);
+
+    showSongDataServiceSpy.add.and.resolveTo('show-song-2');
+    showSongDataServiceSpy.read$.and.returnValue(of(showSong));
+    showSongDataServiceSpy.list$.and.returnValue(of([showSong]));
+    showSongDataServiceSpy.delete.and.resolveTo();
+    showSongDataServiceSpy.update$.and.resolveTo();
+    songDataServiceSpy.read$.and.returnValue(of(song));
+    userServiceSpy.incSongCount.and.resolveTo();
+    userServiceSpy.decSongCount.and.resolveTo();
+    showServiceSpy.read$.and.returnValue(of(show));
+    showServiceSpy.update$.and.resolveTo();
+
+    void TestBed.configureTestingModule({
+      providers: [
+        {provide: ShowSongDataService, useValue: showSongDataServiceSpy},
+        {provide: SongDataService, useValue: songDataServiceSpy},
+        {provide: UserService, useValue: userServiceSpy},
+        {provide: ShowService, useValue: showServiceSpy},
+      ],
+    });
+
     service = TestBed.inject(ShowSongService);
   });
 
   it('should be created', () => {
-    void expect(service).toBeTruthy();
+    expect(service).toBeTruthy();
+  });
+
+  it('should create a show song from the song and current user', async () => {
+    await expectAsync(service.new$('show-1', 'song-1', true)).toBeResolvedTo('show-song-2');
+
+    expect(userServiceSpy.incSongCount).toHaveBeenCalledWith('song-1');
+    expect(showSongDataServiceSpy.add).toHaveBeenCalledWith('show-1', {
+      ...song,
+      songId: 'song-1',
+      key: 'G',
+      keyOriginal: 'G',
+      chordMode: 'letters',
+      addedLive: true,
+    });
+  });
+
+  it('should return null when the song is missing', async () => {
+    songDataServiceSpy.read$.and.returnValue(of(null));
+
+    await expectAsync(service.new$('show-1', 'song-1')).toBeResolvedTo(null);
+
+    expect(showSongDataServiceSpy.add).not.toHaveBeenCalled();
+    expect(userServiceSpy.incSongCount).not.toHaveBeenCalled();
+  });
+
+  it('should return null when the current user is missing', async () => {
+    user$.next(null);
+
+    await expectAsync(service.new$('show-1', 'song-1')).toBeResolvedTo(null);
+
+    expect(showSongDataServiceSpy.add).not.toHaveBeenCalled();
+    expect(userServiceSpy.incSongCount).not.toHaveBeenCalled();
+  });
+
+  it('should delegate reads to the data service', async () => {
+    await expectAsync(service.read('show-1', 'show-song-1')).toBeResolvedTo(showSong);
+    expect(showSongDataServiceSpy.read$).toHaveBeenCalledWith('show-1', 'show-song-1');
+  });
+
+  it('should delegate list access to the data service', async () => {
+    await expectAsync(service.list('show-1')).toBeResolvedTo([showSong]);
+    expect(showSongDataServiceSpy.list$).toHaveBeenCalledWith('show-1');
+  });
+
+  it('should delete a show song, update the order and decrement song usage', async () => {
+    await service.delete$('show-1', 'show-song-1', 0);
+
+    expect(showSongDataServiceSpy.delete).toHaveBeenCalledWith('show-1', 'show-song-1');
+    expect(showServiceSpy.update$).toHaveBeenCalledWith('show-1', {order: ['show-song-2']});
+    expect(userServiceSpy.decSongCount).toHaveBeenCalledWith('song-1');
+  });
+
+  it('should stop delete when the show is missing', async () => {
+    showServiceSpy.read$.and.returnValue(of(null));
+
+    await service.delete$('show-1', 'show-song-1', 0);
+
+    expect(showSongDataServiceSpy.delete).not.toHaveBeenCalled();
+    expect(showServiceSpy.update$).not.toHaveBeenCalled();
+    expect(userServiceSpy.decSongCount).not.toHaveBeenCalled();
+  });
+
+  it('should stop delete when the show song is missing', async () => {
+    showSongDataServiceSpy.read$.and.returnValue(of(null));
+
+    await service.delete$('show-1', 'show-song-1', 0);
+
+    expect(showSongDataServiceSpy.delete).not.toHaveBeenCalled();
+    expect(showServiceSpy.update$).not.toHaveBeenCalled();
+    expect(userServiceSpy.decSongCount).not.toHaveBeenCalled();
+  });
+
+  it('should delegate updates to the data service', async () => {
+    await service.update$('show-1', 'show-song-1', {title: 'Updated'} as never);
+
+    expect(showSongDataServiceSpy.update$).toHaveBeenCalledWith('show-1', 'show-song-1', {title: 'Updated'} as never);
   });
 });

src/app/modules/shows/services/show.service.spec.ts

@@ -1,27 +1,102 @@
 import {TestBed} from '@angular/core/testing';
-
-import {ShowService} from './show.service';
+import {BehaviorSubject, of} from 'rxjs';
 import {ShowDataService} from './show-data.service';
+import {ShowService} from './show.service';
+import {UserService} from '../../../services/user/user.service';
 
 describe('ShowService', () => {
-  const mockShowDataService = {add: Promise.resolve(null)};
-  beforeEach(
-    () =>
-      void TestBed.configureTestingModule({
-        providers: [{provide: ShowDataService, useValue: mockShowDataService}],
-      })
-  );
+  let service: ShowService;
+  let showDataServiceSpy: jasmine.SpyObj<ShowDataService>;
+  let user$: BehaviorSubject<unknown>;
+  const shows = [
+    {id: 'show-1', owner: 'user-1', published: false, archived: false},
+    {id: 'show-2', owner: 'other-user', published: true, archived: false},
+    {id: 'show-3', owner: 'user-1', published: true, archived: true},
+  ] as never;
+
+  beforeEach(() => {
+    user$ = new BehaviorSubject<unknown>({id: 'user-1'});
+    showDataServiceSpy = jasmine.createSpyObj<ShowDataService>('ShowDataService', ['read$', 'listPublicSince$', 'update', 'add'], {
+      list$: of(shows),
+    });
+    showDataServiceSpy.read$.and.returnValue(of(shows[0]));
+    showDataServiceSpy.listPublicSince$.and.returnValue(of([shows[1]]));
+    showDataServiceSpy.update.and.resolveTo();
+    showDataServiceSpy.add.and.resolveTo('new-show-id');
+
+    void TestBed.configureTestingModule({
+      providers: [
+        {provide: ShowDataService, useValue: showDataServiceSpy},
+        {provide: UserService, useValue: {user$: user$.asObservable()}},
+      ],
+    });
+
+    service = TestBed.inject(ShowService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should list published shows and own drafts, but exclude archived ones', done => {
+    service.list$().subscribe(result => {
+      expect(result.map(show => show.id)).toEqual(['show-1', 'show-2']);
+      done();
+    });
+  });
+
+  it('should filter out private drafts when publishedOnly is true', done => {
+    service.list$(true).subscribe(result => {
+      expect(result.map(show => show.id)).toEqual(['show-2']);
+      done();
+    });
+  });
+
+  it('should delegate public listing to the data service', done => {
+    service.listPublicSince$(6).subscribe(result => {
+      expect(result).toEqual([shows[1]]);
+      expect(showDataServiceSpy.listPublicSince$).toHaveBeenCalledWith(6);
+      done();
+    });
+  });
+
+  it('should delegate reads to the data service', done => {
+    service.read$('show-1').subscribe(result => {
+      expect(result).toEqual(shows[0]);
+      expect(showDataServiceSpy.read$).toHaveBeenCalledWith('show-1');
+      done();
+    });
+  });
+
+  it('should delegate updates to the data service', async () => {
+    await service.update$('show-1', {published: true});
+
+    expect(showDataServiceSpy.update).toHaveBeenCalledWith('show-1', {published: true});
+  });
+
+  it('should return null when creating a show without showType', async () => {
+    await expectAsync(service.new$({published: true})).toBeResolvedTo(null);
+
+    expect(showDataServiceSpy.add).not.toHaveBeenCalled();
+  });
+
+  it('should return null when no user is available for show creation', async () => {
+    user$.next(null);
+
+    await expectAsync(service.new$({showType: 'misc-public'})).toBeResolvedTo(null);
+
+    expect(showDataServiceSpy.add).not.toHaveBeenCalled();
+  });
 
   ShowService.SHOW_TYPE_PUBLIC.forEach(type => {
     it('should calc public flag for ' + type, async () => {
-      const service: ShowService = TestBed.inject(ShowService);
-      const addSpy = spyOn(TestBed.inject(ShowDataService), 'add').and.returnValue(Promise.resolve('id'));
-
       const id = await service.new$({showType: type});
 
-      void expect(id).toBe('id');
-      void expect(addSpy).toHaveBeenCalledWith({
+      expect(id).toBe('new-show-id');
+      expect(showDataServiceSpy.add).toHaveBeenCalledWith({
         showType: type,
+        owner: 'user-1',
+        order: [],
         public: true,
       });
     });
@@ -29,14 +104,13 @@ describe('ShowService', () => {
 
   ShowService.SHOW_TYPE_PRIVATE.forEach(type => {
     it('should calc private flag for ' + type, async () => {
-      const service: ShowService = TestBed.inject(ShowService);
-      const addSpy = spyOn(TestBed.inject(ShowDataService), 'add').and.returnValue(Promise.resolve('id'));
-
       const id = await service.new$({showType: type});
 
-      void expect(id).toBe('id');
-      void expect(addSpy).toHaveBeenCalledWith({
+      expect(id).toBe('new-show-id');
+      expect(showDataServiceSpy.add).toHaveBeenCalledWith({
         showType: type,
+        owner: 'user-1',
+        order: [],
         public: false,
       });
     });