pdfdancer-client-typescript 1.0.16 → 1.0.18

package/src/__tests__/e2e/snapshot.test.ts

@@ -1,296 +0,0 @@
-/**
- * E2E tests for snapshot operations
- */
-
-import {ObjectType, PDFDancer, DocumentSnapshot, PageSnapshot} from '../../index';
-import {requireEnvAndFixture} from './test-helpers';
-
-describe('Snapshot E2E Tests', () => {
-    
-    test('get document snapshot', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        const snapshot = await client.getDocumentSnapshot();
-        
-        // Verify snapshot structure
-        expect(snapshot).toBeDefined();
-        expect(snapshot).toBeInstanceOf(DocumentSnapshot);
-        
-        // Verify page count
-        expect(snapshot.pageCount).toBe(12);
-        
-        // Verify fonts array exists
-        expect(snapshot.fonts).toBeDefined();
-        expect(Array.isArray(snapshot.fonts)).toBe(true);
-        
-        // Verify pages array
-        expect(snapshot.pages).toBeDefined();
-        expect(Array.isArray(snapshot.pages)).toBe(true);
-        expect(snapshot.pages.length).toBe(12);
-        
-        // Verify each page snapshot
-        for (let i = 0; i < snapshot.pages.length; i++) {
-            const pageSnapshot = snapshot.pages[i];
-            expect(pageSnapshot).toBeInstanceOf(PageSnapshot);
-            expect(pageSnapshot.pageRef).toBeDefined();
-            expect(pageSnapshot.pageRef.position.pageIndex).toBe(i);
-            expect(pageSnapshot.elements).toBeDefined();
-            expect(Array.isArray(pageSnapshot.elements)).toBe(true);
-        }
-    });
-
-    test('get document snapshot with type filter', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        // Get snapshot filtered by paragraphs only
-        const snapshot = await client.getDocumentSnapshot([ObjectType.PARAGRAPH]);
-        
-        expect(snapshot).toBeDefined();
-        expect(snapshot.pageCount).toBe(12);
-        
-        // Verify all elements are paragraphs
-        const allElements = snapshot.getAllElements();
-        for (const element of allElements) {
-            expect(element.type).toBe(ObjectType.PARAGRAPH);
-        }
-    });
-
-    test('get document snapshot with multiple type filters', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        // Get snapshot filtered by paragraphs and images
-        const snapshot = await client.getDocumentSnapshot([ObjectType.PARAGRAPH, ObjectType.IMAGE]);
-        
-        expect(snapshot).toBeDefined();
-        
-        // Verify all elements are either paragraphs or images
-        const allElements = snapshot.getAllElements();
-        for (const element of allElements) {
-            expect([ObjectType.PARAGRAPH, ObjectType.IMAGE]).toContain(element.type);
-        }
-    });
-
-    test('get page snapshot', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        const pageSnapshot = await client.getPageSnapshot(0);
-        
-        // Verify snapshot structure
-        expect(pageSnapshot).toBeDefined();
-        expect(pageSnapshot).toBeInstanceOf(PageSnapshot);
-        
-        // Verify page reference
-        expect(pageSnapshot.pageRef).toBeDefined();
-        expect(pageSnapshot.pageRef.position.pageIndex).toBe(0);
-        expect(pageSnapshot.pageRef.type).toBe(ObjectType.PAGE);
-        
-        // Verify elements
-        expect(pageSnapshot.elements).toBeDefined();
-        expect(Array.isArray(pageSnapshot.elements)).toBe(true);
-        expect(pageSnapshot.elements.length).toBeGreaterThan(0);
-        
-        // Verify each element has required properties
-        for (const element of pageSnapshot.elements) {
-            expect(element.internalId).toBeDefined();
-            expect(element.type).toBeDefined();
-            expect(element.position).toBeDefined();
-        }
-    });
-
-    test('get page snapshot with type filter', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        // Get page snapshot filtered by images only
-        const pageSnapshot = await client.getPageSnapshot(0, [ObjectType.IMAGE]);
-        
-        expect(pageSnapshot).toBeDefined();
-        
-        // Verify all elements are images
-        for (const element of pageSnapshot.elements) {
-            expect(element.type).toBe(ObjectType.IMAGE);
-        }
-    });
-
-    test('get page snapshot via PageClient', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        const page = client.page(1);
-        const pageSnapshot = await page.getSnapshot();
-        
-        // Verify snapshot structure
-        expect(pageSnapshot).toBeDefined();
-        expect(pageSnapshot).toBeInstanceOf(PageSnapshot);
-        expect(pageSnapshot.pageRef.position.pageIndex).toBe(1);
-        expect(pageSnapshot.elements.length).toBeGreaterThan(0);
-    });
-
-    test('get page snapshot via PageClient with type filter', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        const page = client.page(0);
-        const pageSnapshot = await page.getSnapshot([ObjectType.PARAGRAPH]);
-        
-        expect(pageSnapshot).toBeDefined();
-        
-        // Verify all elements are paragraphs
-        for (const element of pageSnapshot.elements) {
-            expect(element.type).toBe(ObjectType.PARAGRAPH);
-        }
-    });
-
-    test('DocumentSnapshot helper methods', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        const snapshot = await client.getDocumentSnapshot();
-        
-        // Test getPageSnapshot
-        const page0 = snapshot.getPageSnapshot(0);
-        expect(page0).toBeDefined();
-        expect(page0!.getPageIndex()).toBe(0);
-        
-        const page5 = snapshot.getPageSnapshot(5);
-        expect(page5).toBeDefined();
-        expect(page5!.getPageIndex()).toBe(5);
-        
-        // Test getAllElements
-        const allElements = snapshot.getAllElements();
-        expect(allElements.length).toBeGreaterThan(0);
-        
-        // Test getTotalElementCount
-        const totalCount = snapshot.getTotalElementCount();
-        expect(totalCount).toBe(allElements.length);
-        expect(totalCount).toBeGreaterThan(0);
-        
-        // Test getElementsByType
-        const paragraphs = snapshot.getElementsByType(ObjectType.PARAGRAPH);
-        expect(paragraphs.length).toBeGreaterThan(0);
-        for (const para of paragraphs) {
-            expect(para.type).toBe(ObjectType.PARAGRAPH);
-        }
-    });
-
-    test('PageSnapshot helper methods', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        const pageSnapshot = await client.getPageSnapshot(0);
-        
-        // Test getPageIndex
-        expect(pageSnapshot.getPageIndex()).toBe(0);
-        
-        // Test getElementCount
-        const elementCount = pageSnapshot.getElementCount();
-        expect(elementCount).toBe(pageSnapshot.elements.length);
-        expect(elementCount).toBeGreaterThan(0);
-        
-        // Test getElementsByType
-        const paragraphs = pageSnapshot.getElementsByType(ObjectType.PARAGRAPH);
-        for (const para of paragraphs) {
-            expect(para.type).toBe(ObjectType.PARAGRAPH);
-        }
-    });
-
-    test('snapshot with form fields', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('mixed-form-types.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        // Form fields can be TEXT_FIELD, CHECKBOX, or RADIO_BUTTON
-        const snapshot = await client.getDocumentSnapshot([
-            ObjectType.TEXT_FIELD,
-            ObjectType.CHECKBOX,
-            ObjectType.RADIO_BUTTON
-        ]);
-
-        expect(snapshot).toBeDefined();
-
-        // Get all form field types
-        const allFormFields = snapshot.getAllElements();
-        expect(allFormFields.length).toBeGreaterThan(0);
-
-        // Verify they are all form field types
-        const formFieldTypes = [ObjectType.TEXT_FIELD, ObjectType.CHECKBOX, ObjectType.RADIO_BUTTON];
-        for (const field of allFormFields) {
-            expect(formFieldTypes).toContain(field.type);
-        }
-    });
-
-    test('snapshot with paths', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('basic-paths.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        const snapshot = await client.getDocumentSnapshot([ObjectType.PATH]);
-        
-        expect(snapshot).toBeDefined();
-        
-        // Get all paths
-        const paths = snapshot.getElementsByType(ObjectType.PATH);
-        expect(paths.length).toBeGreaterThan(0);
-        
-        // Verify they are all paths
-        for (const path of paths) {
-            expect(path.type).toBe(ObjectType.PATH);
-        }
-    });
-
-    test('compare snapshot with individual find operations', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        // Get snapshot
-        const snapshot = await client.getPageSnapshot(0);
-        const snapshotParagraphs = snapshot.getElementsByType(ObjectType.PARAGRAPH);
-        
-        // Get paragraphs via page client
-        const page = client.page(0);
-        const paragraphs = await page.selectParagraphs();
-        
-        // Should have same count
-        expect(snapshotParagraphs.length).toBe(paragraphs.length);
-    });
-
-    test('snapshot fonts information', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        const snapshot = await client.getDocumentSnapshot();
-        
-        // Verify fonts array
-        expect(snapshot.fonts).toBeDefined();
-        expect(Array.isArray(snapshot.fonts)).toBe(true);
-        
-        // If there are fonts, verify their structure
-        if (snapshot.fonts.length > 0) {
-            for (const font of snapshot.fonts) {
-                expect(font.documentFontName).toBeDefined();
-                expect(font.systemFontName).toBeDefined();
-                expect(typeof font.documentFontName).toBe('string');
-                expect(typeof font.systemFontName).toBe('string');
-            }
-        }
-    });
-
-    test('snapshot on empty page', async () => {
-        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Empty.pdf');
-        const client = await PDFDancer.open(pdfData, token, baseUrl);
-
-        const snapshot = await client.getDocumentSnapshot();
-        
-        expect(snapshot).toBeDefined();
-        expect(snapshot.pageCount).toBeGreaterThan(0);
-        expect(snapshot.pages.length).toBeGreaterThan(0);
-        
-        // Empty pages might have no elements
-        const page0Snapshot = snapshot.getPageSnapshot(0);
-        expect(page0Snapshot).toBeDefined();
-        expect(page0Snapshot!.elements).toBeDefined();
-        expect(Array.isArray(page0Snapshot!.elements)).toBe(true);
-    });
-});

