dcrouter/test/test.reference-resolver.ts

import { expect, tap } from '@git.zone/tstest/tapbundle';
import { ReferenceResolver } from '../ts/config/classes.reference-resolver.js';
import type { ISourceProfile, INetworkTarget, IRouteMetadata } from '../ts_interfaces/data/route-management.js';
import type { IRouteConfig } from '@push.rocks/smartproxy';

function injectProfile(resolver: ReferenceResolver, profile: ISourceProfile): void {
  (resolver as any).profiles.set(profile.id, profile);
}

function injectTarget(resolver: ReferenceResolver, target: INetworkTarget): void {
  (resolver as any).targets.set(target.id, target);
}

function makeProfile(overrides: Partial<ISourceProfile> = {}): ISourceProfile {
  return {
    id: 'profile-1',
    name: 'STANDARD',
    description: 'Test profile',
    security: {
      ipAllowList: ['192.168.0.0/16', '10.0.0.0/8'],
      maxConnections: 1000,
    },
    createdAt: Date.now(),
    updatedAt: Date.now(),
    createdBy: 'test',
    ...overrides,
  };
}

function makeTarget(overrides: Partial<INetworkTarget> = {}): INetworkTarget {
  return {
    id: 'target-1',
    name: 'INFRA',
    description: 'Test target',
    host: '192.168.5.247',
    port: 443,
    createdAt: Date.now(),
    updatedAt: Date.now(),
    createdBy: 'test',
    ...overrides,
  };
}

function makeRoute(overrides: Partial<IRouteConfig> = {}): IRouteConfig {
  return {
    name: 'test-route',
    match: { ports: 443, domains: 'test.example.com' },
    action: { type: 'forward', targets: [{ host: 'placeholder', port: 80 }] },
    ...overrides,
  } as IRouteConfig;
}

let resolver: ReferenceResolver;

tap.test('should create ReferenceResolver instance', async () => {
  resolver = new ReferenceResolver();
  expect(resolver).toBeTruthy();
});

tap.test('should list empty profiles and targets initially', async () => {
  expect(resolver.listProfiles()).toBeArray();
  expect(resolver.listProfiles()).toHaveLength(0);
  expect(resolver.listTargets()).toBeArray();
  expect(resolver.listTargets()).toHaveLength(0);
});

tap.test('should resolve source binding display names without materializing route security', async () => {
  const profile = makeProfile();
  injectProfile(resolver, profile);

  const route = makeRoute({
    security: { ipAllowList: ['127.0.0.1'], maxConnections: 42 },
  });
  const metadata: IRouteMetadata = {
    sourceBindings: [{ sourceProfileRef: 'profile-1' }],
  };

  const result = resolver.resolveRoute(route, metadata);

  expect(result.route.security!.ipAllowList).toEqual(['127.0.0.1']);
  expect(result.route.security!.maxConnections).toEqual(42);
  expect(result.metadata.sourceBindings![0].sourceProfileName).toEqual('STANDARD');
  expect(result.metadata.lastResolvedAt).toBeTruthy();
});

tap.test('should keep missing source binding refs fail-closed for compiler validation', async () => {
  const route = makeRoute();
  const metadata: IRouteMetadata = {
    sourceBindings: [{ sourceProfileRef: 'nonexistent-profile' }],
  };

  const result = resolver.resolveRoute(route, metadata);

  expect(result.route.security).toBeUndefined();
  expect(result.metadata.sourceBindings![0].sourceProfileName).toBeUndefined();
});

tap.test('should resolve source profile inheritance for apply-time compiler use', async () => {
  const baseProfile = makeProfile({
    id: 'base-profile',
    name: 'BASE',
    security: {
      ipAllowList: ['10.0.0.0/8'],
      maxConnections: 500,
    },
  });
  injectProfile(resolver, baseProfile);

  const extendedProfile = makeProfile({
    id: 'extended-profile',
    name: 'EXTENDED',
    security: {
      ipAllowList: ['160.79.104.0/21'],
    },
    extendsProfiles: ['base-profile'],
  });
  injectProfile(resolver, extendedProfile);

  const security = resolver.resolveSourceProfileSecurity('extended-profile')!;
  expect(security.ipAllowList).toContain('10.0.0.0/8');
  expect(security.ipAllowList).toContain('160.79.104.0/21');
  expect(security.maxConnections).toEqual(500);
});

