8402698809

Committed 23 Mar 2024 03:15PM UTC coverage: 92.902%. Remained the same

Build # 8402698809

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1917 from damienbod/feature/fg/moving-to-inject-function

Moving to inject function

Run Details

700 of 818 branches covered (85.57%)

Branch coverage included in aggregate %.

241 of 241 new or added lines in 52 files covered. (100.0%)

1 existing line in 1 file now uncovered.

2559 of 2690 relevant lines covered (95.13%)

8.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.43

/projects/angular-auth-oidc-client/src/lib/iframe/check-session.service.ts

import { DOCUMENT } from '@angular/common';
import { Injectable, NgZone, OnDestroy, inject } from '@angular/core';
import { BehaviorSubject, Observable, of } from 'rxjs';
import { take } from 'rxjs/operators';
import { OpenIdConfiguration } from '../config/openid-configuration';
import { LoggerService } from '../logging/logger.service';
import { EventTypes } from '../public-events/event-types';
import { PublicEventsService } from '../public-events/public-events.service';
import { StoragePersistenceService } from '../storage/storage-persistence.service';
import { IFrameService } from './existing-iframe.service';

const IFRAME_FOR_CHECK_SESSION_IDENTIFIER = 'myiFrameForCheckSession';

// http://openid.net/specs/openid-connect-session-1_0-ID4.html

@Injectable({ providedIn: 'root' })
export class CheckSessionService implements OnDestroy {
  private readonly loggerService = inject(LoggerService);

  private readonly storagePersistenceService = inject(
    StoragePersistenceService
  );

  private readonly iFrameService = inject(IFrameService);

  private readonly eventService = inject(PublicEventsService);

  private readonly zone = inject(NgZone);

  private readonly document = inject(DOCUMENT);

  private checkSessionReceived = false;

  private scheduledHeartBeatRunning: any;

  private lastIFrameRefresh = 0;

  private outstandingMessages = 0;

  private readonly heartBeatInterval = 3000;

  private readonly iframeRefreshInterval = 60000;

  private readonly checkSessionChangedInternal$ = new BehaviorSubject<boolean>(
    false
  );

  private iframeMessageEventListener: any;

  get checkSessionChanged$(): Observable<boolean> {
    return this.checkSessionChangedInternal$.asObservable();
  }

  ngOnDestroy(): void {
    this.stop();
    const windowAsDefaultView = this.document.defaultView;

    if (windowAsDefaultView) {
      windowAsDefaultView.removeEventListener(
        'message',
        this.iframeMessageEventListener,
        false
      );
    }
  }

  isCheckSessionConfigured(configuration: OpenIdConfiguration): boolean {
    const { startCheckSession } = configuration;

    return Boolean(startCheckSession);
  }

  start(configuration: OpenIdConfiguration): void {
    if (!!this.scheduledHeartBeatRunning) {
      return;
    }

    const { clientId } = configuration;

    this.pollServerSession(clientId, configuration);
  }

  stop(): void {
    if (!this.scheduledHeartBeatRunning) {
      return;
    }

    this.clearScheduledHeartBeat();
    this.checkSessionReceived = false;
  }

  serverStateChanged(configuration: OpenIdConfiguration): boolean {
    const { startCheckSession } = configuration;

    return Boolean(startCheckSession) && this.checkSessionReceived;
  }

  getExistingIframe(): HTMLIFrameElement | null {
    return this.iFrameService.getExistingIFrame(
      IFRAME_FOR_CHECK_SESSION_IDENTIFIER
    );
  }