package/src/__tests__/e2e/test-helpers.ts

@@ -1,152 +0,0 @@
-/**
- * Helper functions for e2e tests
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import os from "os";
-
-/**
- * Get the base URL from environment variable or default
- */
-export function getBaseUrl(): string {
-    return (process.env.PDFDANCER_BASE_URL || 'http://localhost:8080').trim();
-}
-
-/**
- * Read authentication token from environment or token files
- */
-export function readToken(): string | null {
-    const token = process.env.PDFDANCER_TOKEN;
-    if (token) {
-        return token.trim();
-    }
-
-    // Try common token files in project root
-    const projectRoot = path.resolve(__dirname, '../../..');
-    const candidates = findFiles(projectRoot, 'jwt-token-*.txt');
-
-    for (const file of candidates) {
-        try {
-            return fs.readFileSync(file, 'utf-8').trim();
-        } catch {
-            continue;
-        }
-    }
-
-    return null;
-}
-
-/**
- * Check if server is up and running
- */
-export async function serverUp(baseUrl: string): Promise<boolean> {
-    try {
-        const response = await fetch(`${baseUrl}/ping`, {
-            signal: AbortSignal.timeout(60000)
-        });
-        const text = await response.text();
-        let pongReceived = response.status === 200 && text.includes('Pong');
-        if (!pongReceived) {
-            console.error(`Server did not respond with Pong. Response: ${text}, status ${response.status}`);
-        }
-        return pongReceived;
-    } catch (e) {
-        console.error("Server down", e)
-        return false;
-    }
-}
-
-/**
- * Helper to find files matching a pattern
- */
-function findFiles(dir: string, pattern: string): string[] {
-    try {
-        const files = fs.readdirSync(dir);
-        const regex = new RegExp(pattern.replace('*', '.*'));
-        return files
-            .filter(file => regex.test(file))
-            .map(file => path.join(dir, file));
-    } catch {
-        return [];
-    }
-}
-
-/**
- * Require environment variables and PDF fixture for testing
- */
-export async function requireEnvAndFixture(pdfFilename: string): Promise<[string, string, Uint8Array]> {
-    const baseUrl = getBaseUrl();
-    const token = readToken();
-
-    if (!await serverUp(baseUrl)) {
-        throw new Error(`PDFDancer server not reachable at ${baseUrl}; set PDFDANCER_BASE_URL or start server`);
-    }
-
-    if (!token) {
-        throw new Error('PDFDANCER_TOKEN not set and no token file found; set env or place jwt-token-*.txt in repo');
-    }
-
-    // Look for PDF fixture file
-    const fixturesDir = path.resolve(__dirname, '../../../fixtures');
-    const pdfPath = path.join(fixturesDir, pdfFilename);
-
-    if (!fs.existsSync(pdfPath)) {
-        throw new Error(`${pdfFilename} fixture not found at ${pdfPath}`);
-    }
-
-    const pdfData = fs.readFileSync(pdfPath);
-    return [baseUrl, token, new Uint8Array(pdfData)];
-}
-
-/**
- * Helper to open temporary file path (for Node.js environment)
- */
-export function createTempPath(filename: string): string {
-    const tmpDir =
-        process.env.TMPDIR ||
-        process.env.TEMP ||
-        process.env.TMP ||
-        os.tmpdir(); // reliable built-in fallback
-
-    return path.join(tmpDir, filename);
-}
-
-/**
- * Helper to read image file for tests
- */
-export function readImageFixture(filename: string): Uint8Array {
-    const imagePath = getImagePath(filename);
-
-    if (!fs.existsSync(imagePath)) {
-        throw new Error(`Image fixture not found: ${filename}`);
-    }
-
-    const imageData = fs.readFileSync(imagePath);
-    return new Uint8Array(imageData);
-}
-
-export function getImagePath(filename: string): string {
-    const fixturesDir = path.resolve(__dirname, '../../../fixtures');
-    return path.join(fixturesDir, filename);
-}
-
-export function getFontPath(filename: string) {
-    const fixturesDir = path.resolve(__dirname, '../../../fixtures');
-    const fontPath = path.join(fixturesDir, filename);
-    return fontPath;
-}
-
-/**
- * Helper to read font file for tests
- */
-export function readFontFixture(filename: string): Uint8Array {
-    const fontPath = getFontPath(filename);
-
-    if (!fs.existsSync(fontPath)) {
-        throw new Error(`Font fixture not found: ${filename}`);
-    }
-
-    const fontData = fs.readFileSync(fontPath);
-    return new Uint8Array(fontData);
-}

