@vessl-ai/mcpctl-control-plane
Version:
Vessl MCP Control Plane service for managing distributed jobs.
91 lines • 3.48 kB
JavaScript
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { ConfigService } from '@nestjs/config';
import { Test } from '@nestjs/testing';
import { AppCacheService } from './appcache.service';
jest.mock('fs/promises', () => ({
readFile: jest.fn(),
writeFile: jest.fn(),
mkdir: jest.fn(),
}));
jest.mock('path', () => require('path-browserify'));
jest.mock('fs', () => ({
existsSync: jest.fn(),
}));
class FakeCacheableMemory {
}
function makeMemoryStore(entries = {}) {
return {
store: new FakeCacheableMemory(),
iterator: async function* () {
for (const [key, value] of Object.entries(entries)) {
yield [key, value];
}
},
};
}
describe('AppCacheService (restore/backup only)', () => {
let service;
let cacheManagerMock;
let configServiceMock;
let fsPromises;
let fs;
beforeEach(async () => {
jest.resetModules();
fsPromises = require('fs/promises');
fs = require('fs');
fsPromises.readFile.mockReset();
fsPromises.writeFile.mockReset();
fsPromises.mkdir.mockReset();
fs.existsSync.mockReset();
cacheManagerMock = {
stores: [makeMemoryStore({ foo: 'bar', baz: 42 })],
set: jest.fn(),
};
configServiceMock = {
get: jest.fn().mockImplementation((key) => {
if (key === 'cache')
return { backupDir: '/tmp/mock-backup' };
return undefined;
}),
};
const module = await Test.createTestingModule({
providers: [
AppCacheService,
{ provide: CACHE_MANAGER, useValue: cacheManagerMock },
{ provide: ConfigService, useValue: configServiceMock },
],
}).compile();
service = module.get(AppCacheService);
});
it('should restore cache from backup file if it exists', async () => {
fs.existsSync.mockReturnValue(true);
fsPromises.readFile.mockResolvedValue('{"foo":"bar","baz":42}');
cacheManagerMock.set.mockResolvedValue(undefined);
await service.restore();
expect(cacheManagerMock.set).toHaveBeenCalledWith('foo', 'bar');
expect(cacheManagerMock.set).toHaveBeenCalledWith('baz', 42);
});
it('should do nothing if backup file does not exist', async () => {
fs.existsSync.mockReturnValue(false);
await service.restore();
expect(cacheManagerMock.set).not.toHaveBeenCalled();
});
it('should save memory cache to file on backup', async () => {
fs.existsSync.mockImplementation((p) => p === '/tmp/mock-backup');
fsPromises.writeFile.mockResolvedValue(undefined);
const expected = JSON.stringify({ foo: 'bar', baz: 42 }, null, 2);
await service.backup();
expect(fsPromises.writeFile).toHaveBeenCalledWith('/tmp/mock-backup/memory-cache.json', expected);
});
it('should create backup directory if it does not exist', async () => {
fs.existsSync.mockReturnValue(false);
fsPromises.mkdir.mockResolvedValue(undefined);
fsPromises.writeFile.mockResolvedValue(undefined);
await service.backup();
expect(fsPromises.mkdir).toHaveBeenCalledWith('/tmp/mock-backup', {
recursive: true,
});
expect(fsPromises.writeFile).toHaveBeenCalled();
});
});
//# sourceMappingURL=appcache.service.spec.js.map