[DSC-1570] write tests

Author: Andrea Barbasso

src/app/shared/datadog-rum/datadog-rum.service.spec.ts

@@ -1,16 +1,93 @@
 import { TestBed } from '@angular/core/testing';
-
+import { MockStore, provideMockStore } from '@ngrx/store/testing';
 import { DatadogRumService } from './datadog-rum.service';
+import { CookieConsents, KlaroService } from '../cookies/klaro.service';
+import { of } from 'rxjs';
+import { environment } from '../../../environments/environment';
+import { setDatadogRumStatusAction } from './datadog-rum.actions';
 
 describe('DatadogRumService', () => {
   let service: DatadogRumService;
+  let store: MockStore;
+  let klaroService: KlaroService;
+  let memoizedSelector;
+
+  const initialState = {
+    datadogRum: {
+      isInitialized: false,
+      isRunning: false
+    }
+  };
+
+  const consentsAccepted: CookieConsents = {
+    datadog: true
+  };
+
+  const klaroServiceSpy = jasmine.createSpyObj('KlaroService', {
+    getSavedPreferences: jasmine.createSpy('getSavedPreferences'),
+    watchConsentUpdates: jasmine.createSpy('watchConsentUpdates')
+  }, {
+    consentsUpdates$: of(consentsAccepted)
+  });
+
+  const datadogRumEnvironmentOptions = {
+    clientToken: 'clientToken',
+    applicationId: 'applicationId',
+    service: 'service',
+    env: 'env'
+  };
 
   beforeEach(() => {
-    TestBed.configureTestingModule({});
+    TestBed.configureTestingModule({
+      providers: [
+        DatadogRumService,
+        provideMockStore({initialState}),
+        {provide: KlaroService, useValue: klaroServiceSpy},
+      ]
+    });
     service = TestBed.inject(DatadogRumService);
+    store = TestBed.inject(MockStore);
+    memoizedSelector = store.overrideSelector(service.datadogRumStateSelector, initialState.datadogRum);
+    klaroService = TestBed.inject(KlaroService);
+
+    spyOn(store, 'dispatch');
   });
 
   it('should be created', () => {
     expect(service).toBeTruthy();
   });
+
+  it('should dispatch setDatadogRumStatusAction with isInitialized and isRunning true when datadog cookie is accepted', () => {
+    memoizedSelector.setResult({isInitialized: false, isRunning: false});
+    store.refreshState();
+    consentsAccepted.datadog = true;
+    environment.datadogRum = datadogRumEnvironmentOptions;
+    service.initDatadogRum();
+    expect(store.dispatch).toHaveBeenCalledWith(new setDatadogRumStatusAction({
+      isInitialized: true,
+      isRunning: true
+    }));
+  });
+
+  it('should dispatch setDatadogRumStatusAction with isRunning true when datadog cookie is accepted and isInitialized is true', () => {
+    memoizedSelector.setResult({isInitialized: true, isRunning: false});
+    store.refreshState();
+    consentsAccepted.datadog = true;
+    environment.datadogRum = datadogRumEnvironmentOptions;
+    service.initDatadogRum();
+    expect(store.dispatch).toHaveBeenCalledWith(new setDatadogRumStatusAction({
+      isRunning: true
+    }));
+  });
+
+  it('should dispatch setDatadogRumStatusAction with isRunning false when datadog cookie is not accepted', () => {
+    memoizedSelector.setResult({isInitialized: true, isRunning: true});
+    store.refreshState();
+    consentsAccepted.datadog = false;
+    service.initDatadogRum();
+    expect(store.dispatch).toHaveBeenCalledWith(new setDatadogRumStatusAction({
+      isRunning: false
+    }));
+  });
+
 });

src/app/shared/datadog-rum/datadog-rum.service.ts

@@ -10,14 +10,13 @@ import { distinctUntilChanged, take } from 'rxjs/operators';
 import { coreSelector } from '../../core/core.selectors';
 import { CoreState } from '../../core/core-state.model';
 
-export const getDatadogRumState = createSelector(coreSelector, (state: CoreState) => state.datadogRum);
-
 @Injectable({
   providedIn: 'root'
 })
 export class DatadogRumService {
 
-  consentUpdates$: BehaviorSubject<CookieConsents>;
+  consentsUpdates$: BehaviorSubject<CookieConsents>;
+  datadogRumStateSelector = createSelector(coreSelector, (state: CoreState) => state.datadogRum);
 
   constructor(
     private klaroService: KlaroService,
@@ -27,8 +26,8 @@ export class DatadogRumService {
 
   initDatadogRum() {
     this.klaroService.watchConsentUpdates();
-    this.consentUpdates$ = this.klaroService.consentsUpdates$;
-    this.consentUpdates$.subscribe(savedPreferences => {
+    this.consentsUpdates$ = this.klaroService.consentsUpdates$;
+    this.consentsUpdates$.subscribe(savedPreferences => {
       this.getDatadogRumState().subscribe((state) => {
         if (savedPreferences?.datadog &&
           environment.datadogRum?.clientToken && environment.datadogRum?.applicationId &&
@@ -58,7 +57,7 @@ export class DatadogRumService {
 
   getDatadogRumState(): Observable<DatadogRumState> {
     return this.store
-      .select(getDatadogRumState)
+      .select(this.datadogRumStateSelector)
       .pipe(
         distinctUntilChanged(),
         take(1),