@wearesage/schema/__tests__/core/RegistryProvider.test.ts

A flexible schema definition and validation system for TypeScript with multi-database support

import "reflect-metadata";
import { 
  DefaultRegistryProvider, 
  getRegistryProvider, 
  setRegistryProvider, 
  resetRegistryProvider, 
  getRegistry, 
  IRegistryProvider 
} from "../../core/RegistryProvider";
import { MetadataRegistry } from "../../core/MetadataRegistry";

describe("RegistryProvider", () => {
  // Restore default provider after each test
  afterEach(() => {
    resetRegistryProvider();
  });

  test("should provide shared registry instance via default provider", () => {
    // Get registry from default provider
    const registry = getRegistry();
    
    // Should return an instance of MetadataRegistry
    expect(registry).toBeInstanceOf(MetadataRegistry);
    
    // Get registry again - should be same instance
    const registry2 = getRegistry();
    expect(registry2).toBe(registry);
  });

  test("should allow setting a custom provider", () => {
    // Create a custom provider
    class CustomProvider implements IRegistryProvider {
      private customRegistry = new MetadataRegistry();
      
      getRegistry(): MetadataRegistry {
        return this.customRegistry;
      }
    }
    
    // Set custom provider
    const customProvider = new CustomProvider();
    setRegistryProvider(customProvider);
    
    // Get registry via provider
    const registry = getRegistry();
    
    // Should be the custom registry
    expect(registry).toBe(customProvider.getRegistry());
  });

  test("should reset to default provider", () => {
    // Create and set a custom provider
    class CustomProvider implements IRegistryProvider {
      getRegistry(): MetadataRegistry {
        return new MetadataRegistry();
      }
    }
    setRegistryProvider(new CustomProvider());
    
    // Reset to default provider
    resetRegistryProvider();
    
    // Get provider - should be DefaultRegistryProvider
    const provider = getRegistryProvider();
    expect(provider).toBeInstanceOf(DefaultRegistryProvider);
  });

  test("DefaultRegistryProvider should use shared registry", () => {
    // Create two instances of DefaultRegistryProvider
    const provider1 = new DefaultRegistryProvider();
    const provider2 = new DefaultRegistryProvider();
    
    // Both should return the same registry instance
    expect(provider1.getRegistry()).toBe(provider2.getRegistry());
    
    // Registry from provider should be the same as from getRegistry()
    expect(provider1.getRegistry()).toBe(getRegistry());
  });
});