aggregation-mapping-resource.service.spec.ts

import { AggregationMappingResource } from '@admin-client/reporting-shared';
import { ROUTES } from '@admin-client/shared';
import { NavigationService, RouteData } from '@alfa-client/navigation-shared';
import {
  createEmptyStateResource,
  createStateResource,
  decodeUrlFromEmbedding,
  ResourceRepository,
  ResourceServiceConfig,
  StateResource,
} from '@alfa-client/tech-shared';
import { Mock, mock, useFromMock } from '@alfa-client/test-utils';
import { UrlSegment } from '@angular/router';
import { faker } from '@faker-js/faker';
import { afterAll, expect } from '@jest/globals';
import { ResourceUri } from '@ngxp/rest';
import { Observable, of } from 'rxjs';
import { createRouteData, createUrlSegment } from '../../../../navigation-shared/test/navigation-test-factory';
import { singleColdCompleted } from '../../../../tech-shared/test/marbles';
import { createAggregationMappingResource } from '../../test/aggregation-mapping';
import * as module from './aggregation-mapping-resource.service';

jest.mock('@alfa-client/tech-shared', () => ({
  ...jest.requireActual('@alfa-client/tech-shared'),
  decodeUrlFromEmbedding: jest.fn(),
}));

const decodeUrlFromEmbeddingMock: jest.Mock = decodeUrlFromEmbedding as jest.Mock;