package/src/__tests__/e2e/token_from_env.test.ts

@@ -1,80 +0,0 @@
-import {requireEnvAndFixture} from "./test-helpers";
-import {PDFDancer} from "../../pdfdancer_v1";
-import {HttpClientException, ValidationException} from "../../exceptions";
-
-describe('Env Token E2E Tests', () => {
-    let originalToken: string | undefined;
-    let originalBaseUrl: string | undefined;
-    let baseUrl: string;
-    let pdfData: Uint8Array;
-    let validToken: string;
-
-    const restoreEnv = () => {
-        if (originalToken !== undefined) {
-            process.env.PDFDANCER_TOKEN = originalToken;
-        } else {
-            delete process.env.PDFDANCER_TOKEN;
-        }
-
-        if (originalBaseUrl !== undefined) {
-            process.env.PDFDANCER_BASE_URL = originalBaseUrl;
-        } else {
-            delete process.env.PDFDANCER_BASE_URL;
-        }
-    };
-
-    beforeAll(async () => {
-        originalToken = process.env.PDFDANCER_TOKEN;
-        originalBaseUrl = process.env.PDFDANCER_BASE_URL;
-
-        [baseUrl, validToken, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-    });
-
-    beforeEach(() => {
-        restoreEnv();
-    });
-
-    afterEach(() => {
-        restoreEnv();
-    });
-
-    afterAll(() => {
-        restoreEnv();
-    });
-
-    test('opens with token from env', async () => {
-        process.env.PDFDANCER_TOKEN = validToken;
-        const client = await PDFDancer.open(pdfData, undefined, baseUrl);
-        expect(client).toBeInstanceOf(PDFDancer);
-    });
-
-    test('fails with unreachable base url', async () => {
-        process.env.PDFDANCER_TOKEN = validToken;
-        process.env.PDFDANCER_BASE_URL = "http://www.google.com";
-
-        await expect(async () => {
-            try {
-                await PDFDancer.open(pdfData);
-            } catch (error) {
-                expect(error).toBeInstanceOf(HttpClientException);
-                throw error;
-            }
-        }).rejects.toThrow(HttpClientException);
-    });
-
-    test('fails with invalid token', async () => {
-        process.env.PDFDANCER_TOKEN = "invalid-token";
-        process.env.PDFDANCER_BASE_URL = "https://api.pdfdancer.com";
-
-        await expect(async () => {
-            try {
-                await PDFDancer.open(pdfData);
-            } catch (error) {
-                expect(error).toBeInstanceOf(ValidationException);
-                expect((error as Error).message)
-                    .toContain("Authentication with the PDFDancer API failed. Confirm that your API token is valid, has not expired");
-                throw error;
-            }
-        }).rejects.toThrow(ValidationException);
-    });
-});

package/src/__tests__/fingerprint.test.ts

@@ -1,36 +0,0 @@
-/**
- * Tests for fingerprint generation
- */
-
-import {generateFingerprint} from '../fingerprint';
-
-describe('Fingerprint', () => {
-    it('should generate a valid SHA256 fingerprint', async () => {
-        const fingerprint = await generateFingerprint();
-
-        // SHA256 produces 64 hex characters
-        expect(fingerprint).toHaveLength(64);
-        expect(fingerprint).toMatch(/^[a-f0-9]{64}$/);
-    });
-
-    it('should generate different fingerprints for different user IDs', async () => {
-        const fingerprint1 = await generateFingerprint('user1');
-        const fingerprint2 = await generateFingerprint('user2');
-
-        expect(fingerprint1).not.toBe(fingerprint2);
-        expect(fingerprint1).toHaveLength(64);
-        expect(fingerprint2).toHaveLength(64);
-    });
-
-    it('should generate consistent fingerprints for same user ID', async () => {
-        const fingerprint1 = await generateFingerprint('user123');
-        const fingerprint2 = await generateFingerprint('user123');
-
-        // Note: These might differ due to install salt randomness in test environment
-        // but they should both be valid SHA256 hashes
-        expect(fingerprint1).toHaveLength(64);
-        expect(fingerprint2).toHaveLength(64);
-        expect(fingerprint1).toMatch(/^[a-f0-9]{64}$/);
-        expect(fingerprint2).toMatch(/^[a-f0-9]{64}$/);
-    });
-});