atnotary / tests / integration / notary.test.ts

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { ATProtocolNotary } from '../../src/lib/notary';

// Mock external dependencies
vi.mock('@atproto/api', () => ({
  AtpAgent: vi.fn().mockImplementation(() => ({
    com: {
      atproto: {
        repo: {
          getRecord: vi.fn().mockResolvedValue({
            data: {
              value: { text: 'Test post', createdAt: '2024-01-01' },
              cid: 'bafyreiabc123',
            },
          }),
        },
      },
    },
  })),
}));

vi.mock('@ethereum-attestation-service/eas-sdk', () => {
  const mockEAS = {
    connect: vi.fn(),
    attest: vi.fn().mockResolvedValue({
      wait: vi.fn().mockResolvedValue('0xattestationuid123'),
      receipt: {
        hash: '0xtxhash123',
        transactionHash: '0xtxhash123',
      },
    }),
    getAttestation: vi.fn().mockResolvedValue({
      uid: '0xattestationuid123',
      attester: '0xattester',
      revocationTime: 0n,
      data: '0xencodeddata',
    }),
  };

  const mockSchemaRegistry = {
    connect: vi.fn(),
    register: vi.fn().mockResolvedValue({
      wait: vi.fn().mockResolvedValue({ 
        transactionHash: '0xschemahash',
        hash: '0xschemahash',
      }),
      receipt: {
        hash: '0xschemahash',
        transactionHash: '0xschemahash',
      },
    }),
  };

  return {
    default: {
      EAS: vi.fn(() => mockEAS),
      SchemaRegistry: vi.fn(() => mockSchemaRegistry),
      SchemaEncoder: vi.fn().mockImplementation(() => ({
        encodeData: vi.fn().mockReturnValue('0xencodeddata'),
        decodeData: vi.fn().mockReturnValue([
          { name: 'recordURI', value: { value: 'at://did:plc:test/app.bsky.feed.post/123' } },
          { name: 'cid', value: { value: 'bafyreiabc123' } },
          { name: 'contentHash', value: { value: '0xa64b286ffd5cc55c57f4e9c74d1122aa081dc5f662648cb5cc5ced74e0e12cd5' } },
          { name: 'pds', value: { value: 'https://pds.example.com' } },
          { name: 'timestamp', value: { value: 1234567890 } },
        ]),
      })),
      NO_EXPIRATION: 0n,
    },
  };
});

global.fetch = vi.fn();

describe('ATProtocolNotary', () => {
  beforeEach(() => {
    vi.clearAllMocks();
    
    // Mock DID resolution
    (global.fetch as any).mockResolvedValue({
      ok: true,
      json: async () => ({
        service: [
          {
            id: '#atproto_pds',
            type: 'AtprotoPersonalDataServer',
            serviceEndpoint: 'https://pds.example.com',
          },
        ],
      }),
    });
  });

  describe('constructor', () => {
    it('should create instance with valid config', () => {
      const notary = new ATProtocolNotary({
        privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
        schemaUID: '0xschemauid',
      }, 'sepolia');

      expect(notary).toBeInstanceOf(ATProtocolNotary);
      expect(notary.getAddress()).toBeTruthy();
    });
  });

  describe('resolveDIDtoPDS', () => {
    it('should resolve did:plc to PDS', async () => {
      const notary = new ATProtocolNotary({
        schemaUID: '0xschemauid',
      });

      const pds = await notary.resolveDIDtoPDS('did:plc:test123');

      expect(pds).toBe('https://pds.example.com');
      expect(global.fetch).toHaveBeenCalledWith('https://plc.directory/did:plc:test123');
    });

    it('should throw error for unsupported DID method', async () => {
      const notary = new ATProtocolNotary({
        schemaUID: '0xschemauid',
      });

      await expect(notary.resolveDIDtoPDS('did:unsupported:test')).rejects.toThrow(
        'Unsupported DID method'
      );
    });

    it('should throw error when PDS not found', async () => {
      (global.fetch as any).mockResolvedValueOnce({
        ok: true,
        json: async () => ({ service: [] }),
      });

      const notary = new ATProtocolNotary({
        schemaUID: '0xschemauid',
      });

      await expect(notary.resolveDIDtoPDS('did:plc:test')).rejects.toThrow(
        'No PDS endpoint found'
      );
    });
  });

  describe('fetchRecord', () => {
    it('should fetch record from PDS', async () => {
      const notary = new ATProtocolNotary({
        schemaUID: '0xschemauid',
      });

      const result = await notary.fetchRecord('at://did:plc:test/app.bsky.feed.post/123');

      expect(result.record.value.text).toBe('Test post');
      expect(result.record.cid).toBe('bafyreiabc123');
      expect(result.pds).toBe('https://pds.example.com');
    });
  });

  describe('notarizeRecord', () => {
    it('should create attestation successfully', async () => {
      const notary = new ATProtocolNotary({
        privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
        schemaUID: '0xschemauid123',
      });

      const result = await notary.notarizeRecord('at://did:plc:test/app.bsky.feed.post/123');

      expect(result.attestationUID).toBe('0xattestationuid123');
      expect(result.recordURI).toBe('at://did:plc:test/app.bsky.feed.post/123');
      expect(result.cid).toBe('bafyreiabc123');
      expect(result.pds).toBe('https://pds.example.com');
      expect(result.transactionHash).toBeTruthy();
    });
  });

  describe('verifyAttestation', () => {
    it('should verify attestation successfully', async () => {
      const notary = new ATProtocolNotary({ 
        schemaUID: '0xschemauid',
      });

      const result = await notary.verifyAttestation('0xattestationuid123');

      expect(result.uid).toBe('0xattestationuid123');
      expect(result.recordURI).toBe('at://did:plc:test/app.bsky.feed.post/123');
      expect(result.cid).toBe('bafyreiabc123');
      expect(result.pds).toBe('https://pds.example.com');
      expect(result.attester).toBe('0xattester');
      expect(result.revoked).toBe(false);
    });
  });

  describe('compareWithCurrent', () => {
    it('should detect unchanged content', async () => {
      const notary = new ATProtocolNotary({ 
        schemaUID: '0xschemauid',
      });

      const attestation = await notary.verifyAttestation('0xattestationuid123');
      const comparison = await notary.compareWithCurrent(attestation);

      expect(comparison.exists).toBe(true);
      expect(comparison.cidMatches).toBe(true);
      expect(comparison.hashMatches).toBe(true);
      expect(comparison.currentCid).toBeTruthy();
      expect(comparison.currentHash).toBeTruthy();
    });
    
    it('should detect changed content', async () => {
      // Mock different CID and hash
      const { AtpAgent } = await import('@atproto/api');
      (AtpAgent as any).mockImplementation(() => ({
        com: {
          atproto: {
            repo: {
              getRecord: vi.fn().mockResolvedValue({
                data: {
                  value: { text: 'Modified post', createdAt: '2024-01-02' },
                  cid: 'bafyreidifferent123',
                },
              }),
            },
          },
        },
      }));
      
      const notary = new ATProtocolNotary({
        schemaUID: '0xschemauid',
      });

      const attestation = await notary.verifyAttestation('0xattestationuid123');
      const comparison = await notary.compareWithCurrent(attestation);

      expect(comparison.exists).toBe(true);
      expect(comparison.cidMatches).toBe(false);
      expect(comparison.hashMatches).toBe(false);
    });
  });

});