tap.test('should resolve network target onto a route', async () => {
  const target = makeTarget();
  injectTarget(resolver, target);

  const route = makeRoute();
  const metadata: IRouteMetadata = { networkTargetRef: 'target-1' };

  const result = resolver.resolveRoute(route, metadata);

  expect(result.route.action.targets![0].host).toEqual('192.168.5.247');
  expect(result.route.action.targets![0].port).toEqual(443);
  expect(result.metadata.networkTargetName).toEqual('INFRA');
  expect(result.metadata.lastResolvedAt).toBeTruthy();
});

tap.test('should resolve source bindings and target references together', async () => {
  const route = makeRoute();
  const metadata: IRouteMetadata = {
    sourceBindings: [{ sourceProfileRef: 'profile-1' }],
    networkTargetRef: 'target-1',
  };

  const result = resolver.resolveRoute(route, metadata);

  expect(result.route.security).toBeUndefined();
  expect(result.route.action.targets![0].host).toEqual('192.168.5.247');
  expect(result.metadata.sourceBindings![0].sourceProfileName).toEqual('STANDARD');
  expect(result.metadata.networkTargetName).toEqual('INFRA');
});

tap.test('should find routes by source binding profile ref only', async () => {
  const storedRoutes = new Map<string, any>();
  storedRoutes.set('route-a', {
    id: 'route-a',
    route: makeRoute({ name: 'route-a' }),
    enabled: true,
    metadata: { sourceBindings: [{ sourceProfileRef: 'profile-1' }] },
  });
  storedRoutes.set('route-b', {
    id: 'route-b',
    route: makeRoute({ name: 'route-b' }),
    enabled: true,
    metadata: { networkTargetRef: 'target-1' },
  });
  storedRoutes.set('route-c', {
    id: 'route-c',
    route: makeRoute({ name: 'route-c' }),
    enabled: true,
    metadata: {
      sourceBindings: [{ sourceProfileRef: 'profile-1' }],
      networkTargetRef: 'target-1',
    },
  });

  const profileRefs = resolver.findRoutesByProfileRefSync('profile-1', storedRoutes);
  expect(profileRefs).toHaveLength(2);
  expect(profileRefs).toContain('route-a');
  expect(profileRefs).toContain('route-c');

  const targetRefs = resolver.findRoutesByTargetRefSync('target-1', storedRoutes);
  expect(targetRefs).toHaveLength(2);
  expect(targetRefs).toContain('route-b');
  expect(targetRefs).toContain('route-c');
});

tap.test('should get profile and target usage for specific IDs', async () => {
  const storedRoutes = new Map<string, any>();
  storedRoutes.set('route-x', {
    id: 'route-x',
    route: makeRoute({ name: 'my-route' }),
    enabled: true,
    metadata: { sourceBindings: [{ sourceProfileRef: 'profile-1' }] },
  });
  storedRoutes.set('route-y', {
    id: 'route-y',
    route: makeRoute({ name: 'other-route' }),
    enabled: true,
    metadata: { networkTargetRef: 'target-1' },
  });

  const profileUsage = resolver.getProfileUsageForId('profile-1', storedRoutes);
  expect(profileUsage).toHaveLength(1);
  expect(profileUsage[0].routeName).toEqual('my-route');

  const targetUsage = resolver.getTargetUsageForId('target-1', storedRoutes);
  expect(targetUsage).toHaveLength(1);
  expect(targetUsage[0].routeName).toEqual('other-route');
});

tap.test('should get profiles and targets by name', async () => {
  expect(resolver.getProfileByName('STANDARD')!.id).toEqual('profile-1');
  expect(resolver.getTargetByName('INFRA')!.id).toEqual('target-1');
  expect(resolver.getProfileByName('NONEXISTENT')).toBeUndefined();
  expect(resolver.getTargetByName('NONEXISTENT')).toBeUndefined();
});

export default tap.start();