  private init(configuration: OpenIdConfiguration): Observable<any> {
    if (this.lastIFrameRefresh + this.iframeRefreshInterval > Date.now()) {
      return of(undefined);
    }

    const authWellKnownEndPoints = this.storagePersistenceService.read(
      'authWellKnownEndPoints',
      configuration
    );

    if (!authWellKnownEndPoints) {
      this.loggerService.logWarning(
        configuration,
        'CheckSession - init check session: authWellKnownEndpoints is undefined. Returning.'
      );

      return of();
    }

    const existingIframe = this.getOrCreateIframe(configuration);

    // https://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html#Events-EventTarget-addEventListener
    // If multiple identical EventListeners are registered on the same EventTarget with the same parameters the duplicate instances are discarded. They do not cause the EventListener to be called twice and since they are discarded they do not need to be removed with the removeEventListener method.
    // this is done even if iframe exists for HMR to work, since iframe exists on service init
    this.bindMessageEventToIframe(configuration);
    const checkSessionIframe = authWellKnownEndPoints.checkSessionIframe;
    const contentWindow = existingIframe.contentWindow;

    if (!checkSessionIframe) {
      this.loggerService.logWarning(
        configuration,
        'CheckSession - init check session: checkSessionIframe is not configured to run'
      );
    }

    if (!contentWindow) {
      this.loggerService.logWarning(
        configuration,
        'CheckSession - init check session: IFrame contentWindow does not exist'
      );
    } else {
      contentWindow.location.replace(checkSessionIframe);
    }

    return new Observable((observer) => {
      existingIframe.onload = (): void => {
        this.lastIFrameRefresh = Date.now();
        observer.next();
        observer.complete();
      };
    });
  }

  private pollServerSession(
    clientId: string | undefined,
    configuration: OpenIdConfiguration
  ): void {
    this.outstandingMessages = 0;

    const pollServerSessionRecur = (): void => {
      this.init(configuration)
        .pipe(take(1))
        .subscribe(() => {
          const existingIframe = this.getExistingIframe();

          if (existingIframe && clientId) {
            this.loggerService.logDebug(
              configuration,
              `CheckSession - clientId : '${clientId}' - existingIframe: '${existingIframe}'`
            );
            const sessionState = this.storagePersistenceService.read(
              'session_state',
              configuration
            );
            const authWellKnownEndPoints = this.storagePersistenceService.read(
              'authWellKnownEndPoints',
              configuration
            );
            const contentWindow = existingIframe.contentWindow;

            if (
              sessionState &&
              authWellKnownEndPoints?.checkSessionIframe &&
              contentWindow
            ) {
              const iframeOrigin = new URL(
                authWellKnownEndPoints.checkSessionIframe
              )?.origin;

              this.outstandingMessages++;
              contentWindow.postMessage(
                clientId + ' ' + sessionState,
                iframeOrigin
              );
            } else {
              this.loggerService.logDebug(
                configuration,
                `CheckSession - session_state is '${sessionState}' - AuthWellKnownEndPoints is '${JSON.stringify(
                  authWellKnownEndPoints,
                  null,
                  2
                )}'`
              );
              this.checkSessionChangedInternal$.next(true);
            }
          } else {
            this.loggerService.logWarning(
              configuration,
              `CheckSession - OidcSecurityCheckSession pollServerSession checkSession IFrame does not exist:
               clientId : '${clientId}' - existingIframe: '${existingIframe}'`
            );
          }

          // after sending three messages with no response, fail.
          if (this.outstandingMessages > 3) {
            this.loggerService.logError(
              configuration,
              `CheckSession - OidcSecurityCheckSession not receiving check session response messages.
                            Outstanding messages: '${this.outstandingMessages}'. Server unreachable?`
            );
          }

          this.zone.runOutsideAngular(() => {
            this.scheduledHeartBeatRunning = setTimeout(
              () => this.zone.run(pollServerSessionRecur),
              this.heartBeatInterval
            );
          });
        });
    };

    pollServerSessionRecur();
  }

  private clearScheduledHeartBeat(): void {
    clearTimeout(this.scheduledHeartBeatRunning);
    this.scheduledHeartBeatRunning = null;
  }

