Adding the latest changes from upstream

package.json

@@ -108,15 +108,15 @@
     "jest-junit": "^13.0.0",
     "jest-preset-angular": "^8.4.0",
     "lodash": "^4.17.21",
-    "ng-mocks": "^13.3.0",
+    "ng-mocks": "^13.4.0",
     "ng-packagr": "^12.2.5",
     "prettier": "^2.2.1",
     "pretty-quick": "^3.1.3",
     "ts-node": "~10.7.0",
     "tslint": "~6.1.3",
     "tslint-config-prettier": "^1.18.0",
     "typescript": "~4.3.5",
-    "typescript-tslint-plugin": "^1.0.1"
+    "typescript-tslint-plugin": "^1.0.2"
   },
   "config": {
     "commitizen": {

projects/common/src/constants/application-constants.ts

@@ -1,7 +1,3 @@
-import { InjectionToken } from '@angular/core';
-
-export const GLOBAL_HEADER_HEIGHT = new InjectionToken<string>('Global Header Height');
-
 export const enum ApplicationFeature {
   PageTimeRange = 'ui.page-time-range'
 }

projects/common/src/global-header-height/global-header-height-provider.service.ts

@@ -0,0 +1,10 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({ providedIn: 'root' })
+export class GlobalHeaderHeightProviderService {
+  protected headerHeight: string = '56px';
+
+  public get globalHeaderHeight(): string {
+    return this.headerHeight;
+  }
+}

projects/common/src/navigation/ht-route-data.ts

@@ -7,4 +7,5 @@ export interface HtRouteData {
   features?: string[];
   title?: string;
   defaultTimeRange?: TimeRange;
+  shouldSavePageTimeRange?: boolean;
 }

projects/common/src/navigation/navigation.service.ts

@@ -128,7 +128,7 @@ export class NavigationService {
     return {
       path: params.path,
       extras: {
-        queryParams: params?.queryParams ?? this.buildQueryParam(),
+        queryParams: { ...this.buildQueryParam(), ...(params?.queryParams ?? {}) },
         queryParamsHandling: params?.queryParamsHandling,
         replaceUrl: params?.replaceCurrentHistory,
         relativeTo: params?.relativeTo

projects/common/src/public-api.ts

@@ -128,3 +128,6 @@ export * from './utilities/validators';
 
 // Color Palette
 export * from './color/color-palette';
+
+// Global header height provider
+export * from './global-header-height/global-header-height-provider.service';

projects/common/src/time/page-time-range-preference-service.test.ts

@@ -21,9 +21,7 @@ describe('Page time range preference service', () => {
     service: PageTimeRangePreferenceService,
     providers: [
       mockProvider(NavigationService, {
-        getCurrentActivatedRoute: jest
-          .fn()
-          .mockReturnValue({ snapshot: { data: { defaultTimeRange: defaultPageTimeRange } } })
+        getRouteConfig: jest.fn().mockReturnValue({ data: { defaultTimeRange: defaultPageTimeRange } })
       }),
       mockProvider(FeatureStateResolver, {
         getFeatureState: jest.fn().mockReturnValue(of(FeatureState.Enabled))

projects/common/src/time/page-time-range-preference.service.ts

@@ -1,5 +1,4 @@
 import { Injectable } from '@angular/core';
-import { ActivatedRoute } from '@angular/router';
 import { isNil } from 'lodash-es';
 import { combineLatest, Observable } from 'rxjs';
 import { map, shareReplay, take } from 'rxjs/operators';
@@ -38,7 +37,7 @@ export class PageTimeRangePreferenceService {
       map(([pageTimeRangeStringDictionary, featureState]) => {
         if (featureState === FeatureState.Enabled) {
           if (isNil(pageTimeRangeStringDictionary[rootLevelPath])) {
-            return () => this.getDefaultTimeRangeForCurrentRoute();
+            return () => this.getDefaultTimeRangeForPath(rootLevelPath);
           }
 
           return () => this.timeRangeService.timeRangeFromUrlString(pageTimeRangeStringDictionary[rootLevelPath]);
@@ -78,11 +77,14 @@ export class PageTimeRangePreferenceService {
       .pipe(shareReplay(1));
   }
 
-  public getDefaultTimeRangeForCurrentRoute(): TimeRange {
-    const currentRoute: ActivatedRoute = this.navigationService.getCurrentActivatedRoute();
-    // Right side for when FF is enabled but 'defaultTimeRange' is not set on AR data
+  public getDefaultTimeRangeForPath(rootLevelPath: string): TimeRange {
+    const routeConfigForPath = this.navigationService.getRouteConfig(
+      [rootLevelPath],
+      this.navigationService.rootRoute()
+    );
 
-    return currentRoute.snapshot.data?.defaultTimeRange ?? this.getGlobalDefaultTimeRange();
+    // Right side for when FF is enabled but 'defaultTimeRange' is not set on AR data
+    return routeConfigForPath?.data?.defaultTimeRange ?? this.getGlobalDefaultTimeRange();
   }
 
   public getGlobalDefaultTimeRange(): TimeRange {

projects/common/src/time/time-range.service.test.ts

@@ -1,13 +1,13 @@
 import { ActivatedRoute, convertToParamMap } from '@angular/router';
-import { runFakeRxjs } from '@hypertrace/test-utils';
+import { recordObservable, runFakeRxjs } from '@hypertrace/test-utils';
 import { createServiceFactory, mockProvider } from '@ngneat/spectator/jest';
-import { NEVER, Observable, of } from 'rxjs';
+import { NEVER, Observable, of, Subject } from 'rxjs';
 import { map } from 'rxjs/operators';
-import { NavigationService } from '../navigation/navigation.service';
+import { NavigationService, QueryParamObject } from '../navigation/navigation.service';
 import { FixedTimeRange } from './fixed-time-range';
 import { TimeRangeService } from './time-range.service';
 
-describe('Time range service', () => {
+describe('Time range(TR) service', () => {
   let timeRange$: Observable<string> = NEVER;
   const buildService = createServiceFactory({
     service: TimeRangeService,
@@ -18,12 +18,19 @@ describe('Time range service', () => {
             map(
               initialTrString =>
                 // tslint:disable-next-line: no-object-literal-type-assertion
-                ({
-                  queryParamMap: of(convertToParamMap({ time: initialTrString }))
-                } as ActivatedRoute)
+                (({
+                  queryParamMap: of(convertToParamMap({ time: initialTrString, refresh: 'true' })),
+                  snapshot: { queryParamMap: convertToParamMap({ time: initialTrString, refresh: 'true' }) }
+                } as unknown) as ActivatedRoute)
             )
           );
-        }
+        },
+        getQueryParameter: jest
+          .fn()
+          .mockReturnValueOnce('1573255100253-1573255111159')
+          .mockReturnValue('1573255111159-1573455111990'),
+        getCurrentActivatedRoute: () =>
+          (({ snapshot: { queryParams: { time: 'test-value' } } } as unknown) as ActivatedRoute)
       })
     ]
   });
@@ -34,57 +41,120 @@ describe('Time range service', () => {
   });
 
   test('returns time range when requested after init', () => {
-    timeRange$ = of('1573255100253-1573255111159');
-    const spectator = buildService();
-    expect(spectator.service.getCurrentTimeRange()).toEqual(
-      new FixedTimeRange(new Date(1573255100253), new Date(1573255111159))
-    );
-  });
-
-  test('returns observable that emits future time range changes including initialization', () => {
-    const lateArrivingTimeRange = new FixedTimeRange(new Date(1573255111159), new Date(1573255111160));
     runFakeRxjs(({ cold, expectObservable }) => {
-      timeRange$ = cold('1ms x', {
+      timeRange$ = cold('x|', {
         x: '1573255100253-1573255111159'
       });
 
       const spectator = buildService();
+
       expect(() => spectator.service.getCurrentTimeRange()).toThrow();
 
-      cold('5ms x').subscribe(() =>
-        spectator.service.setFixedRange(lateArrivingTimeRange.startTime, lateArrivingTimeRange.endTime)
-      );
+      expectObservable(spectator.service.getTimeRangeAndChanges()).toBe('x', {
+        x: new FixedTimeRange(new Date(1573255100253), new Date(1573255111159))
+      });
+    });
+  });
 
-      expectObservable(spectator.service.getTimeRangeAndChanges()).toBe('1ms x 3ms y', {
+  test('returns observable that emits future time range changes including initialization', () => {
+    const firstArrivingTimeRange = new FixedTimeRange(new Date(1573255100253), new Date(1573255111159));
+    const secondArrivingTimeRange = new FixedTimeRange(new Date(1573255111159), new Date(1573455111990));
+
+    runFakeRxjs(({ cold, expectObservable }) => {
+      const spectator = buildService({
+        providers: [
+          mockProvider(NavigationService, {
+            navigation$: cold('-x---y', {
+              x: ({
+                queryParamMap: of(convertToParamMap({ time: firstArrivingTimeRange.toUrlString(), refresh: 'true' })),
+                snapshot: {
+                  queryParamMap: convertToParamMap({ time: firstArrivingTimeRange.toUrlString(), refresh: 'true' })
+                }
+              } as unknown) as ActivatedRoute,
+              y: ({
+                queryParamMap: of(convertToParamMap({ time: secondArrivingTimeRange.toUrlString(), refresh: 'true' })),
+                snapshot: {
+                  queryParamMap: convertToParamMap({ time: secondArrivingTimeRange.toUrlString(), refresh: 'true' })
+                }
+              } as unknown) as ActivatedRoute
+            }),
+            getQueryParameter: jest
+              .fn()
+              .mockReturnValueOnce(firstArrivingTimeRange.toUrlString())
+              .mockReturnValue(secondArrivingTimeRange.toUrlString()),
+            getCurrentActivatedRoute: () =>
+              (({ snapshot: { queryParams: { time: 'test-value' } } } as unknown) as ActivatedRoute)
+          })
+        ]
+      });
+
+      const recordedTimeRanges = recordObservable(spectator.service.getTimeRangeAndChanges());
+
+      expect(() => spectator.service.getCurrentTimeRange()).toThrow();
+
+      expectObservable(recordedTimeRanges).toBe('-x----y', {
         x: new FixedTimeRange(new Date(1573255100253), new Date(1573255111159)),
-        y: lateArrivingTimeRange
+        y: secondArrivingTimeRange
       });
     });
   });
 
-  test('returns observable that emits current time range and later changes', () => {
-    const lateArrivingTimeRange = new FixedTimeRange(new Date(1573255111159), new Date(1573255111160));
-    runFakeRxjs(({ cold, expectObservable }) => {
-      timeRange$ = of('1573255100253-1573255111159');
+  test('Emits default TR when set, then subsequent first and second TRs from query param changes', () => {
+    const defaultTimeRange = new FixedTimeRange(new Date(1573277100277), new Date(1573277100277));
+    const firstArrivingTimeRange = new FixedTimeRange(new Date(1573255100253), new Date(1573255111159));
+    const secondArrivingTimeRange = new FixedTimeRange(new Date(1573255111159), new Date(1573455111990));
+    const mockNavigation$ = new Subject();
+    runFakeRxjs(({ expectObservable, cold }) => {
+      const spectator = buildService({
+        providers: [
+          mockProvider(NavigationService, {
+            navigation$: mockNavigation$.asObservable().pipe(
+              map(
+                timeRangeString =>
+                  (({
+                    queryParamMap: of(convertToParamMap({ time: timeRangeString, refresh: 'true' })),
+                    snapshot: {
+                      queryParamMap: convertToParamMap({ time: timeRangeString, refresh: 'true' })
+                    }
+                  } as unknown) as ActivatedRoute)
+              )
+            ),
+            addQueryParametersToUrl: (newParams: QueryParamObject) => mockNavigation$.next(newParams.time as string),
+            getQueryParameter: jest
+              .fn()
+              .mockReturnValueOnce('1573277100277-1573277100277')
+              .mockReturnValueOnce('1573255100253-1573255111159')
+              .mockReturnValue('1573255111159-1573455111990'),
+            getCurrentActivatedRoute: () =>
+              (({ snapshot: { queryParams: { time: 'test-value' } } } as unknown) as ActivatedRoute),
+            replaceQueryParametersInUrl: jest.fn()
+          })
+        ]
+      });
 
-      const spectator = buildService();
-      expect(spectator.service.getCurrentTimeRange()).toEqual(
-        new FixedTimeRange(new Date(1573255100253), new Date(1573255111159))
+      cold('x').subscribe(() => spectator.service.setDefaultTimeRange(defaultTimeRange));
+
+      cold('2ms y').subscribe(() =>
+        spectator.service.setFixedRange(firstArrivingTimeRange.startTime, firstArrivingTimeRange.endTime)
       );
-      cold('5ms x').subscribe(() =>
-        spectator.service.setFixedRange(lateArrivingTimeRange.startTime, lateArrivingTimeRange.endTime)
+
+      cold('5ms z').subscribe(() =>
+        spectator.service.setFixedRange(secondArrivingTimeRange.startTime, secondArrivingTimeRange.endTime)
       );
 
-      expectObservable(spectator.service.getTimeRangeAndChanges()).toBe('x 4ms y', {
-        x: new FixedTimeRange(new Date(1573255100253), new Date(1573255111159)),
-        y: lateArrivingTimeRange
+      expectObservable(spectator.service.getTimeRangeAndChanges()).toBe('x 1ms y 2ms z', {
+        x: defaultTimeRange,
+        y: firstArrivingTimeRange,
+        z: secondArrivingTimeRange
       });
     });
   });
 
   test('returns custom time filter', () => {
     const spectator = buildService();
-    expect(spectator.service.toQueryParams(new Date(1642296703000), new Date(1642396703000))).toStrictEqual({
+    expect(
+      spectator.service.toQueryParams(new FixedTimeRange(new Date(1642296703000), new Date(1642396703000)))
+    ).toStrictEqual({
       ['time']: new FixedTimeRange(new Date(1642296703000), new Date(1642396703000)).toUrlString()
     });
   });