Merge branch 'master' of bitbucket.org:unicon/shib-idp-ui into bugfix…

…/SHIBUI-1392-QA

backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolverControllerVersionEndpointsIntegrationTests.groovy

@@ -1,5 +1,7 @@
 package edu.internet2.tier.shibboleth.admin.ui.controller
 
+import edu.internet2.tier.shibboleth.admin.ui.domain.filters.EntityAttributesFilter
+import edu.internet2.tier.shibboleth.admin.ui.domain.filters.EntityAttributesFilterTarget
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicHttpMetadataResolver
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FileBackedHttpMetadataResolver
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FilesystemMetadataResolver
@@ -103,6 +105,37 @@ class MetadataResolverControllerVersionEndpointsIntegrationTests extends Specifi
         mrv2.body.name == 'resolverUPDATED'
     }
 
+    def "SHIBUI-1386"() {
+        MetadataResolver mr = new FileBackedHttpMetadataResolver(name: 'testme')
+        mr = repository.save(mr)
+
+        when: 'add a filter'
+        // def filterValue = '''{"type":"EntityAttributes","@type":"EntityAttributes","filterEnabled":true,"entityAttributesFilterTarget":{"entityAttributesFilterTargetType":"ENTITY","value":["https://idp.unicon.net/idp/shibboleth"]},"relyingPartyOverrides":{"signAssertion":false,"dontSignResponse":false,"turnOffEncryption":false,"useSha":false,"ignoreAuthenticationMethod":false,"omitNotBefore":false,"nameIdFormats":[],"authenticationMethods":[],"forceAuthn":false},"attributeRelease":[],"name":"Test Filter 1"}'''
+        def filter = new EntityAttributesFilter(
+                name: 'testme',
+                filterEnabled: true
+        ).with {
+            it.relyingPartyOverrides = [
+                    'signAssertion': true
+            ]
+            it.setEntityAttributesFilterTarget(new EntityAttributesFilterTarget().with {
+                it.entityAttributesFilterTargetType = EntityAttributesFilterTarget.EntityAttributesFilterTargetType.ENTITY
+                it.value = ['https://testme/sp']
+                it
+            })
+            it
+        }
+        mr.metadataFilters.add(filter)
+        mr = repository.save(mr)
+
+        def allVersions = getAllMetadataResolverVersions(mr.resourceId, List)
+        def mrv1 = getMetadataResolverForVersion(mr.resourceId, allVersions.body[0].id, MetadataResolver)
+        def mrv2 = getMetadataResolverForVersion(mr.resourceId, allVersions.body[1].id, MetadataResolver)
+
+        then:
+        noExceptionThrown()
+    }
+
     private getAllMetadataResolverVersions(String resourceId, responseType) {
         this.restTemplate.getForEntity(resourceUriFor(ALL_VERSIONS_URI, resourceId), responseType)
     }

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'

backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilterTarget.java

@@ -1,5 +1,6 @@
 package edu.internet2.tier.shibboleth.admin.ui.domain.filters;
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import edu.internet2.tier.shibboleth.admin.ui.domain.AbstractAuditable;
 import lombok.EqualsAndHashCode;
 import org.hibernate.envers.AuditOverride;
@@ -9,6 +10,7 @@
 
 import javax.persistence.ElementCollection;
 import javax.persistence.Entity;
+import javax.persistence.FetchType;
 import javax.persistence.OrderColumn;
 import java.util.ArrayList;
 import java.util.List;
@@ -17,6 +19,7 @@
 @EqualsAndHashCode(callSuper = true)
 @Audited
 @AuditOverride(forClass = AbstractAuditable.class)
+@JsonIgnoreProperties({"handler", "hibernateLazyInitializer"})
 public class EntityAttributesFilterTarget extends AbstractAuditable {
     public enum EntityAttributesFilterTargetType {
         ENTITY, CONDITION_SCRIPT, CONDITION_REF, REGEX

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)">

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 {

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

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

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';

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')">

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);
+        });
+    });
 });

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();
+            });
+        });
     });
 });