diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversVersioningMetadataTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversVersioningMetadataTests.groovy
index 9eed8e2bc..3bc1a2f98 100644
--- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversVersioningMetadataTests.groovy
+++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversVersioningMetadataTests.groovy
@@ -60,9 +60,9 @@ class EnversVersioningMetadataTests extends Specification {
 
         then:
         mrVersions[0].creator == mr.createdBy
-        mrVersions[0].date == mr.createdDateAsZonedDateTime()
+        mrVersions[0].date == mr.modifiedDateAsZonedDateTime()
         edVersions[0].creator == ed.createdBy
-        edVersions[0].date == ed.createdDateAsZonedDateTime()
+        edVersions[0].date == ed.modifiedDateAsZonedDateTime()
 
         when: 'new version due to update'
         mr.name = 'UPDATED'
diff --git a/ui/src/app/metadata/configuration/component/history-list.component.html b/ui/src/app/metadata/configuration/component/history-list.component.html
index 82a275060..db658f453 100644
--- a/ui/src/app/metadata/configuration/component/history-list.component.html
+++ b/ui/src/app/metadata/configuration/component/history-list.component.html
@@ -23,7 +23,7 @@
             </td>
             <td *ngIf="i === 0"><translate-i18n key="label.current">Current</translate-i18n> (v{{ history.length - i }})</td>
             <td *ngIf="i > 0">v{{ history.length - (i) }}</td>
-            <td>{{ version.date | date:'medium' }}</td>
+            <td>{{ version.date | date:DATE_FORMAT }}</td>
             <td>{{ version.creator }}</td>
             <td>
                 <button class="btn btn-link" (click)="restore.emit(version)">
diff --git a/ui/src/app/metadata/configuration/component/history-list.component.ts b/ui/src/app/metadata/configuration/component/history-list.component.ts
index 7e03468e2..68e596ab5 100644
--- a/ui/src/app/metadata/configuration/component/history-list.component.ts
+++ b/ui/src/app/metadata/configuration/component/history-list.component.ts
@@ -1,6 +1,7 @@
 import { Component, Input, EventEmitter, ChangeDetectionStrategy, Output } from '@angular/core';
 import { MetadataHistory } from '../model/history';
 import { MetadataVersion } from '../model/version';
+import { CONFIG_DATE_FORMAT } from '../configuration.values';
 
 @Component({
     selector: 'history-list',
@@ -15,6 +16,8 @@ export class HistoryListComponent {
 
     selected: MetadataVersion[] = [];
 
+    DATE_FORMAT = CONFIG_DATE_FORMAT;
+
     constructor() {}
 
     toggleVersionSelected(version: MetadataVersion): void {
diff --git a/ui/src/app/metadata/configuration/component/metadata-configuration.component.html b/ui/src/app/metadata/configuration/component/metadata-configuration.component.html
index e45530ebf..f5ab2814b 100644
--- a/ui/src/app/metadata/configuration/component/metadata-configuration.component.html
+++ b/ui/src/app/metadata/configuration/component/metadata-configuration.component.html
@@ -23,7 +23,7 @@ <h2 class="title h4 m-0 flex-grow-1">
                     <strong [ngStyle]="{'width': width}" translate="label.option">Option</strong>
                     <strong *ngFor="let date of configuration.dates" [ngStyle]="{'width': width}">
                         <translate-i18n key="label.value" *ngIf="configuration.dates.length <= 1">Value</translate-i18n>
-                        <span *ngIf="configuration.dates.length > 1">{{ date | date:'medium' }}</span>
+                        <span *ngIf="configuration.dates.length > 1">{{ date | date:DATE_FORMAT }}</span>
                     </strong>
                 </div>
                 <object-property
diff --git a/ui/src/app/metadata/configuration/component/metadata-configuration.component.ts b/ui/src/app/metadata/configuration/component/metadata-configuration.component.ts
index 86e8bd23b..280c362a6 100644
--- a/ui/src/app/metadata/configuration/component/metadata-configuration.component.ts
+++ b/ui/src/app/metadata/configuration/component/metadata-configuration.component.ts
@@ -2,6 +2,7 @@ import { Component, ChangeDetectionStrategy, Input, Output, EventEmitter } from
 import { Router, ActivatedRoute } from '@angular/router';
 import { MetadataConfiguration } from '../model/metadata-configuration';
 import { Metadata } from '../../domain/domain.type';
+import { CONFIG_DATE_FORMAT } from '../configuration.values';
 
 @Component({
     selector: 'metadata-configuration',
@@ -18,6 +19,8 @@ export class MetadataConfigurationComponent {
 
     @Output() preview: EventEmitter<any> = new EventEmitter();
 
+    DATE_FORMAT = CONFIG_DATE_FORMAT;
+
     constructor(
         private router: Router,
         private activatedRoute: ActivatedRoute
diff --git a/ui/src/app/metadata/configuration/configuration.values.ts b/ui/src/app/metadata/configuration/configuration.values.ts
index 383486cfd..53c2279e9 100644
--- a/ui/src/app/metadata/configuration/configuration.values.ts
+++ b/ui/src/app/metadata/configuration/configuration.values.ts
@@ -13,3 +13,5 @@ export enum TYPES {
 export const DEFINITIONS = {
     resolver: MetadataSourceEditor
 };
+
+export const CONFIG_DATE_FORMAT = 'MMM dd, yyyy HH:mm:ss';
diff --git a/ui/src/app/metadata/configuration/container/metadata-options.component.html b/ui/src/app/metadata/configuration/container/metadata-options.component.html
index d99166c11..972e0e4da 100644
--- a/ui/src/app/metadata/configuration/container/metadata-options.component.html
+++ b/ui/src/app/metadata/configuration/container/metadata-options.component.html
@@ -48,7 +48,6 @@ <h2 class="title h4 m-0 ml-2 flex-grow-1">
             (onUpdateOrderDown)="updateOrderDown($event)"
             (onUpdateOrderUp)="updateOrderUp($event)"
             (onRemove)="removeFilter($event)"
-            (preview)="onPreview($event)"
             [filters]="filters$ | async"></filter-configuration-list>
     </div>
     <button class="btn btn-link" (click)="onScrollTo('header')">
diff --git a/ui/src/app/metadata/domain/entity/resolver/file-backed-http-metadata-resolver.spec.ts b/ui/src/app/metadata/domain/entity/resolver/file-backed-http-metadata-resolver.spec.ts
index 669033c19..627a22571 100644
--- a/ui/src/app/metadata/domain/entity/resolver/file-backed-http-metadata-resolver.spec.ts
+++ b/ui/src/app/metadata/domain/entity/resolver/file-backed-http-metadata-resolver.spec.ts
@@ -1,4 +1,5 @@
 import { FileBackedHttpMetadataResolver } from './file-backed-http-metadata-resolver';
+import { MetadataResolver } from '../../model';
 
 describe('Resolver construct', () => {
 
@@ -60,8 +61,8 @@ describe('Resolver construct', () => {
             }
         ],
         serviceEnabled: true,
-        createdDate: 'string (date)',
-        modifiedDate: 'string (date)',
+        createdDate: 'December 17, 1995 03:24:00',
+        modifiedDate: 'December 17, 1995 03:24:00',
         relyingPartyOverrides: {
             'signAssertion': true,
             'dontSignResponse': true,
@@ -83,11 +84,51 @@ describe('Resolver construct', () => {
             'mail'
         ]
     };
-    const entity = new FileBackedHttpMetadataResolver(config);
 
     it('should populate its own values', () => {
+        const entity = new FileBackedHttpMetadataResolver(config);
         Object.keys(config).forEach(key => {
             expect(entity[key]).toEqual(config[key]);
         });
     });
+
+    describe('isDraft method', () => {
+        it('should return false if no createDate defined', () => {
+            const entity = new FileBackedHttpMetadataResolver(config);
+            expect(entity.isDraft()).toBe(false);
+        });
+
+        it('should return false if no createDate defined', () => {
+            const { createdDate, ...rest } = config;
+            const entity = new FileBackedHttpMetadataResolver(rest as MetadataResolver);
+            expect(entity.isDraft()).toBe(true);
+        });
+    });
+
+    describe('getCreationDate method', () => {
+        it('should return false if no createDate defined', () => {
+            const entity = new FileBackedHttpMetadataResolver(config);
+            expect(entity.getCreationDate()).toBeDefined();
+        });
+
+        it('should return false if no createDate defined', () => {
+            const { createdDate, ...rest } = config;
+            const entity = new FileBackedHttpMetadataResolver(rest as MetadataResolver);
+            expect(entity.getCreationDate()).toBeNull();
+        });
+    });
+
+    describe('enabled getter', () => {
+        it('should return the serviceEnabled attribute', () => {
+            const entity = new FileBackedHttpMetadataResolver(config);
+            expect(entity.enabled).toBe(config.serviceEnabled);
+        });
+    });
+
+    describe('serialize method', () => {
+        it('should return itself', () => {
+            const entity = new FileBackedHttpMetadataResolver(config);
+            expect(entity.serialize()).toBe(entity);
+        });
+    });
 });
diff --git a/ui/src/app/metadata/domain/service/draft.service.spec.ts b/ui/src/app/metadata/domain/service/draft.service.spec.ts
index 199a301d9..f03da6906 100644
--- a/ui/src/app/metadata/domain/service/draft.service.spec.ts
+++ b/ui/src/app/metadata/domain/service/draft.service.spec.ts
@@ -1,6 +1,7 @@
 import { TestBed } from '@angular/core/testing';
 import { EntityDraftService } from './draft.service';
 import { FileBackedHttpMetadataResolver } from '../entity';
+import { MetadataResolver } from '../model';
 
 describe(`EntityDraftService`, () => {
     let service: EntityDraftService;
@@ -36,5 +37,71 @@ describe(`EntityDraftService`, () => {
                 done();
             });
         });
+
+        it(`should return a 404 error if not found`, (done: DoneFn) => {
+            let id = null;
+            service.find(id).subscribe(null, err => {
+                expect(err).toEqual(404);
+                done();
+            });
+        });
+    });
+
+    describe('exists', () => {
+        it('should check if the provided id exists in storage', () => {
+            spyOn(service.storage, 'query').and.returnValue([{id: 'bar'} as MetadataResolver]);
+            expect(service.exists('foo')).toBe(false);
+            expect(service.exists('bar')).toBe(true);
+        });
+
+        it('should use the provided attr', () => {
+            spyOn(service.storage, 'query').and.returnValue([
+                { id: 'bar', serviceProviderName: 'foo' } as MetadataResolver
+            ]);
+            expect(service.exists('foo', 'serviceProviderName')).toBe(true);
+            expect(service.exists('bar', 'serviceProviderName')).toBe(false);
+        });
+    });
+
+    describe('save', () => {
+        it('should add the provider to storage', () => {
+            const resolver = { id: 'bar' } as MetadataResolver;
+            spyOn(service.storage, 'add');
+            service.save(resolver).subscribe();
+            expect(service.storage.add).toHaveBeenCalledWith(resolver);
+        });
+    });
+
+    describe('remove', () => {
+        it('should remove the provider from storage', () => {
+            const resolver = { id: 'bar' } as MetadataResolver;
+            spyOn(service.storage, 'removeByAttr');
+            service.remove(resolver).subscribe();
+            expect(service.storage.removeByAttr).toHaveBeenCalledWith(resolver.id, 'id');
+        });
+    });
+
+    describe('update', () => {
+        it('should remove the provider from storage', () => {
+            const resolver = { id: 'bar' } as MetadataResolver;
+            const updates = { id: 'foo', serviceProviderName: 'bar' }; 
+            spyOn(service.storage, 'findByAttr').and.returnValue(resolver);
+            spyOn(service.storage, 'add');
+            spyOn(service.storage, 'removeByAttr');
+            service.update(resolver).subscribe();
+            expect(service.storage.removeByAttr).toHaveBeenCalled();
+            expect(service.storage.add).toHaveBeenCalled();
+            expect(service.storage.findByAttr).toHaveBeenCalled();
+        });
+
+        it('should return a 404 if not found', () => {
+            const resolver = { id: 'bar' } as MetadataResolver;
+            const updates = { id: 'foo', serviceProviderName: 'bar' };
+            spyOn(service.storage, 'findByAttr').and.returnValue(null);
+            service.update(resolver).subscribe(null, (err) => {
+                expect(err).toBe(404);
+                expect(service.storage.findByAttr).toHaveBeenCalled();
+            });
+        });
     });
 });
diff --git a/ui/src/app/metadata/domain/service/resolver.service.spec.ts b/ui/src/app/metadata/domain/service/resolver.service.spec.ts
index 71d7686e2..c11bb0dd5 100644
--- a/ui/src/app/metadata/domain/service/resolver.service.spec.ts
+++ b/ui/src/app/metadata/domain/service/resolver.service.spec.ts
@@ -30,13 +30,36 @@ describe(`Resolver Service`, () => {
             }
         )));
 
-        xit(`should emit 'true' for 200 Ok`, async(inject([ResolverService, HttpTestingController],
+        it(`should emit 'true' for 200 Ok`, async(inject([ResolverService, HttpTestingController],
             (service: ResolverService, backend: HttpTestingController) => {
                 service.query().subscribe((next) => {
                     expect(next).toBeTruthy();
                 });
 
-                backend.expectOne('/api/EntityDescriptors').flush([], { status: 200, statusText: 'Ok' });
+                backend.expectOne('/api/EntityDescriptors').flush(['foo'], { status: 200, statusText: 'Ok' });
+            }
+        )));
+    });
+
+    describe('queryForAdmin', () => {
+        it(`should send an expected query request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.queryForAdmin().subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === '/api/EntityDescriptor/disabledNonAdmin'
+                        && req.method === 'GET';
+                }, `GET EntityDescriptors collection for an admin`);
+            }
+        )));
+
+        it(`should emit 'true' for 200 Ok`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.queryForAdmin().subscribe((next) => {
+                    expect(next).toBeTruthy();
+                });
+
+                backend.expectOne('/api/EntityDescriptor/disabledNonAdmin').flush(['foo'], { status: 200, statusText: 'Ok' });
             }
         )));
     });
@@ -55,4 +78,103 @@ describe(`Resolver Service`, () => {
             }
         )));
     });
+
+    describe('update', () => {
+        let id = 'foo',
+            serviceProviderName = 'Test Provider',
+            createdBy = 'admin';
+
+        it(`should send an expected PUT request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.update({id, serviceProviderName, createdBy}).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor/${id}`
+                        && req.method === 'PUT';
+                }, `PUT EntityDescriptor by id`);
+            }
+        )));
+    });
+
+    describe('create', () => {
+        let id = 'foo',
+            serviceProviderName = 'Test Provider',
+            createdBy = 'admin';
+
+        it(`should send an expected POST request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.save({ id, serviceProviderName, createdBy }).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor`
+                        && req.method === 'POST';
+                }, `POST new EntityDescriptor`);
+            }
+        )));
+    });
+
+    describe('remove', () => {
+        let id = 'foo',
+            serviceProviderName = 'Test Provider',
+            createdBy = 'admin';
+
+        it(`should send an expected PUT request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.remove({ id, serviceProviderName, createdBy }).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor/${id}`
+                        && req.method === 'DELETE';
+                }, `DELETE an EntityDescriptor`);
+            }
+        )));
+    });
+
+    describe('preview', () => {
+        let id = 'foo';
+
+        it(`should send an expected GET request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.preview(id).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor/${id}`
+                        && req.method === 'GET'
+                        && req.headers.get('Accept') === 'application/xml'
+                        && req.responseType === 'text';
+                }, `GET an EntityDescriptor (xml)`);
+            }
+        )));
+    });
+
+    describe('upload', () => {
+        it(`should send an expected POST request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                const name = 'foo', xml = '<foo></foo>';
+                service.upload(name, xml).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor`
+                        && req.method === 'POST'
+                        && req.headers.get('Content-Type') === 'application/xml';
+                }, `POST new EntityDescriptor`);
+            }
+        )));
+    });
+
+    describe('createFromUrl', () => {
+        it(`should send an expected POST request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                const name = 'foo', url = 'http://goo.gle';
+                service.createFromUrl(name, url).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor`
+                        && req.method === 'POST'
+                        && req.headers.get('Content-Type') === 'application/x-www-form-urlencoded'
+                        && req.body === `metadataUrl=${url}`;
+                }, `POST new EntityDescriptor`);
+            }
+        )));
+    });
 });
diff --git a/ui/src/app/metadata/domain/service/resolver.service.ts b/ui/src/app/metadata/domain/service/resolver.service.ts
index 2a158f75f..cae3a5ed8 100644
--- a/ui/src/app/metadata/domain/service/resolver.service.ts
+++ b/ui/src/app/metadata/domain/service/resolver.service.ts
@@ -15,24 +15,15 @@ export class ResolverService {
     ) {}
 
     query(): Observable<MetadataResolver[]> {
-        return this.http.get<MetadataResolver[]>(`${ this.base }${ this.endpoint }s`, {})
-            .pipe(
-                catchError(err => throwError([]))
-            );
+        return this.http.get<MetadataResolver[]>(`${ this.base }${ this.endpoint }s`, {});
     }
 
     queryForAdmin(): Observable<MetadataResolver[]> {
-        return this.http.get<MetadataResolver[]>(`${this.base}${this.endpoint}/disabledNonAdmin`, {})
-            .pipe(
-                catchError(err => throwError([]))
-            );
+        return this.http.get<MetadataResolver[]>(`${this.base}${this.endpoint}/disabledNonAdmin`, {});
     }
 
     find(id: string): Observable<MetadataResolver> {
-        return this.http.get<MetadataResolver>(`${ this.base }${ this.endpoint }/${ id }`)
-            .pipe(
-                catchError(err => throwError(err))
-            );
+        return this.http.get<MetadataResolver>(`${ this.base }${ this.endpoint }/${ id }`);
     }
 
     update(provider: MetadataResolver): Observable<MetadataResolver> {
@@ -52,9 +43,10 @@ export class ResolverService {
         return this.http.post<MetadataResolver>(`${this.base}${this.endpoint}`, xml, {
             headers: new HttpHeaders().set('Content-Type', 'application/xml'),
             params: new HttpParams().set('spName', name)
-        }).pipe(catchError(error => {
-            return throwError({ errorCode: error.status, errorMessage: `Unable to upload file ... ${error.error.errorMessage}` });
-        }));
+        }).pipe(catchError(error => throwError({
+            errorCode: error.status,
+            errorMessage: `Unable to upload file ... ${error.error.errorMessage}`
+        })));
     }
 
     createFromUrl(name: string, url: string): Observable<MetadataResolver> {
@@ -62,9 +54,12 @@ export class ResolverService {
         return this.http.post<MetadataResolver>(`${this.base}${this.endpoint}`, body, {
             headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded'),
             params: new HttpParams().set('spName', name)
-        }).pipe(catchError(error => {
-            return throwError({ errorCode: error.status, errorMessage: `Unable to upload file ... ${error.error.errorMessage}` });
-        }));
+        }).pipe(catchError(error => throwError(
+            {
+                errorCode: error.status,
+                errorMessage: `Unable to upload file ... ${error.error.errorMessage}`
+            }
+        )));
     }
 
     preview(id: string): Observable<string> {