  private messageHandler(configuration: OpenIdConfiguration, e: any): void {
    const existingIFrame = this.getExistingIframe();
    const authWellKnownEndPoints = this.storagePersistenceService.read(
      'authWellKnownEndPoints',
      configuration
    );
    const startsWith = !!authWellKnownEndPoints?.checkSessionIframe?.startsWith(
      e.origin
    );

    this.outstandingMessages = 0;

    if (
      existingIFrame &&
      startsWith &&
      e.source === existingIFrame.contentWindow
    ) {
      if (e.data === 'error') {
        this.loggerService.logWarning(
          configuration,
          'CheckSession - error from check session messageHandler'
        );
      } else if (e.data === 'changed') {
        this.loggerService.logDebug(
          configuration,
          `CheckSession - ${e} from check session messageHandler`
        );
        this.checkSessionReceived = true;
        this.eventService.fireEvent(EventTypes.CheckSessionReceived, e.data);
        this.checkSessionChangedInternal$.next(true);
      } else {
        this.eventService.fireEvent(EventTypes.CheckSessionReceived, e.data);
        this.loggerService.logDebug(
          configuration,
          `CheckSession - ${e.data} from check session messageHandler`
        );
      }
    }
  }

  private bindMessageEventToIframe(configuration: OpenIdConfiguration): void {
    this.iframeMessageEventListener = this.messageHandler.bind(
      this,
      configuration
    );

    const defaultView = this.document.defaultView;

    if (defaultView) {
      defaultView.addEventListener(
        'message',
        this.iframeMessageEventListener,
        false
      );
    }
  }

  private getOrCreateIframe(
    configuration: OpenIdConfiguration
  ): HTMLIFrameElement {
    return (
      this.getExistingIframe() ||
      this.iFrameService.addIFrameToWindowBody(
        IFRAME_FOR_CHECK_SESSION_IDENTIFIER,
        configuration
      )
    );
  }
}

