@aj-archipelago/cortex/helper-apps/cortex-file-handler/tests/storage/LocalStorageProvider.test.js

Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.

import test from 'ava';
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import { LocalStorageProvider } from '../../src/services/storage/LocalStorageProvider.js';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

test.before(() => {
    // Create test directory
    const testDir = path.join(__dirname, 'test-files');
    if (!fs.existsSync(testDir)) {
        fs.mkdirSync(testDir, { recursive: true });
    }
});

test.after(() => {
    // Cleanup test directory
    const testDir = path.join(__dirname, 'test-files');
    if (fs.existsSync(testDir)) {
        fs.rmSync(testDir, { recursive: true });
    }
});

test('should create provider with valid path', (t) => {
    const provider = new LocalStorageProvider(path.join(__dirname, 'test-files'));
    t.truthy(provider);
});

test('should throw error with missing path', (t) => {
    t.throws(() => {
        new LocalStorageProvider(null);
    }, { message: 'Missing public folder path' });
});

test('should create public folder if it does not exist', (t) => {
    const testDir = path.join(__dirname, 'test-files', 'new-folder');
    if (fs.existsSync(testDir)) {
        fs.rmSync(testDir, { recursive: true });
    }

    const provider = new LocalStorageProvider(testDir);
    t.true(fs.existsSync(testDir));
});

test('should upload and delete file', async (t) => {
    const provider = new LocalStorageProvider(path.join(__dirname, 'test-files'));

    // Create test file
    const testContent = 'Hello World!';
    const testFile = path.join(__dirname, 'test.txt');
    fs.writeFileSync(testFile, testContent);

    try {
        // Upload file
        const requestId = 'test-upload';
        const result = await provider.uploadFile({}, testFile, requestId);
        
        t.truthy(result.url);
        t.truthy(result.blobName);
        t.true(result.url.includes('/files/'));
        t.true(result.blobName.startsWith(requestId));

        // Verify file exists
        const exists = await provider.fileExists(result.url);
        t.true(exists);

        // Delete file
        const deleted = await provider.deleteFiles(requestId);
        t.true(deleted.length > 0);
        t.true(deleted[0].startsWith(requestId));

        // Verify file is gone
        const existsAfterDelete = await provider.fileExists(result.url);
        t.false(existsAfterDelete);
    } finally {
        // Cleanup test file
        if (fs.existsSync(testFile)) {
            fs.unlinkSync(testFile);
        }
    }
});

test('should handle file download', async (t) => {
    const provider = new LocalStorageProvider(path.join(__dirname, 'test-files'));

    // Create test file
    const testContent = 'Hello World!';
    const testFile = path.join(__dirname, 'test.txt');
    fs.writeFileSync(testFile, testContent);

    try {
        // Upload file
        const requestId = 'test-download';
        const result = await provider.uploadFile({}, testFile, requestId);

        // Download to new location
        const downloadPath = path.join(__dirname, 'downloaded.txt');
        await provider.downloadFile(result.url, downloadPath);

        // Verify content
        const downloadedContent = fs.readFileSync(downloadPath, 'utf8');
        t.is(downloadedContent, testContent);

        // Cleanup
        await provider.deleteFiles(requestId);
        fs.unlinkSync(downloadPath);
    } finally {
        // Cleanup test file
        if (fs.existsSync(testFile)) {
            fs.unlinkSync(testFile);
        }
    }
});

test('should handle cleanup of multiple files', async (t) => {
    const provider = new LocalStorageProvider(path.join(__dirname, 'test-files'));

    // Create test files
    const testContent = 'Hello World!';
    const testFile1 = path.join(__dirname, 'test1.txt');
    const testFile2 = path.join(__dirname, 'test2.txt');
    fs.writeFileSync(testFile1, testContent);
    fs.writeFileSync(testFile2, testContent);

    try {
        // Upload files
        const requestId1 = 'test-cleanup-1';
        const requestId2 = 'test-cleanup-2';
        const result1 = await provider.uploadFile({}, testFile1, requestId1);
        const result2 = await provider.uploadFile({}, testFile2, requestId2);

        // Cleanup files
        const cleaned = await provider.cleanup([result1.url, result2.url]);
        t.is(cleaned.length, 2);

        // Verify files are gone
        const exists1 = await provider.fileExists(result1.url);
        const exists2 = await provider.fileExists(result2.url);
        t.false(exists1);
        t.false(exists2);
    } finally {
        // Cleanup test files
        if (fs.existsSync(testFile1)) fs.unlinkSync(testFile1);
        if (fs.existsSync(testFile2)) fs.unlinkSync(testFile2);
    }
});