chore: import upstream snapshot with attribution

test/util/jsonlOutput.test.ts

@@ -0,0 +1,253 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { writeOutput } from '../../src/util/index';
+import { createTempDir, removeTempDir } from './utils';
+
+// Mock dependencies
+vi.mock('../../src/database', () => ({
+  getDb: vi.fn().mockReturnValue({
+    select: vi.fn(),
+    insert: vi.fn(),
+    transaction: vi.fn(),
+  }),
+}));
+
+vi.mock('../../src/logger', () => ({
+  default: {
+    info: vi.fn(),
+    debug: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  },
+}));
+
+describe('JSONL output with proper line endings', () => {
+  let tempDir: string;
+  let tempFilePath: string;
+  let mockEval: any;
+
+  beforeEach(() => {
+    tempDir = createTempDir('promptfoo-jsonl-test-');
+    tempFilePath = path.join(tempDir, 'test-export.jsonl');
+
+    mockEval = {
+      id: 'test-eval-id',
+      createdAt: '2025-01-01T00:00:00.000Z',
+      author: 'test-author',
+      config: { testConfig: true },
+      prompts: [
+        { raw: 'Test prompt 1', label: 'prompt1' },
+        { raw: 'Test prompt 2', label: 'prompt2' },
+      ],
+      fetchResultsBatched: vi.fn(),
+    };
+  });
+
+  afterEach(() => {
+    removeTempDir(tempDir);
+    vi.clearAllMocks();
+  });
+
+  it('should produce valid JSONL with proper line endings between batches', async () => {
+    // Mock fetchResultsBatched to return multiple batches
+    const batch1 = [
+      { testIdx: 0, success: true, score: 1.0, output: 'result 1' },
+      { testIdx: 1, success: true, score: 0.9, output: 'result 2' },
+    ];
+    const batch2 = [
+      { testIdx: 2, success: true, score: 0.8, output: 'result 3' },
+      { testIdx: 3, success: false, score: 0.0, output: 'result 4' },
+    ];
+
+    // Create async iterator for batches
+    const batchIterator = [batch1, batch2];
+
+    mockEval.fetchResultsBatched = vi.fn().mockImplementation(async function* () {
+      for (const batch of batchIterator) {
+        yield batch;
+      }
+    });
+
+    await writeOutput(tempFilePath, mockEval, null);
+
+    expect(fs.existsSync(tempFilePath)).toBe(true);
+    const content = fs.readFileSync(tempFilePath, 'utf8');
+
+    // Split by lines and filter out empty lines
+    const lines = content.split(/\r?\n/).filter((line) => line.trim() !== '');
+
+    // Should have exactly 4 JSON objects (2 per batch)
+    expect(lines).toHaveLength(4);
+
+    // Each line should be valid JSON
+    lines.forEach((line, index) => {
+      expect(() => JSON.parse(line)).not.toThrow();
+      const parsed = JSON.parse(line);
+      expect(parsed).toHaveProperty('testIdx', index);
+      expect(parsed).toHaveProperty('output', `result ${index + 1}`);
+    });
+
+    // File should end with a newline
+    expect(content.endsWith('\n')).toBe(true);
+  });
+
+  it('should handle single batch correctly', async () => {
+    const singleBatch = [{ testIdx: 0, success: true, score: 1.0, output: 'single result' }];
+
+    mockEval.fetchResultsBatched = vi.fn().mockImplementation(async function* () {
+      yield singleBatch;
+    });
+
+    await writeOutput(tempFilePath, mockEval, null);
+
+    const content = fs.readFileSync(tempFilePath, 'utf8');
+    const lines = content.split(/\r?\n/).filter((line) => line.trim() !== '');
+
+    expect(lines).toHaveLength(1);
+    expect(() => JSON.parse(lines[0])).not.toThrow();
+    expect(content.endsWith('\n')).toBe(true);
+  });
+
+  it('should handle empty batches gracefully', async () => {
+    mockEval.fetchResultsBatched = vi.fn().mockImplementation(async function* () {
+      yield [];
+      yield [{ testIdx: 0, success: true, score: 1.0, output: 'after empty' }];
+      yield [];
+    });
+
+    await writeOutput(tempFilePath, mockEval, null);
+
+    const content = fs.readFileSync(tempFilePath, 'utf8');
+    const lines = content.split(/\r?\n/).filter((line) => line.trim() !== '');
+
+    expect(lines).toHaveLength(1);
+    expect(() => JSON.parse(lines[0])).not.toThrow();
+    const parsed = JSON.parse(lines[0]);
+    expect(parsed.output).toBe('after empty');
+  });
+
+  it('should use OS-specific line endings', async () => {
+    const batch = [{ testIdx: 0, success: true, score: 1.0, output: 'test result' }];
+
+    mockEval.fetchResultsBatched = vi.fn().mockImplementation(async function* () {
+      yield batch;
+    });
+
+    await writeOutput(tempFilePath, mockEval, null);
+
+    const content = fs.readFileSync(tempFilePath, 'utf8');
+
+    // Content should end with the OS-specific line ending
+    expect(content.endsWith(os.EOL)).toBe(true);
+
+    // For multiple results, should use OS line endings between them
+    const multiResultBatch = [
+      { testIdx: 0, success: true, score: 1.0, output: 'result 1' },
+      { testIdx: 1, success: true, score: 0.9, output: 'result 2' },
+    ];
+
+    mockEval.fetchResultsBatched = vi.fn().mockImplementation(async function* () {
+      yield multiResultBatch;
+    });
+
+    // Clear the file
+    fs.unlinkSync(tempFilePath);
+
+    await writeOutput(tempFilePath, mockEval, null);
+
+    const multiContent = fs.readFileSync(tempFilePath, 'utf8');
+    const expectedContent =
+      multiResultBatch.map((result) => JSON.stringify(result)).join(os.EOL) + os.EOL;
+
+    expect(multiContent).toBe(expectedContent);
+  });
+
+  it('should preserve the existing artifact when a rewrite fails', async () => {
+    fs.writeFileSync(tempFilePath, '{"status":"existing"}\n');
+    mockEval.fetchResultsBatched = vi.fn().mockImplementation(async function* () {
+      yield [{ testIdx: 0, success: true, score: 1.0, output: 'replacement' }];
+      throw new Error('simulated rewrite failure');
+    });
+
+    await expect(writeOutput(tempFilePath, mockEval, null)).rejects.toThrow(
+      'simulated rewrite failure',
+    );
+
+    expect(fs.readFileSync(tempFilePath, 'utf8')).toBe('{"status":"existing"}\n');
+    expect(fs.readdirSync(tempDir)).toEqual(['test-export.jsonl']);
+  });
+
+  it('should preserve existing artifact permissions during a rewrite', async () => {
+    if (process.platform === 'win32') {
+      return;
+    }
+
+    fs.writeFileSync(tempFilePath, '{"status":"existing"}\n', { mode: 0o644 });
+    fs.chmodSync(tempFilePath, 0o644);
+    mockEval.fetchResultsBatched = vi.fn().mockImplementation(async function* () {
+      yield [{ testIdx: 0, success: true, score: 1.0, output: 'replacement' }];
+    });
+
+    const originalUmask = process.umask(0o077);
+    try {
+      await writeOutput(tempFilePath, mockEval, null);
+    } finally {
+      process.umask(originalUmask);
+    }
+
+    expect(fs.statSync(tempFilePath).mode & 0o777).toBe(0o644);
+  });
+
+  it('should preserve an existing artifact symlink during a rewrite', async () => {
+    if (process.platform === 'win32') {
+      return;
+    }
+
+    const targetPath = path.join(tempDir, 'target.jsonl');
+    fs.writeFileSync(targetPath, '{"status":"existing"}\n');
+    fs.symlinkSync(targetPath, tempFilePath);
+    mockEval.fetchResultsBatched = vi.fn().mockImplementation(async function* () {
+      yield [{ testIdx: 0, success: true, score: 1.0, output: 'replacement' }];
+    });
+
+    await writeOutput(tempFilePath, mockEval, null);
+
+    expect(fs.lstatSync(tempFilePath).isSymbolicLink()).toBe(true);
+    expect(fs.readFileSync(targetPath, 'utf8')).toContain('"output":"replacement"');
+  });
+
+  it('should preserve a dangling artifact symlink and create its target during a rewrite', async () => {
+    if (process.platform === 'win32') {
+      return;
+    }
+
+    const targetPath = path.join(tempDir, 'missing-target.jsonl');
+    fs.symlinkSync(path.basename(targetPath), tempFilePath);
+    mockEval.fetchResultsBatched = vi.fn().mockImplementation(async function* () {
+      yield [{ testIdx: 0, success: true, score: 1.0, output: 'replacement' }];
+    });
+
+    await writeOutput(tempFilePath, mockEval, null);
+
+    expect(fs.lstatSync(tempFilePath).isSymbolicLink()).toBe(true);
+    expect(fs.readFileSync(targetPath, 'utf8')).toContain('"output":"replacement"');
+  });
+
+  it('should rewrite an artifact with a long valid basename', async () => {
+    if (process.platform === 'win32') {
+      return;
+    }
+
+    const longFilePath = path.join(tempDir, `${'a'.repeat(240)}.jsonl`);
+    mockEval.fetchResultsBatched = vi.fn().mockImplementation(async function* () {
+      yield [{ testIdx: 0, success: true, score: 1.0, output: 'replacement' }];
+    });
+
+    await writeOutput(longFilePath, mockEval, null);
+
+    expect(fs.readFileSync(longFilePath, 'utf8')).toContain('"output":"replacement"');
+  });
+});