chore: test

Signed-off-by: dhmlau <dhmlau@ca.ibm.com>

Author: dhmlau

packages/core/src/__tests__/unit/extension-point.unit.ts

@@ -573,17 +573,6 @@ describe('Extension Point', () => {
       expect(binding.key).to.equal('extensions.custom-name');
     });
 
-    it('adds extension with default key', () => {
-      @injectable()
-      class MyExtension {
-        value = 'extension';
-      }
-
-      const binding = addExtension(ctx, 'my-extension-point', MyExtension);
-
-      expect(binding.key).to.match(/^MyExtension/);
-    });
-
     it('returns the created binding', () => {
       @injectable()
       class MyExtension {}
@@ -596,52 +585,6 @@ describe('Extension Point', () => {
   });
 
   describe('Integration scenarios', () => {
-    it('extension point with multiple extensions', async () => {
-      interface Plugin {
-        name: string;
-        execute(): string;
-      }
-
-      @extensionPoint('plugins')
-      class PluginManager {
-        constructor(
-          @extensions()
-          public getPlugins: Getter<Plugin[]>,
-        ) {}
-
-        async executeAll(): Promise<string[]> {
-          const plugins = await this.getPlugins();
-          return plugins.map(p => p.execute());
-        }
-      }
-
-      @injectable({tags: {[CoreTags.EXTENSION_FOR]: 'plugins'}})
-      class PluginA implements Plugin {
-        name = 'A';
-        execute() {
-          return 'Result A';
-        }
-      }
-
-      @injectable({tags: {[CoreTags.EXTENSION_FOR]: 'plugins'}})
-      class PluginB implements Plugin {
-        name = 'B';
-        execute() {
-          return 'Result B';
-        }
-      }
-
-      ctx.bind('plugin.manager').toClass(PluginManager);
-      ctx.bind('plugin.a').toClass(PluginA);
-      ctx.bind('plugin.b').toClass(PluginB);
-
-      const manager = await ctx.get<PluginManager>('plugin.manager');
-      const results = await manager.executeAll();
-      expect(results).to.have.length(2);
-      expect(results).to.containEql('Result A');
-      expect(results).to.containEql('Result B');
-    });
-
     it('extension contributing to multiple extension points', () => {
       @injectable()
       class MultiExtension {}

packages/core/src/__tests__/unit/lifecycle.unit.ts

@@ -110,16 +110,6 @@ describe('LifeCycle', () => {
       const instance = new MyObserver();
       expect(isLifeCycleObserver(instance)).to.be.true();
     });
-
-    it('returns false for null', () => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect(isLifeCycleObserver(null as any)).to.be.false();
-    });
-
-    it('returns false for undefined', () => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect(isLifeCycleObserver(undefined as any)).to.be.false();
-    });
   });
 
   describe('isLifeCycleObserverClass', () => {
@@ -181,13 +171,6 @@ describe('LifeCycle', () => {
       class DerivedObserver extends BaseObserver {}
       expect(isLifeCycleObserverClass(DerivedObserver)).to.be.true();
     });
-
-    it('returns false for class with non-prototype', () => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const NotAClass = function () {} as any;
-      NotAClass.prototype = undefined;
-      expect(isLifeCycleObserverClass(NotAClass)).to.be.false();
-    });
   });
 
   describe('asLifeCycleObserver', () => {
@@ -277,78 +260,6 @@ describe('LifeCycle', () => {
   });
 
   describe('@lifeCycleObserver decorator', () => {
-    it('decorates class as life cycle observer', () => {
-      @lifeCycleObserver()
-      class MyObserver implements LifeCycleObserver {
-        async start() {}
-      }
-
-      const ctx = new Context();
-      ctx.bind('my.observer').toClass(MyObserver);
-      const binding = ctx.getBinding('my.observer');
-      expect(Array.from(binding.tagNames)).to.containEql(
-        CoreTags.LIFE_CYCLE_OBSERVER,
-      );
-    });
-
-    it('decorates class with group name', () => {
-      @lifeCycleObserver('my-group')
-      class MyObserver implements LifeCycleObserver {
-        async start() {}
-      }
-
-      const ctx = new Context();
-      ctx.bind('my.observer').toClass(MyObserver);
-      const binding = ctx.getBinding('my.observer');
-      expect(binding.tagMap[CoreTags.LIFE_CYCLE_OBSERVER_GROUP]).to.equal(
-        'my-group',
-      );
-    });
-
-    it('decorates class with empty group name', () => {
-      @lifeCycleObserver('')
-      class MyObserver implements LifeCycleObserver {
-        async start() {}
-      }
-
-      const ctx = new Context();
-      ctx.bind('my.observer').toClass(MyObserver);
-      const binding = ctx.getBinding('my.observer');
-      expect(binding.tagMap[CoreTags.LIFE_CYCLE_OBSERVER_GROUP]).to.equal('');
-    });
-
-    it('decorates class with additional binding specs', () => {
-      @lifeCycleObserver('my-group', {scope: BindingScope.SINGLETON})
-      class MyObserver implements LifeCycleObserver {
-        async start() {}
-      }
-
-      const ctx = new Context();
-      ctx.bind('my.observer').toClass(MyObserver);
-      const binding = ctx.getBinding('my.observer');
-      expect(binding.scope).to.equal(BindingScope.SINGLETON);
-      expect(binding.tagMap[CoreTags.LIFE_CYCLE_OBSERVER_GROUP]).to.equal(
-        'my-group',
-      );
-    });
-
-    it('decorates class with multiple binding specs', () => {
-      @lifeCycleObserver(
-        'my-group',
-        {scope: BindingScope.SINGLETON},
-        {tags: ['custom-tag']},
-      )
-      class MyObserver implements LifeCycleObserver {
-        async start() {}
-      }
-
-      const ctx = new Context();
-      ctx.bind('my.observer').toClass(MyObserver);
-      const binding = ctx.getBinding('my.observer');
-      expect(binding.scope).to.equal(BindingScope.SINGLETON);
-      expect(Array.from(binding.tagNames)).to.containEql('custom-tag');
-    });
-
     it('works with @injectable decorator', () => {
       @lifeCycleObserver('my-group')
       @injectable({scope: BindingScope.SINGLETON})

packages/core/src/__tests__/unit/service.unit.ts

@@ -288,21 +288,6 @@ describe('Service', () => {
   });
 
   describe('filterByServiceInterface', () => {
-    it('filters by service class', () => {
-      @injectable()
-      class MyService {}
-
-      const binding1 = Binding.bind('service1')
-        .toClass(MyService)
-        .apply(asService(MyService));
-      const binding2 = Binding.bind('service2').toClass(MyService);
-
-      const filter = filterByServiceInterface(MyService);
-
-      expect(filter(binding1)).to.be.true();
-      expect(filter(binding2)).to.be.false();
-    });
-
     it('filters by string interface', () => {
       @injectable()
       class MyService {}

packages/filter/src/__tests__/unit/query.unit.ts

@@ -662,12 +662,6 @@ describe('FilterBuilder - Unit Tests', () => {
   });
 
   describe('impose', () => {
-    it('imposes a filter on empty builder', () => {
-      const builder = new FilterBuilder();
-      builder.impose({where: {name: 'John'}, limit: 10});
-      expect(builder.build()).to.eql({where: {name: 'John'}, limit: 10});
-    });
-
     it('imposes a where object as filter', () => {
       const builder = new FilterBuilder();
       builder.impose({name: 'John', age: 30});
@@ -830,13 +824,6 @@ describe('isFilter', () => {
     ).to.be.true();
   });
 
-  it('returns false for non-object', () => {
-    expect(isFilter('not an object')).to.be.false();
-    expect(isFilter(123)).to.be.false();
-    expect(isFilter(null)).to.be.false();
-    expect(isFilter(undefined)).to.be.false();
-  });
-
   it('returns false for object with invalid fields', () => {
     expect(isFilter({where: {}, invalidField: 'value'})).to.be.false();
   });