Skip to content

Full Toolkit for Next-Level Domain Analysis

6.1 KB
Raw Blame
import { log } from 'evlog';
import { afterEach, describe, expect, it, vi } from 'vitest';

import { ALL_RECORD_TYPES } from '@/lib/data';
import { UserFacingError } from '@/lib/user-facing-error';

import { DnsResolver, type RecordType, type ResolverResponse } from './base';

class MockResolver extends DnsResolver {
  public async resolveRecordType(
    domain: string,
    type: RecordType,
  ): Promise<ResolverResponse> {
    return {
      records: [
        {
          name: domain,
          type,
          TTL: 3600,
          data: `data-for-${type}`,
        },
      ],
      trace: [],
    };
  }
}

// Resolves each type to its listed values, or rejects with its error.
class FakeResolver extends DnsResolver {
  constructor(
    private readonly outcomes: Partial<Record<RecordType, string[] | Error>>,
  ) {
    super();
  }

  public async resolveRecordType(
    domain: string,
    type: RecordType,
  ): Promise<ResolverResponse> {
    const outcome = this.outcomes[type] ?? [];
    if (outcome instanceof Error) throw outcome;
    return {
      records: outcome.map((data) => ({ name: domain, type, TTL: 300, data })),
      trace: [],
    };
  }
}

const refused = {
  title: 'Lookup refused',
  description: 'The server refused the lookup.',
  retryable: true,
};

// evlog JSON-stringifies events in production, so only what survives a JSON
// round-trip reaches the log.
const loggedFailures = (spy: { mock: { calls: unknown[][] } }) =>
  spy.mock.calls
    .map(([event]) => JSON.parse(JSON.stringify(event)))
    .filter((event) => event.message === 'record_type_lookup_failed');

describe('DnsResolver', () => {
  afterEach(() => {
    vi.restoreAllMocks();
  });

  describe('resolveRecordType', () => {
    it('should resolve a specific record type for a domain', async () => {
      const resolver = new MockResolver();

      const records = await resolver.resolveRecordType('example.com', 'A');

      expect(records).toEqual({
        records: [
          {
            name: 'example.com',
            type: 'A',
            TTL: 3600,
            data: 'data-for-A',
          },
        ],
        trace: [],
      });
    });
  });

  describe('resolveRecordTypes', () => {
    it('should resolve all supported record types for a domain', async () => {
      const resolver = new MockResolver();

      const resolvedRecords = await resolver.resolveRecordTypes(
        'example.com',
        ALL_RECORD_TYPES,
      );

      // Ensure all record types are present and have the expected data
      ALL_RECORD_TYPES.forEach((type) => {
        expect(resolvedRecords[type]).toBeDefined();
        expect(resolvedRecords[type].records[0].type).toBe(type);
      });

      // Ensure all and only the expected keys are present
      const expectedKeys = ALL_RECORD_TYPES;
      const resolvedKeys = Object.keys(resolvedRecords);
      expect(resolvedKeys.toSorted()).toEqual(expectedKeys.toSorted());
    });

    it('should resolve only specified record types for a domain', async () => {
      const resolver = new MockResolver();

      const resolvedRecords = await resolver.resolveRecordTypes('example.com', [
        'A',
        'AAAA',
      ]);

      // Ensure only the specified record types are present
      expect(Object.keys(resolvedRecords).toSorted()).toEqual(['A', 'AAAA']);

      // Ensure the specified record types have the expected data
      expect(resolvedRecords['A'].records[0].data).toBe('data-for-A');
      expect(resolvedRecords['AAAA'].records[0].data).toBe('data-for-AAAA');
    });

    it('keeps resolved types and marks each failed type with its error', async () => {
      vi.spyOn(log, 'warn').mockImplementation(() => {});
      const resolver = new FakeResolver({
        A: ['192.0.2.1'],
        PTR: new UserFacingError(refused),
      });

      const result = await resolver.resolveRecordTypes('example.com', [
        'A',
        'PTR',
      ]);

      expect(result.A.records[0].data).toBe('192.0.2.1');
      expect(result.A.error).toBeUndefined();
      expect(result.PTR).toEqual({ records: [], trace: [], error: refused });
      expect(JSON.parse(JSON.stringify(result))).toEqual(result);
    });

    it('throws the first failure when every type fails', async () => {
      const first = new UserFacingError(refused);
      const resolver = new FakeResolver({ A: first, AAAA: new Error('bug') });

      await expect(
        resolver.resolveRecordTypes('example.com', ['A', 'AAAA']),
      ).rejects.toBe(first);
    });

    it('throws when the only successes are empty, instead of reporting no records', async () => {
      const failure = new UserFacingError(refused);
      const resolver = new FakeResolver({ A: failure, AAAA: [] });

      await expect(
        resolver.resolveRecordTypes('example.com', ['A', 'AAAA']),
      ).rejects.toBe(failure);
    });

    it('warns for expected failures and errors for bugs without exposing them', async () => {
      const logWarn = vi.spyOn(log, 'warn').mockImplementation(() => {});
      const logError = vi.spyOn(log, 'error').mockImplementation(() => {});
      const resolver = new FakeResolver({
        A: ['192.0.2.1'],
        PTR: new UserFacingError(refused, { cause: new Error('192.0.2.53') }),
        TXT: new Error('private transport details'),
      });

      const result = await resolver.resolveRecordTypes('example.com', [
        'A',
        'PTR',
        'TXT',
      ]);

      expect(result.PTR.error).toEqual(refused);
      expect(result.TXT.error?.title).toBe('DNS lookup failed');
      expect(JSON.stringify(result)).not.toContain('private transport details');
      expect(loggedFailures(logWarn)).toEqual([
        expect.objectContaining({
          domain: 'example.com',
          recordType: 'PTR',
          error: expect.objectContaining({
            message: refused.title,
            stack: expect.any(String),
            cause: expect.stringContaining('192.0.2.53'),
          }),
        }),
      ]);
      expect(loggedFailures(logError)).toEqual([
        expect.objectContaining({
          recordType: 'TXT',
          error: expect.objectContaining({
            message: 'private transport details',
            stack: expect.any(String),
          }),
        }),
      ]);
    });
  });
});