chore: general clean up around

fix missing renames
remove unneeded tests
use helper method for dry in resolver test
remove unneeded file

Author: davidlj95

projects/ngx-meta/src/core/src/metadata-json-resolver.spec.ts

@@ -55,7 +55,7 @@ describe('MetadataJsonResolver', () => {
         })
       })
       describe('like when key does not exist', () => {
-        const metadata = makeMetadata([key])
+        const metadata = makeMetadata([key, subKey])
         const values = {}
 
         testGlobalMayBeRetrieved(metadata, values)
@@ -70,16 +70,7 @@ describe('MetadataJsonResolver', () => {
       })
 
       describe('like when key is null', () => {
-        const metadata = makeMetadata([key])
-        const values = { [key]: null }
-
-        it('should return null', () => {
-          expect(sut.get(metadata, values)).toBeNull()
-        })
-      })
-
-      describe('like when key is null and there is sub key', () => {
-        const metadata = makeMetadata([key, subKey, 'dummy'])
+        const metadata = makeMetadata([key, subKey])
         const values = { [key]: null }
 
         it('should return null', () => {

projects/ngx-meta/src/core/src/metadata-registry.spec.ts

@@ -6,53 +6,53 @@ import { MockProvider } from 'ng-mocks'
 
 describe('MetadataRegistry', () => {
   const dummyId = 'dummyId'
-  const dummyMetadata = makeMetadataProvider({ id: dummyId })
+  const dummyMetadataProvider = makeMetadataProvider({ id: dummyId })
 
   it('should register metadata from DI system', () => {
-    const sut = makeSut({ metadata: [dummyMetadata] })
+    const sut = makeSut({ metadataProviders: [dummyMetadataProvider] })
 
     const allMetadata = [...sut.getAll()]
     expect(allMetadata).toHaveSize(1)
-    expect(allMetadata).toEqual([dummyMetadata])
+    expect(allMetadata).toEqual([dummyMetadataProvider])
   })
 
   it('should register the given metadata', () => {
     const sut = makeSut()
 
-    sut.register(dummyMetadata)
+    sut.register(dummyMetadataProvider)
 
     const allMetadata = [...sut.getAll()]
     expect(allMetadata).toHaveSize(1)
-    expect(allMetadata).toEqual([dummyMetadata])
+    expect(allMetadata).toEqual([dummyMetadataProvider])
   })
 
   it('should not register twice the same metadata', () => {
-    const sameDummyMetadata = makeMetadataProvider({
+    const sameDummyMetadataProvider = makeMetadataProvider({
       id: dummyId,
       spyName: 'duplicated metadata set',
     })
     const sut = makeSut()
 
-    sut.register(dummyMetadata)
-    sut.register(sameDummyMetadata)
+    sut.register(dummyMetadataProvider)
+    sut.register(sameDummyMetadataProvider)
 
     const allMetadata = [...sut.getAll()]
     expect(allMetadata).toHaveSize(1)
-    expect(allMetadata).toEqual([dummyMetadata])
+    expect(allMetadata).toEqual([dummyMetadataProvider])
   })
 })
 
 function makeSut(
   opts: {
-    metadata?: ReadonlyArray<MetadataProvider<unknown>>
+    metadataProviders?: ReadonlyArray<MetadataProvider<unknown>>
   } = {},
 ) {
   TestBed.configureTestingModule({
     providers: [
       //👇 Mocking sut to ensure injected metadata calls registry function
       MetadataRegistry,
-      ...(opts.metadata
-        ? opts.metadata.map((metadata) =>
+      ...(opts.metadataProviders
+        ? opts.metadataProviders.map((metadata) =>
             MockProvider(MetadataProvider, metadata, 'useValue', true),
           )
         : []),

projects/ngx-meta/src/core/src/metadata-registry.ts

@@ -8,18 +8,18 @@ export class MetadataRegistry {
   constructor(
     @Optional()
     @Inject(MetadataProvider)
-    private readonly injectedMetadata: ReadonlyArray<
+    private readonly injectedProviders: ReadonlyArray<
       MetadataProvider<unknown>
     > | null,
   ) {
-    this.injectedMetadata?.forEach((metadata) => this.register(metadata))
+    this.injectedProviders?.forEach((metadata) => this.register(metadata))
   }
 
-  register(metadata: MetadataProvider<unknown>) {
-    if (this.byId.has(metadata.metadata.id)) {
+  register(provider: MetadataProvider<unknown>) {
+    if (this.byId.has(provider.metadata.id)) {
       return
     }
-    this.byId.set(metadata.metadata.id, metadata)
+    this.byId.set(provider.metadata.id, provider)
   }
 
   getAll(): Iterable<MetadataProvider<unknown>> {

projects/ngx-meta/src/core/src/metadata-resolver.spec.ts

@@ -14,13 +14,13 @@ import { makeGlobalMetadata } from './make-global-metadata'
 describe('MetadataResolver', () => {
   enableAutoSpy()
   let sut: MetadataResolver
-  let dummyMetadataDefinition: Metadata
+  let dummyMetadata: Metadata
   let jsonResolver: jasmine.SpyObj<MetadataJsonResolver>
   let routeMetadataValues: jasmine.SpyObj<RouteMetadataValues>
   let defaultsService: jasmine.SpyObj<DefaultsService>
 
   beforeEach(() => {
-    dummyMetadataDefinition = makeGlobalMetadata('dummy')
+    dummyMetadata = makeGlobalMetadata('dummy')
     sut = makeSut()
     jsonResolver = TestBed.inject(
       MetadataJsonResolver,
@@ -35,7 +35,7 @@ describe('MetadataResolver', () => {
 
   function mockJsonResolver(returnMap: Map<MetadataValues, unknown>) {
     jsonResolver.get.and.callFake(
-      <T>(def: Metadata, values: MetadataValues) =>
+      <T>(metadata: Metadata, values: MetadataValues) =>
         returnMap.get(values) as MaybeUndefined<T>,
     )
   }
@@ -56,16 +56,16 @@ describe('MetadataResolver', () => {
       })
 
       it('should resolve value using values', () => {
-        sut.get(dummyMetadataDefinition, dummyValues)
+        sut.get(dummyMetadata, dummyValues)
 
         expect(jsonResolver.get).toHaveBeenCalledWith(
-          dummyMetadataDefinition,
+          dummyMetadata,
           dummyValues,
         )
       })
 
       it('should return its value', () => {
-        expect(sut.get(dummyMetadataDefinition, dummyValues)).toEqual(value)
+        expect(sut.get(dummyMetadata, dummyValues)).toEqual(value)
       })
     })
 
@@ -76,17 +76,17 @@ describe('MetadataResolver', () => {
       })
 
       it('should resolve value using route metadata values', () => {
-        sut.get(dummyMetadataDefinition, dummyValues)
+        sut.get(dummyMetadata, dummyValues)
 
         expect(routeMetadataValues.get).toHaveBeenCalledOnceWith()
         expect(jsonResolver.get).toHaveBeenCalledWith(
-          dummyMetadataDefinition,
+          dummyMetadata,
           routeValues,
         )
       })
 
       it('should return value obtained from route metadata values', () => {
-        expect(sut.get(dummyMetadataDefinition, dummyValues)).toEqual(value)
+        expect(sut.get(dummyMetadata, dummyValues)).toEqual(value)
       })
     })
 
@@ -97,17 +97,17 @@ describe('MetadataResolver', () => {
       })
 
       it('should resolve value using default values', () => {
-        sut.get(dummyMetadataDefinition, dummyValues)
+        sut.get(dummyMetadata, dummyValues)
 
         expect(defaultsService.get).toHaveBeenCalledOnceWith()
         expect(jsonResolver.get).toHaveBeenCalledWith(
-          dummyMetadataDefinition,
+          dummyMetadata,
           defaultValues,
         )
       })
 
       it('should return value obtained from defaults', () => {
-        expect(sut.get(dummyMetadataDefinition, dummyValues)).toEqual(value)
+        expect(sut.get(dummyMetadata, dummyValues)).toEqual(value)
       })
     })
 
@@ -129,7 +129,7 @@ describe('MetadataResolver', () => {
         })
 
         it('should return the merged object, with value props having more priority', () => {
-          expect(sut.get(dummyMetadataDefinition, dummyValues)).toEqual({
+          expect(sut.get(dummyMetadata, dummyValues)).toEqual({
             ...routeValueObject,
             ...valueObject,
           })
@@ -141,29 +141,23 @@ describe('MetadataResolver', () => {
 
         beforeEach(() => {
           routeMetadataValues.get.and.returnValue(routeValues)
-          jsonResolver.get.and.callFake(
-            <T>(def: Metadata, values: MetadataValues) => {
-              switch (values) {
-                case routeValues:
-                  return routeValue as T
-                case values:
-                  return value as T
-                default:
-                  throw new Error('Unexpected values, cannot mock')
-              }
-            },
+          mockJsonResolver(
+            new Map<MetadataValues, unknown>([
+              [routeValues, routeValue],
+              [dummyValues, value],
+            ]),
           )
         })
 
         it('should return value from values object', () => {
-          expect(sut.get(dummyMetadataDefinition, dummyValues)).toEqual(value)
+          expect(sut.get(dummyMetadata, dummyValues)).toEqual(value)
         })
       })
     })
 
     describe('when neither value, route value or default value exists', () => {
       it('should return nothing', () => {
-        expect(sut.get(dummyMetadataDefinition, dummyValues)).toBeUndefined()
+        expect(sut.get(dummyMetadata, dummyValues)).toBeUndefined()
       })
     })
   })

projects/ngx-meta/src/core/src/metadata-resolver.ts

@@ -15,14 +15,14 @@ export class MetadataResolver {
     private readonly defaultsService: DefaultsService,
   ) {}
 
-  get<T>(metadataDefinition: Metadata, values: MetadataValues): T | undefined {
-    const value = this.jsonResolver.get(metadataDefinition, values)
+  get<T>(metadata: Metadata, values: MetadataValues): T | undefined {
+    const value = this.jsonResolver.get(metadata, values)
     const routeValue = this.jsonResolver.get(
-      metadataDefinition,
+      metadata,
       this.routeMetadataValues.get(),
     )
     const defaultValue = this.jsonResolver.get(
-      metadataDefinition,
+      metadata,
       this.defaultsService.get(),
     )
     const effectiveValue =

projects/ngx-meta/src/core/src/metadata.service.spec.ts

@@ -22,12 +22,15 @@ describe('MetadataService', () => {
   })
 
   describe('set', () => {
-    const firstMetadata = makeMetadataProvider({ id: 'first' })
-    const secondMetadata = makeMetadataProvider({ id: 'second' })
+    const firstMetadataProvider = makeMetadataProvider({ id: 'first' })
+    const secondMetadataProvider = makeMetadataProvider({ id: 'second' })
     const dummyValues = {}
 
     beforeEach(() => {
-      metadataRegistry.getAll.and.returnValue([firstMetadata, secondMetadata])
+      metadataRegistry.getAll.and.returnValue([
+        firstMetadataProvider,
+        secondMetadataProvider,
+      ])
     })
 
     it('should set each metadata using resolved values', () => {
@@ -38,9 +41,9 @@ describe('MetadataService', () => {
       const dummySecondMetadataValue = 'secondMetadataValue'
       resolver.get.and.callFake(<T>(definition: Metadata) => {
         switch (definition) {
-          case firstMetadata.metadata:
+          case firstMetadataProvider.metadata:
             return dummyFirstMetadataValue as MaybeUndefined<T>
-          case secondMetadata.metadata:
+          case secondMetadataProvider.metadata:
             return dummySecondMetadataValue as MaybeUndefined<T>
           default:
             throw new Error('Unexpected metadata')
@@ -51,15 +54,19 @@ describe('MetadataService', () => {
       expect(metadataRegistry.getAll).toHaveBeenCalledOnceWith()
       expect(resolver.get).toHaveBeenCalledTimes(2)
       expect(resolver.get).toHaveBeenCalledWith(
-        firstMetadata.metadata,
+        firstMetadataProvider.metadata,
         dummyValues,
       )
-      expect(firstMetadata.set).toHaveBeenCalledWith(dummyFirstMetadataValue)
+      expect(firstMetadataProvider.set).toHaveBeenCalledWith(
+        dummyFirstMetadataValue,
+      )
       expect(resolver.get).toHaveBeenCalledWith(
-        secondMetadata.metadata,
+        secondMetadataProvider.metadata,
         dummyValues,
       )
-      expect(secondMetadata.set).toHaveBeenCalledWith(dummySecondMetadataValue)
+      expect(secondMetadataProvider.set).toHaveBeenCalledWith(
+        dummySecondMetadataValue,
+      )
     })
 
     it('should set values for route when finished', () => {

projects/ngx-meta/src/core/src/provide-metadata-factory.ts

@@ -7,15 +7,13 @@ export type MetadataSetterFactory<T> = (
   ...deps: Exclude<FactoryProvider['deps'], undefined>
 ) => MetadataSetter<T>
 
-const makeMetadata = <T>(
-  definition: Metadata,
+const makeMetadataProvider = <T>(
+  metadata: Metadata,
   set: MetadataSetter<T>,
-): MetadataProvider<T> => {
-  return {
-    metadata: definition,
-    set,
-  }
-}
+): MetadataProvider<T> => ({
+  metadata,
+  set,
+})
 
 export function provideMetadataFactory<T>(
   definition: Metadata,
@@ -26,7 +24,7 @@ export function provideMetadataFactory<T>(
     provide: MetadataProvider,
     multi: true,
     useFactory: (...deps: unknown[]) =>
-      makeMetadata(definition, setterFactory(...deps)),
+      makeMetadataProvider(definition, setterFactory(...deps)),
     deps,
   }
 }