describe('AggregationMappingResourceService', () => {
  let repository: Mock<ResourceRepository>;
  let navigationService: Mock<NavigationService>;

  beforeEach(() => {
    repository = mock(ResourceRepository);
    navigationService = mock(NavigationService);
  });

  describe('build config', () => {
    const _getResourceByNavigationRoute: jest.SpyInstance = jest
      .spyOn(module, '_getResourceByNavigationRoute')
      .mockImplementation();

    afterAll(() => {
      _getResourceByNavigationRoute.mockRestore();
    });

    it('should get resource by navigation route', () => {
      module._buildResourceServiceConfig(useFromMock(repository), useFromMock(navigationService));

      expect(_getResourceByNavigationRoute).toHaveBeenCalled();
    });

    it('should have aggregation mapping static resource', () => {
      const staticResource: StateResource<AggregationMappingResource> = createStateResource(createAggregationMappingResource());
      _getResourceByNavigationRoute.mockReturnValue(of(staticResource));

      const config: ResourceServiceConfig<AggregationMappingResource> = module._buildResourceServiceConfig(
        useFromMock(repository),
        useFromMock(navigationService),
      );

      expect(config.resource).toBeObservable(singleColdCompleted(staticResource));
    });
  });

  describe('get resource by navigation route', () => {
    const routeData: RouteData = createRouteData();
    const _isAggregationMappingEditUrl: jest.SpyInstance = jest
      .spyOn(module, '_isAggregationMappingEditUrl')
      .mockImplementation();
    const _getAggregationMappingResourceByRoute: jest.SpyInstance = jest
      .spyOn(module, '_getAggregationMappingResourceByRoute')
      .mockImplementation();

    beforeEach(() => {
      navigationService.getCurrentRouteData.mockReturnValue(of(routeData));
    });

    afterAll(() => {
      _isAggregationMappingEditUrl.mockRestore();
      _getAggregationMappingResourceByRoute.mockRestore();
    });

    it('should get current route data', () => {
      module._getResourceByNavigationRoute(useFromMock(repository), useFromMock(navigationService)).subscribe();

      expect(navigationService.getCurrentRouteData).toHaveBeenCalled();
    });

    it('should check if url contains resource uri', () => {
      module._getResourceByNavigationRoute(useFromMock(repository), useFromMock(navigationService)).subscribe();

      expect(_isAggregationMappingEditUrl).toHaveBeenCalled();
    });

    it('should get aggregation mapping resource by route', () => {
      module._getResourceByNavigationRoute(useFromMock(repository), useFromMock(navigationService)).subscribe();

      expect(_getAggregationMappingResourceByRoute).toHaveBeenCalled();
    });

    it('should return aggregation mapping by route', () => {
      const stateResource: StateResource<AggregationMappingResource> = createStateResource(createAggregationMappingResource());
      _getAggregationMappingResourceByRoute.mockReturnValue(of(stateResource));
      _isAggregationMappingEditUrl.mockReturnValue(true);

      const resourceByRoute$: Observable<StateResource<AggregationMappingResource>> = module._getResourceByNavigationRoute(
        useFromMock(repository),
        useFromMock(navigationService),
      );

      expect(resourceByRoute$).toBeObservable(singleColdCompleted(stateResource));
    });

    it('should return empty state resource', () => {
      const stateResource: StateResource<AggregationMappingResource> = createEmptyStateResource();
      _isAggregationMappingEditUrl.mockReturnValue(false);

      const resourceByRoute$: Observable<StateResource<AggregationMappingResource>> = module._getResourceByNavigationRoute(
        useFromMock(repository),
        useFromMock(navigationService),
      );

      expect(resourceByRoute$).toBeObservable(singleColdCompleted(stateResource));
    });
  });

  describe('is aggregation mapping edit url', () => {
    it.each([0, 1, 3])('should return false of wrong number of segments = %d', (numberOfSegments: number) => {
      const routeData: RouteData = {
        ...createRouteData(),
        urlSegments: Array(numberOfSegments).fill(createUrlSegment()),
      };

      expect(module._isAggregationMappingEditUrl(routeData)).toBe(false);
    });

    it('should return false if first path is wrong', () => {
      const routeData: RouteData = {
        ...createRouteData(),
        urlSegments: Array(2).fill(createUrlSegment()),
      };

      expect(module._isAggregationMappingEditUrl(routeData)).toBe(false);
    });

    it('should return false if second path is wrong', () => {
      const firstUrlSegment: UrlSegment = createUrlSegment();
      firstUrlSegment.path = ROUTES.AGGREGATION_MAPPING;
      const secondUrlSegment: UrlSegment = createUrlSegment();
      secondUrlSegment.path = 'neu';
      const routeData: RouteData = {
        ...createRouteData(),
        urlSegments: [firstUrlSegment, secondUrlSegment],
      };

      expect(module._isAggregationMappingEditUrl(routeData)).toBe(false);
    });

    it('should return true', () => {
      const firstUrlSegment: UrlSegment = createUrlSegment();
      firstUrlSegment.path = ROUTES.AGGREGATION_MAPPING;
      const secondUrlSegment: UrlSegment = createUrlSegment();
      secondUrlSegment.path = faker.internet.url();
      const routeData: RouteData = {
        ...createRouteData(),
        urlSegments: [firstUrlSegment, secondUrlSegment],
      };

      expect(module._isAggregationMappingEditUrl(routeData)).toBe(true);
    });
  });

  describe('get aggregation mapping resource by route', () => {
    const firstUrlSegment: UrlSegment = createUrlSegment();
    firstUrlSegment.path = ROUTES.AGGREGATION_MAPPING;
    const secondUrlSegment: UrlSegment = createUrlSegment();
    secondUrlSegment.path = faker.internet.url();
    const routeData: RouteData = {
      ...createRouteData(),
      urlSegments: [firstUrlSegment, secondUrlSegment],
    };
    const uri: ResourceUri = faker.internet.url();
    const resource: AggregationMappingResource = createAggregationMappingResource();

    beforeEach(() => {
      decodeUrlFromEmbeddingMock.mockReturnValue(uri);
      repository.getResource.mockReturnValue(of(resource));
    });

    it('should decode url', () => {
      module._getAggregationMappingResourceByRoute(useFromMock(repository), routeData);

      expect(decodeUrlFromEmbeddingMock).toHaveBeenCalledWith(secondUrlSegment.path);
    });

    it('should get resource', () => {
      module._getAggregationMappingResourceByRoute(useFromMock(repository), routeData);

      expect(repository.getResource).toHaveBeenCalledWith(uri);
    });

    it('should return state resource', () => {
      const stateResource$: Observable<StateResource<AggregationMappingResource>> = module._getAggregationMappingResourceByRoute(
        useFromMock(repository),
        routeData,
      );

      expect(stateResource$).toBeObservable(singleColdCompleted(createStateResource(resource)));
    });
  });
});