add ldn services test

src/app/admin/admin-ldn-services/ldn-services-data/ldn-itemfilter-data.service.spec.ts

@@ -1,19 +1,19 @@
-import { TestScheduler } from "rxjs/testing";
-import { LdnItemfiltersService } from "./ldn-itemfilters-data.service";
-import { RequestService } from "../../../core/data/request.service";
-import { RemoteDataBuildService } from "../../../core/cache/builders/remote-data-build.service";
-import { ObjectCacheService } from "../../../core/cache/object-cache.service";
-import { HALEndpointService } from "../../../core/shared/hal-endpoint.service";
-import { NotificationsService } from "../../../shared/notifications/notifications.service";
-import { RequestEntry } from "../../../core/data/request-entry.model";
-import { RemoteData } from "../../../core/data/remote-data";
-import { RequestEntryState } from "../../../core/data/request-entry-state.model";
-import { cold, getTestScheduler } from "jasmine-marbles";
-import { RestResponse } from "../../../core/cache/response.models";
-import { of } from "rxjs";
-import { createSuccessfulRemoteDataObject$ } from "../../../shared/remote-data.utils";
-import { FindAllData } from "../../../core/data/base/find-all-data";
-import { testFindAllDataImplementation } from "../../../core/data/base/find-all-data.spec";
+import { TestScheduler } from 'rxjs/testing';
+import { LdnItemfiltersService } from './ldn-itemfilters-data.service';
+import { RequestService } from '../../../core/data/request.service';
+import { RemoteDataBuildService } from '../../../core/cache/builders/remote-data-build.service';
+import { ObjectCacheService } from '../../../core/cache/object-cache.service';
+import { HALEndpointService } from '../../../core/shared/hal-endpoint.service';
+import { NotificationsService } from '../../../shared/notifications/notifications.service';
+import { RequestEntry } from '../../../core/data/request-entry.model';
+import { RemoteData } from '../../../core/data/remote-data';
+import { RequestEntryState } from '../../../core/data/request-entry-state.model';
+import { cold, getTestScheduler } from 'jasmine-marbles';
+import { RestResponse } from '../../../core/cache/response.models';
+import { of } from 'rxjs';
+import { createSuccessfulRemoteDataObject$ } from '../../../shared/remote-data.utils';
+import { FindAllData } from '../../../core/data/base/find-all-data';
+import { testFindAllDataImplementation } from '../../../core/data/base/find-all-data.spec';
 
 describe('LdnItemfiltersService test', () => {
   let scheduler: TestScheduler;
@@ -78,8 +78,12 @@ describe('LdnItemfiltersService test', () => {
   });
 
   describe('get endpoint', () => {
-    service.getEndpoint()
-    expect(halService.getEndpoint).toHaveBeenCalledWith('linkPath')
+    it('should retrieve correct endpoint', (done) => {
+      service.getEndpoint().subscribe(() => {
+        expect(halService.getEndpoint).toHaveBeenCalledWith('itemfilters');
+        done();
+      });
+    });
   });
 
 });

src/app/admin/admin-ldn-services/ldn-services-data/ldn-services-data.service.spec.ts

@@ -0,0 +1,116 @@
+import { TestScheduler } from 'rxjs/testing';
+import { RequestService } from '../../../core/data/request.service';
+import { RemoteDataBuildService } from '../../../core/cache/builders/remote-data-build.service';
+import { ObjectCacheService } from '../../../core/cache/object-cache.service';
+import { HALEndpointService } from '../../../core/shared/hal-endpoint.service';
+import { NotificationsService } from '../../../shared/notifications/notifications.service';
+import { RequestEntry } from '../../../core/data/request-entry.model';
+import { RemoteData } from '../../../core/data/remote-data';
+import { RequestEntryState } from '../../../core/data/request-entry-state.model';
+import { cold, getTestScheduler } from 'jasmine-marbles';
+import { RestResponse } from '../../../core/cache/response.models';
+import { of as observableOf } from 'rxjs';
+import { createSuccessfulRemoteDataObject$ } from '../../../shared/remote-data.utils';
+import { FindAllData } from '../../../core/data/base/find-all-data';
+import { testFindAllDataImplementation } from '../../../core/data/base/find-all-data.spec';
+import { LdnServicesService } from './ldn-services-data.service';
+import { testDeleteDataImplementation } from '../../../core/data/base/delete-data.spec';
+import { DeleteData } from '../../../core/data/base/delete-data';
+import { testSearchDataImplementation } from '../../../core/data/base/search-data.spec';
+import { SearchData } from '../../../core/data/base/search-data';
+import { testPatchDataImplementation } from '../../../core/data/base/patch-data.spec';
+import { PatchData } from '../../../core/data/base/patch-data';
+import { CreateData } from '../../../core/data/base/create-data';
+import { testCreateDataImplementation } from '../../../core/data/base/create-data.spec';
+import { FindListOptions } from '../../../core/data/find-list-options.model';
+import { RequestParam } from '../../../core/cache/models/request-param.model';
+import { mockLdnService } from '../ldn-service-serviceMock/ldnServicesRD$-mock';
+import { createPaginatedList } from '../../../shared/testing/utils.test';
+
+
+describe('LdnServicesService test', () => {
+    let scheduler: TestScheduler;
+    let service: LdnServicesService;
+    let requestService: RequestService;
+    let rdbService: RemoteDataBuildService;
+    let objectCache: ObjectCacheService;
+    let halService: HALEndpointService;
+    let notificationsService: NotificationsService;
+    let responseCacheEntry: RequestEntry;
+
+    const endpointURL = `https://rest.api/rest/api/ldn/ldnservices`;
+    const requestUUID = '8b3c613a-5a4b-438b-9686-be1d5b4a1c5a';
+
+    const remoteDataMocks = {
+        Success: new RemoteData(null, null, null, RequestEntryState.Success, null, null, 200),
+    };
+
+    function initTestService() {
+        return new LdnServicesService(
+            requestService,
+            rdbService,
+            objectCache,
+            halService,
+            notificationsService,
+        );
+    }
+
+    beforeEach(() => {
+        scheduler = getTestScheduler();
+
+        objectCache = {} as ObjectCacheService;
+        notificationsService = {} as NotificationsService;
+        responseCacheEntry = new RequestEntry();
+        responseCacheEntry.request = { href: 'https://rest.api/' } as any;
+        responseCacheEntry.response = new RestResponse(true, 200, 'Success');
+
+        requestService = jasmine.createSpyObj('requestService', {
+            generateRequestId: requestUUID,
+            send: true,
+            removeByHrefSubstring: {},
+            getByHref: observableOf(responseCacheEntry),
+            getByUUID: observableOf(responseCacheEntry),
+        });
+
+        halService = jasmine.createSpyObj('halService', {
+            getEndpoint: observableOf(endpointURL)
+        });
+
+        rdbService = jasmine.createSpyObj('rdbService', {
+            buildSingle: createSuccessfulRemoteDataObject$({}, 500),
+            buildList: cold('a', { a: remoteDataMocks.Success })
+        });
+
+
+        service = initTestService();
+    });
+
+    describe('composition', () => {
+        const initFindAllService = () => new LdnServicesService(null, null, null, null, null) as unknown as FindAllData<any>;
+        const initDeleteService = () => new LdnServicesService(null, null, null, null, null) as unknown as DeleteData<any>;
+        const initSearchService = () => new LdnServicesService(null, null, null, null, null) as unknown as SearchData<any>;
+        const initPatchService = () => new LdnServicesService(null, null, null, null, null) as unknown as PatchData<any>;
+        const initCreateService = () => new LdnServicesService(null, null, null, null, null) as unknown as CreateData<any>;
+
+        testFindAllDataImplementation(initFindAllService);
+        testDeleteDataImplementation(initDeleteService);
+        testSearchDataImplementation(initSearchService);
+        testPatchDataImplementation(initPatchService);
+        testCreateDataImplementation(initCreateService);
+    });
+
+    describe('custom methods', () => {
+        it('should find service by inbound pattern', (done) => {
+            const params = [new RequestParam('pattern', 'testPattern')];
+            const findListOptions = Object.assign(new FindListOptions(), {}, {searchParams: params});
+            spyOn(service, 'searchBy').and.returnValue(observableOf(null));
+            spyOn((service as any).searchData, 'searchBy').and.returnValue(createSuccessfulRemoteDataObject$(createPaginatedList([mockLdnService])));
+
+            service.findByInboundPattern('testPattern').subscribe((result) => {
+                expect(service.searchBy).toHaveBeenCalledWith('byInboundPattern', findListOptions, undefined, undefined );
+                done();
+            });
+        });
+    });
+
+});

src/app/admin/admin-ldn-services/ldn-services-data/ldn-services-data.service.ts

@@ -29,8 +29,6 @@ import {Operation} from 'fast-json-patch';
 import {RestRequestMethod} from '../../../core/data/rest-request-method';
 import {CreateData, CreateDataImpl} from '../../../core/data/base/create-data';
 import {LdnServiceConstrain} from '../ldn-services-model/ldn-service.constrain.model';
-import {getFirstCompletedRemoteData} from '../../../core/shared/operators';
-import {hasValue} from '../../../shared/empty.util';
 import {SearchDataImpl} from '../../../core/data/base/search-data';
 import {RequestParam} from '../../../core/cache/models/request-param.model';
 
@@ -77,10 +75,11 @@ export class LdnServicesService extends IdentifiableDataService<LdnService> impl
    * Creates an LDN service by sending a POST request to the REST API.
    *
    * @param {LdnService} object - The LDN service object to be created.
+   * @param params Array with additional params to combine with query string
    * @returns {Observable<RemoteData<LdnService>>} - Observable containing the result of the creation operation.
    */
-  create(object: LdnService): Observable<RemoteData<LdnService>> {
-    return this.createData.create(object);
+  create(object: LdnService, ...params: RequestParam[]): Observable<RemoteData<LdnService>> {
+    return this.createData.create(object, ...params);
   }
 
   /**
@@ -149,7 +148,7 @@ export class LdnServicesService extends IdentifiableDataService<LdnService> impl
   findByInboundPattern(pattern: string, options?: FindListOptions, useCachedVersionIfAvailable?: boolean, reRequestOnStale?: boolean, ...linksToFollow: FollowLinkConfig<LdnService>[]): Observable<RemoteData<PaginatedList<LdnService>>> {
     const params = [new RequestParam('pattern', pattern)];
     const findListOptions = Object.assign(new FindListOptions(), options, {searchParams: params});
-    return this.searchData.searchBy(this.findByPatternEndpoint, findListOptions, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
+    return this.searchBy(this.findByPatternEndpoint, findListOptions, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
   }
 
   /**
@@ -174,6 +173,25 @@ export class LdnServicesService extends IdentifiableDataService<LdnService> impl
     return this.deleteData.deleteByHref(href, copyVirtualMetadata);
   }
 
+
+  /**
+   * Make a new FindListRequest with given search method
+   *
+   * @param searchMethod                The search method for the object
+   * @param options                     The [[FindListOptions]] object
+   * @param useCachedVersionIfAvailable If this is true, the request will only be sent if there's
+   *                                    no valid cached version. Defaults to true
+   * @param reRequestOnStale            Whether or not the request should automatically be re-
+   *                                    requested after the response becomes stale
+   * @param linksToFollow               List of {@link FollowLinkConfig} that indicate which
+   *                                    {@link HALLink}s should be automatically resolved
+   * @return {Observable<RemoteData<PaginatedList<T>>}
+   *    Return an observable that emits response from the server
+   */
+  public searchBy(searchMethod: string, options?: FindListOptions, useCachedVersionIfAvailable?: boolean, reRequestOnStale?: boolean, ...linksToFollow: FollowLinkConfig<LdnService>[]): Observable<RemoteData<PaginatedList<LdnService>>> {
+    return this.searchData.searchBy(searchMethod, options, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
+  }
+
   public invoke(serviceName: string, serviceId: string, parameters: LdnServiceConstrain[], files: File[]): Observable<RemoteData<LdnService>> {
     const requestId = this.requestService.generateRequestId();
     this.getBrowseEndpoint().pipe(
@@ -188,15 +206,6 @@ export class LdnServicesService extends IdentifiableDataService<LdnService> impl
     return this.rdbService.buildFromRequestUUID<LdnService>(requestId);
   }
 
-  public ldnServiceWithNameExistsAndCanExecute(scriptName: string): Observable<boolean> {
-    return this.findById(scriptName).pipe(
-      getFirstCompletedRemoteData(),
-      map((rd: RemoteData<LdnService>) => {
-        return hasValue(rd.payload);
-      }),
-    );
-  }
-
   private getInvocationFormData(constrain: LdnServiceConstrain[], files: File[]): FormData {
     const form: FormData = new FormData();
     form.set('properties', JSON.stringify(constrain));