From 76dcaa6d8dbbfb16803ea3b0b04d4c4ac8e08df3 Mon Sep 17 00:00:00 2001
From: Ryan Mathis <rmathis@unicon.net>
Date: Tue, 13 Aug 2019 08:27:44 -0700
Subject: [PATCH] Fixed unit test

---
 .../service/configuration.service.spec.ts     | 37 ++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

diff --git a/ui/src/app/metadata/configuration/service/configuration.service.spec.ts b/ui/src/app/metadata/configuration/service/configuration.service.spec.ts
index 40bfb39ac..43fd99c05 100644
--- a/ui/src/app/metadata/configuration/service/configuration.service.spec.ts
+++ b/ui/src/app/metadata/configuration/service/configuration.service.spec.ts
@@ -7,10 +7,14 @@ import { MetadataSourceEditor } from '../../domain/model/wizards/metadata-source
 import { ResolverService } from '../../domain/service/resolver.service';
 import { of } from 'rxjs';
 import { MetadataProviderService } from '../../domain/service/provider.service';
+import { Metadata } from '../../domain/domain.type';
+import { SCHEMA } from '../../../../testing/form-schema.stub';
+import { getConfigurationSectionsFn } from '../reducer';
 
 describe(`Configuration Service`, () => {
 
     let resolverService: any;
+    let providerService: any;
 
     let mockService = {
         find: () => of([])
@@ -36,11 +40,12 @@ describe(`Configuration Service`, () => {
         });
 
         resolverService = TestBed.get(ResolverService);
+        providerService = TestBed.get(MetadataProviderService);
 
     });
 
     describe('find method', () => {
-        it(`should send an expected GET request`, async(inject([MetadataConfigurationService, HttpTestingController],
+        it(`should call the resolver service when type is resolver`, async(inject([MetadataConfigurationService, HttpTestingController],
             (service: MetadataConfigurationService, backend: HttpTestingController) => {
                 spyOn(resolverService, 'find').and.callThrough();
                 const type = 'resolver';
@@ -49,6 +54,25 @@ describe(`Configuration Service`, () => {
                 expect(resolverService.find).toHaveBeenCalledWith(id);
             }
         )));
+        it(`should call the provider service when type is resolver`, async(inject([MetadataConfigurationService, HttpTestingController],
+            (service: MetadataConfigurationService, backend: HttpTestingController) => {
+                spyOn(providerService, 'find').and.callThrough();
+                const type = 'provider';
+                const id = 'foo';
+                service.find(id, type).subscribe();
+                expect(providerService.find).toHaveBeenCalledWith(id);
+            }
+        )));
+        it(`should throw an error when a type is not found`, async(inject([MetadataConfigurationService, HttpTestingController],
+            (service: MetadataConfigurationService, backend: HttpTestingController) => {
+                spyOn(providerService, 'find').and.callThrough();
+                const type = 'bar';
+                const id = 'foo';
+                service.find(id, type).subscribe(null, (err) => {
+                    expect(err).toEqual(new Error('Type not supported'));
+                });
+            }
+        )));
     });
 
     describe('loadSchema method', () => {
@@ -79,4 +103,15 @@ describe(`Configuration Service`, () => {
             }
         )));
     });
+
+    describe('getMetadataConfiguration method', () => {
+        it('should return the parsed configuration', async(inject([MetadataConfigurationService],
+            (service: MetadataConfigurationService) => {
+                const model = {} as Metadata;
+                const definition = {steps: []};
+                const expected = getConfigurationSectionsFn([model], definition, SCHEMA);
+                expect(service.getMetadataConfiguration(model, definition, SCHEMA)).toEqual(expected);
+            }
+        )));
+    });
 });