Files
splatoon3.ink/app/data/LocalizationProcessor.test.mjs
Matt Isenhower 21a4f5d85c Route backend file access through storage and auth seams
Prepare the shared updater and social code to run against R2 in a Worker
while keeping the local Node runner working:

- Add app/common/storage with public, private, and archive areas keyed like
  the R2 objects. FilesystemStorage maps them onto dist/ and storage/ for
  Node; BucketStorage wraps R2 bindings. Storage is configured once per
  process; only image existence is cached, so JSON reads are always fresh.
- Move ValueCache, DataUpdater (data, calendars, archive snapshots),
  ImageProcessor, LocalizationProcessor, festival updaters, status
  generators, social translations, ImageWriter, and Buffer/Threads image
  hosting onto storage. Query hashes are a JSON import.
- Add app/splatnet/auth.mjs: the existing bullet-token code behind auth(),
  so the Worker can route token requests to per-region Durable Objects.
  warmCaches uses auth().refresh().
- Remove the S3/R2 sync, vfs, the dual upload, the sync commands, and
  s3-sync-client. Local runs no longer read from or write to remote buckets.
- Give every test fresh in-memory storage via app/test/setup.mjs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 16:03:33 -08:00

168 lines
5.6 KiB
JavaScript

import { describe, expect, it } from 'vitest';
import { LocalizationProcessor } from './LocalizationProcessor.mjs';
function makeProcessor(rulesets) {
return new LocalizationProcessor({ code: 'en-US' }, rulesets);
}
describe('LocalizationProcessor', () => {
describe('filename', () => {
it('returns the correct path for the locale', () => {
const processor = makeProcessor([]);
expect(processor.filename).toBe('data/locale/en-US.json');
});
it('uses the locale code', () => {
const processor = new LocalizationProcessor({ code: 'ja-JP' }, []);
expect(processor.filename).toBe('data/locale/ja-JP.json');
});
});
describe('rulesetIterations', () => {
it('yields one entry for a simple ruleset', () => {
const processor = makeProcessor([
{ key: 'stages', nodes: '$.stages.*', id: 'id', values: 'name' },
]);
const results = [...processor.rulesetIterations()];
expect(results).toEqual([
{ key: 'stages', node: '$.stages.*', id: 'id', value: 'name' },
]);
});
it('yields entries for multiple nodes (array)', () => {
const processor = makeProcessor([
{ key: 'weapons', nodes: ['$.main.*', '$.sub.*'], id: 'id', values: 'name' },
]);
const results = [...processor.rulesetIterations()];
expect(results).toEqual([
{ key: 'weapons', node: '$.main.*', id: 'id', value: 'name' },
{ key: 'weapons', node: '$.sub.*', id: 'id', value: 'name' },
]);
});
it('yields entries for multiple values (array)', () => {
const processor = makeProcessor([
{ key: 'stages', nodes: '$.stages.*', id: 'id', values: ['name', 'description'] },
]);
const results = [...processor.rulesetIterations()];
expect(results).toEqual([
{ key: 'stages', node: '$.stages.*', id: 'id', value: 'name' },
{ key: 'stages', node: '$.stages.*', id: 'id', value: 'description' },
]);
});
it('yields cartesian product for multiple nodes and values', () => {
const processor = makeProcessor([
{ key: 'items', nodes: ['$.a.*', '$.b.*'], id: 'id', values: ['name', 'desc'] },
]);
const results = [...processor.rulesetIterations()];
expect(results).toHaveLength(4);
expect(results).toEqual([
{ key: 'items', node: '$.a.*', id: 'id', value: 'name' },
{ key: 'items', node: '$.a.*', id: 'id', value: 'desc' },
{ key: 'items', node: '$.b.*', id: 'id', value: 'name' },
{ key: 'items', node: '$.b.*', id: 'id', value: 'desc' },
]);
});
it('yields entries across multiple rulesets', () => {
const processor = makeProcessor([
{ key: 'stages', nodes: '$.stages.*', id: 'id', values: 'name' },
{ key: 'weapons', nodes: '$.weapons.*', id: 'id', values: 'name' },
]);
const results = [...processor.rulesetIterations()];
expect(results).toHaveLength(2);
expect(results[0].key).toBe('stages');
expect(results[1].key).toBe('weapons');
});
});
describe('dataIterations', () => {
it('finds matching nodes at any depth', () => {
const processor = makeProcessor([
{ key: 'stages', nodes: '$..stages.*', id: 'id', values: 'name' },
]);
const data = {
schedules: [
{ stages: [{ id: 'stage-1', name: 'Scorch Gorge' }] },
{ nested: { stages: [{ id: 'stage-2', name: 'Eeltail Alley' }] } },
],
};
expect([...processor.dataIterations(data)].map(({ id, value }) => ({ id, value }))).toEqual([
{ id: 'stage-1', value: 'Scorch Gorge' },
{ id: 'stage-2', value: 'Eeltail Alley' },
]);
});
it('yields entries with correct id, value, and path', () => {
const processor = makeProcessor([
{ key: 'stages', nodes: '$.stages[*]', id: 'id', values: 'name' },
]);
const data = {
stages: [
{ id: 'stage-1', name: 'Scorch Gorge' },
{ id: 'stage-2', name: 'Eeltail Alley' },
],
};
const results = [...processor.dataIterations(data)];
expect(results).toHaveLength(2);
expect(results[0].id).toBe('stage-1');
expect(results[0].value).toBe('Scorch Gorge');
expect(results[0].path).toBe('stages.stage-1.name');
expect(results[1].id).toBe('stage-2');
expect(results[1].value).toBe('Eeltail Alley');
expect(results[1].path).toBe('stages.stage-2.name');
});
it('skips null nodes from jsonpath results', () => {
const processor = makeProcessor([
{ key: 'items', nodes: '$.items[*]', id: 'id', values: 'name' },
]);
const data = {
items: [null, { id: 'item-1', name: 'Test' }, null],
};
const results = [...processor.dataIterations(data)];
expect(results).toHaveLength(1);
expect(results[0].id).toBe('item-1');
});
it('handles nested id paths via lodash get', () => {
const processor = makeProcessor([
{ key: 'gear', nodes: '$.gear[*]', id: 'meta.id', values: 'meta.name' },
]);
const data = {
gear: [{ meta: { id: 'g-1', name: 'Splat Helmet' } }],
};
const results = [...processor.dataIterations(data)];
expect(results).toHaveLength(1);
expect(results[0].id).toBe('g-1');
expect(results[0].value).toBe('Splat Helmet');
expect(results[0].path).toBe('gear.g-1.meta.name');
});
it('returns empty for non-matching jsonpath', () => {
const processor = makeProcessor([
{ key: 'stages', nodes: '$.nonexistent[*]', id: 'id', values: 'name' },
]);
const results = [...processor.dataIterations({})];
expect(results).toHaveLength(0);
});
});
});