1	import { DOCUMENT } from '@angular/common';
2	import { Injectable, NgZone, OnDestroy, inject } from '@angular/core';
3	import { BehaviorSubject, Observable, of } from 'rxjs';
4	import { take } from 'rxjs/operators';
5	import { OpenIdConfiguration } from '../config/openid-configuration';
6	import { LoggerService } from '../logging/logger.service';
7	import { EventTypes } from '../public-events/event-types';
8	import { PublicEventsService } from '../public-events/public-events.service';
9	import { StoragePersistenceService } from '../storage/storage-persistence.service';
10	import { IFrameService } from './existing-iframe.service';
11
12	const IFRAME_FOR_CHECK_SESSION_IDENTIFIER = 'myiFrameForCheckSession';	1✔
13
14	// http://openid.net/specs/openid-connect-session-1_0-ID4.html
15
16	@Injectable({ providedIn: 'root' })
17	export class CheckSessionService implements OnDestroy {	1✔
18	private readonly loggerService = inject(LoggerService);	23✔
19
20	private readonly storagePersistenceService = inject(	23✔
21	StoragePersistenceService
22	);
23
24	private readonly iFrameService = inject(IFrameService);	23✔
25
26	private readonly eventService = inject(PublicEventsService);	23✔
27
28	private readonly zone = inject(NgZone);	23✔
29
30	private readonly document = inject(DOCUMENT);	23✔
31
32	private checkSessionReceived = false;	23✔
33
34	private scheduledHeartBeatRunning: any;
35
36	private lastIFrameRefresh = 0;	23✔
37
38	private outstandingMessages = 0;	23✔
39
40	private readonly heartBeatInterval = 3000;	23✔
41
42	private readonly iframeRefreshInterval = 60000;	23✔
43
44	private readonly checkSessionChangedInternal$ = new BehaviorSubject<boolean>(	23✔
45	false
46	);
47
48	private iframeMessageEventListener: any;
49
50	get checkSessionChanged$(): Observable<boolean> {
51	return this.checkSessionChangedInternal$.asObservable();	107✔
52	}
53
54	ngOnDestroy(): void {
UNCOV 55	this.stop();	×
56	const windowAsDefaultView = this.document.defaultView;	×
57
58	if (windowAsDefaultView) {	×
59	windowAsDefaultView.removeEventListener(	×
60	'message',
61	this.iframeMessageEventListener,
62	false
63	);
64	}
65	}
66
67	isCheckSessionConfigured(configuration: OpenIdConfiguration): boolean {
68	const { startCheckSession } = configuration;	2✔
69
70	return Boolean(startCheckSession);	2✔
71	}
72
73	start(configuration: OpenIdConfiguration): void {
74	if (!!this.scheduledHeartBeatRunning) {	2✔
75	return;	1✔
76	}
77
78	const { clientId } = configuration;	1✔
79
80	this.pollServerSession(clientId, configuration);	1✔
81	}
82
83	stop(): void {
84	if (!this.scheduledHeartBeatRunning) {	2✔
85	return;	1✔
86	}
87
88	this.clearScheduledHeartBeat();	1✔
89	this.checkSessionReceived = false;	1✔
90	}
91
92	serverStateChanged(configuration: OpenIdConfiguration): boolean {
93	const { startCheckSession } = configuration;	3✔
94
95	return Boolean(startCheckSession) && this.checkSessionReceived;	3✔
96	}
97
98	getExistingIframe(): HTMLIFrameElement \| null {
99	return this.iFrameService.getExistingIFrame(	4✔
100	IFRAME_FOR_CHECK_SESSION_IDENTIFIER
101	);
102	}
103
104	private init(configuration: OpenIdConfiguration): Observable<any> {
105	if (this.lastIFrameRefresh + this.iframeRefreshInterval > Date.now()) {	3✔
106	return of(undefined);	1✔
107	}
108
109	const authWellKnownEndPoints = this.storagePersistenceService.read(	2✔
110	'authWellKnownEndPoints',
111	configuration
112	);
113
114	if (!authWellKnownEndPoints) {	2✔
115	this.loggerService.logWarning(	1✔
116	configuration,
117	'CheckSession - init check session: authWellKnownEndpoints is undefined. Returning.'
118	);
119
120	return of();	1✔
121	}
122
123	const existingIframe = this.getOrCreateIframe(configuration);	1✔
124
125	// https://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html#Events-EventTarget-addEventListener
126	// If multiple identical EventListeners are registered on the same EventTarget with the same parameters the duplicate instances are discarded. They do not cause the EventListener to be called twice and since they are discarded they do not need to be removed with the removeEventListener method.
127	// this is done even if iframe exists for HMR to work, since iframe exists on service init
128	this.bindMessageEventToIframe(configuration);	1✔
129	const checkSessionIframe = authWellKnownEndPoints.checkSessionIframe;	1✔
130	const contentWindow = existingIframe.contentWindow;	1✔
131
132	if (!checkSessionIframe) {	1✔
133	this.loggerService.logWarning(	1✔
134	configuration,
135	'CheckSession - init check session: checkSessionIframe is not configured to run'
136	);
137	}
138
139	if (!contentWindow) {	1!
140	this.loggerService.logWarning(	×
141	configuration,
142	'CheckSession - init check session: IFrame contentWindow does not exist'
143	);
144	} else {
145	contentWindow.location.replace(checkSessionIframe);	1✔
146	}
147
148	return new Observable((observer) => {	1✔
149	existingIframe.onload = (): void => {	×
150	this.lastIFrameRefresh = Date.now();	×
151	observer.next();	×
152	observer.complete();	×
153	};
154	});
155	}
156
157	private pollServerSession(
158	clientId: string \| undefined,
159	configuration: OpenIdConfiguration
160	): void {
161	this.outstandingMessages = 0;	5✔
162
163	const pollServerSessionRecur = (): void => {	5✔
164	this.init(configuration)	5✔
165	.pipe(take(1))
166	.subscribe(() => {
167	const existingIframe = this.getExistingIframe();	5✔
168
169	if (existingIframe && clientId) {	5✔
170	this.loggerService.logDebug(	3✔
171	configuration,
172	`CheckSession - clientId : '${clientId}' - existingIframe: '${existingIframe}'`
173	);
174	const sessionState = this.storagePersistenceService.read(	3✔
175	'session_state',
176	configuration
177	);
178	const authWellKnownEndPoints = this.storagePersistenceService.read(	3✔
179	'authWellKnownEndPoints',
180	configuration
181	);
182	const contentWindow = existingIframe.contentWindow;	3✔
183
184	if (	3✔
185	sessionState &&	6✔
186	authWellKnownEndPoints?.checkSessionIframe &&
187	contentWindow
188	) {
189	const iframeOrigin = new URL(	1✔
190	authWellKnownEndPoints.checkSessionIframe
191	)?.origin;
192
193	this.outstandingMessages++;	1✔
194	contentWindow.postMessage(	1✔
195	clientId + ' ' + sessionState,
196	iframeOrigin
197	);
198	} else {
199	this.loggerService.logDebug(	2✔
200	configuration,
201	`CheckSession - session_state is '${sessionState}' - AuthWellKnownEndPoints is '${JSON.stringify(
202	authWellKnownEndPoints,
203	null,
204	2
205	)}'`
206	);
207	this.checkSessionChangedInternal$.next(true);	2✔
208	}
209	} else {
210	this.loggerService.logWarning(	2✔
211	configuration,
212	`CheckSession - OidcSecurityCheckSession pollServerSession checkSession IFrame does not exist:
213	clientId : '${clientId}' - existingIframe: '${existingIframe}'`
214	);
215	}
216
217	// after sending three messages with no response, fail.
218	if (this.outstandingMessages > 3) {	5!
219	this.loggerService.logError(	×
220	configuration,
221	`CheckSession - OidcSecurityCheckSession not receiving check session response messages.
222	Outstanding messages: '${this.outstandingMessages}'. Server unreachable?`
223	);
224	}
225
226	this.zone.runOutsideAngular(() => {	5✔
227	this.scheduledHeartBeatRunning = setTimeout(	5✔
228	() => this.zone.run(pollServerSessionRecur),	×
229	this.heartBeatInterval
230	);
231	});
232	});
233	};
234
235	pollServerSessionRecur();	5✔
236	}
237
238	private clearScheduledHeartBeat(): void {
239	clearTimeout(this.scheduledHeartBeatRunning);	1✔
240	this.scheduledHeartBeatRunning = null;	1✔
241	}
242
243	private messageHandler(configuration: OpenIdConfiguration, e: any): void {
244	const existingIFrame = this.getExistingIframe();	×
245	const authWellKnownEndPoints = this.storagePersistenceService.read(	×
246	'authWellKnownEndPoints',
247	configuration
248	);
249	const startsWith = !!authWellKnownEndPoints?.checkSessionIframe?.startsWith(	×
250	e.origin
251	);
252
253	this.outstandingMessages = 0;	×
254
255	if (	×
256	existingIFrame &&	×
257	startsWith &&
258	e.source === existingIFrame.contentWindow
259	) {
260	if (e.data === 'error') {	×
261	this.loggerService.logWarning(	×
262	configuration,
263	'CheckSession - error from check session messageHandler'
264	);
265	} else if (e.data === 'changed') {	×
266	this.loggerService.logDebug(	×
267	configuration,
268	`CheckSession - ${e} from check session messageHandler`
269	);
270	this.checkSessionReceived = true;	×
271	this.eventService.fireEvent(EventTypes.CheckSessionReceived, e.data);	×
272	this.checkSessionChangedInternal$.next(true);	×
273	} else {
274	this.eventService.fireEvent(EventTypes.CheckSessionReceived, e.data);	×
275	this.loggerService.logDebug(	×
276	configuration,
277	`CheckSession - ${e.data} from check session messageHandler`
278	);
279	}
280	}
281	}
282
283	private bindMessageEventToIframe(configuration: OpenIdConfiguration): void {
284	this.iframeMessageEventListener = this.messageHandler.bind(	1✔
285	this,
286	configuration
287	);
288
289	const defaultView = this.document.defaultView;	1✔
290
291	if (defaultView) {	1✔
292	defaultView.addEventListener(	1✔
293	'message',
294	this.iframeMessageEventListener,
295	false
296	);
297	}
298	}
299
300	private getOrCreateIframe(
301	configuration: OpenIdConfiguration
302	): HTMLIFrameElement {
303	return (	4✔
304	this.getExistingIframe() \|\|	7✔
305	this.iFrameService.addIFrameToWindowBody(
306	IFRAME_FOR_CHECK_SESSION_IDENTIFIER,
307	configuration
308	)
309	);
310	}
311	}

damienbod / angular-auth-oidc-client / 8402698809

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous