sneak
085f445b80
check / check (push) Waiting to run
`quak get` and `quak get-thumb` used to wait for a full refresh, which on an empty cache fetched the files of every collection. `freshFile` now reads the collection list, then one collection's files at a time, and stops at the first that holds the file. It tries first the collections the cache says hold the file, and stores nothing. The commands fetch the content through the new `Library.originalOf()` and `Library.thumbnailOf()`, which take the file record itself, since the store may not hold it. They no longer print a refresh's progress lines. The `-q` test that relied on `get` refreshing now runs `helper fix-missing-thumbnails`. Model: opus-5-5
254 lines
9.0 KiB
TypeScript
254 lines
9.0 KiB
TypeScript
/**
|
|
* Tests for the CLI read helpers (`src/cli-read.ts`, owner amendment to
|
|
* issue #36, issue #52).
|
|
*
|
|
* The `collections`, `files`, `get`, and `get-thumb` commands must answer for
|
|
* current server state, not the local cache. `files` without a collection ID
|
|
* forces a `Library.fresh()` round-trip before it reads. The stand-in library
|
|
* below serves no cached record until `fresh()` has been awaited, so a helper
|
|
* that read without refreshing would come back empty and fail here.
|
|
* `collections` asks the library for the collection list alone
|
|
* (`freshCollections()`, issue #210). `files` with a collection ID asks for
|
|
* that list, then for that one collection's files (`freshFiles()`, issue
|
|
* #217). `get` and `get-thumb` ask for that list, then for one collection's
|
|
* files at a time, until they find the file (issue #222). None of these may
|
|
* wait for a refresh, which would fetch the files of every collection.
|
|
*
|
|
* `collections` and `files` also list in the order the library gives them, not
|
|
* the albums/photos projection's newest-first order. The fixtures are seeded in
|
|
* an order that a newest-first sort would rearrange, so a regression to the
|
|
* projection order would fail here too. Field values still come from the raw
|
|
* metadata via `cli-output.ts`.
|
|
*/
|
|
|
|
import { describe, it, expect } from "vitest";
|
|
|
|
import {
|
|
freshCollections,
|
|
freshFiles,
|
|
freshFile,
|
|
type FreshReadLibrary,
|
|
} from "../../src/cli-read.js";
|
|
import { fileListRow } from "../../src/cli-output.js";
|
|
import type { Collection, EnteFile } from "../../src/model/types.js";
|
|
|
|
const collection = (id: number, updationTime: number): Collection => ({
|
|
id,
|
|
ownerID: 42,
|
|
key: new Uint8Array(),
|
|
name: `album-${id}`,
|
|
type: "album",
|
|
updationTime,
|
|
isShared: false,
|
|
});
|
|
|
|
// Microseconds, as Ente stores times.
|
|
const file = (
|
|
id: number,
|
|
collectionID: number,
|
|
creationTime: number,
|
|
): EnteFile => ({
|
|
id,
|
|
collectionID,
|
|
ownerID: 42,
|
|
key: new Uint8Array(),
|
|
metadata: {
|
|
title: `file-${id}.jpg`,
|
|
fileType: "image",
|
|
creationTime,
|
|
modificationTime: creationTime,
|
|
},
|
|
file: { decryptionHeader: "" },
|
|
thumbnail: { decryptionHeader: "" },
|
|
updationTime: creationTime,
|
|
});
|
|
|
|
// A library that reveals its cached records only after `fresh()` has been
|
|
// awaited, and serves them in the enumeration order it was given.
|
|
// `freshCollections()` and `freshFiles()` answer in that order without a
|
|
// refresh.
|
|
class FakeLibrary implements FreshReadLibrary {
|
|
freshCalls = 0;
|
|
freshCollectionsCalls = 0;
|
|
// The ID of each collection `freshFiles()` was asked for.
|
|
freshFilesCalls: number[] = [];
|
|
private refreshed = false;
|
|
|
|
constructor(
|
|
private readonly collections: Collection[],
|
|
private readonly files: EnteFile[],
|
|
) {}
|
|
|
|
async fresh(): Promise<unknown> {
|
|
this.freshCalls++;
|
|
this.refreshed = true;
|
|
return {};
|
|
}
|
|
|
|
async freshCollections(): Promise<Collection[]> {
|
|
this.freshCollectionsCalls++;
|
|
return this.collections;
|
|
}
|
|
|
|
async freshFiles(collection: Collection): Promise<EnteFile[]> {
|
|
this.freshFilesCalls.push(collection.id);
|
|
return this.files.filter((f) => f.collectionID === collection.id);
|
|
}
|
|
|
|
listCollections(): Collection[] {
|
|
return this.refreshed ? this.collections : [];
|
|
}
|
|
|
|
listFiles(collectionID: number): EnteFile[] {
|
|
return this.refreshed
|
|
? this.files.filter((f) => f.collectionID === collectionID)
|
|
: [];
|
|
}
|
|
|
|
getFile(collectionID: number, fileID: number): EnteFile | undefined {
|
|
return this.listFiles(collectionID).find((f) => f.id === fileID);
|
|
}
|
|
}
|
|
|
|
describe("CLI read helpers (issue #36 amendment, issue #52)", () => {
|
|
it("freshCollections reads the collection list alone, in enumeration order", async () => {
|
|
// Enumeration order 2, 1, 3; a newest-first sort would be 3, 2, 1.
|
|
const lib = new FakeLibrary(
|
|
[collection(2, 200), collection(1, 300), collection(3, 100)],
|
|
[],
|
|
);
|
|
const rows = await freshCollections(lib);
|
|
|
|
expect(lib.freshCollectionsCalls).toBe(1);
|
|
expect(lib.freshCalls).toBe(0);
|
|
expect(rows.map((c) => c.id)).toEqual([2, 1, 3]);
|
|
// The projection's newest-first order is a different sequence, so this
|
|
// is not accidentally that order.
|
|
const newestFirst = [...rows]
|
|
.sort((a, b) => b.updationTime - a.updationTime)
|
|
.map((c) => c.id);
|
|
expect(newestFirst).toEqual([1, 2, 3]);
|
|
expect(rows.map((c) => c.id)).not.toEqual(newestFirst);
|
|
});
|
|
|
|
it("freshFiles with a collection ID reads that collection's files alone and keeps their order and raw fields", async () => {
|
|
// Given in the order 10, 11, 12; creationTimes ascending, so a
|
|
// newest-first sort would reverse them.
|
|
const files = [
|
|
file(10, 1, 1_700_000_000_000_000),
|
|
file(11, 1, 1_700_000_000_000_001),
|
|
file(12, 1, 1_700_000_000_000_002),
|
|
file(20, 2, 1_700_000_000_000_003),
|
|
];
|
|
const lib = new FakeLibrary(
|
|
[collection(1, 100), collection(2, 200)],
|
|
files,
|
|
);
|
|
|
|
const rows = await freshFiles(lib, 1);
|
|
expect(lib.freshCalls).toBe(0);
|
|
expect(lib.freshCollectionsCalls).toBe(1);
|
|
expect(lib.freshFilesCalls).toEqual([1]);
|
|
expect(rows?.map((f) => f.id)).toEqual([10, 11, 12]);
|
|
|
|
// Field values come from raw metadata: microsecond creationTime and the
|
|
// raw title, unchanged.
|
|
expect(rows?.map(fileListRow)).toEqual([
|
|
{
|
|
id: 10,
|
|
title: "file-10.jpg",
|
|
fileType: "image",
|
|
creationTime: 1_700_000_000_000_000,
|
|
collectionID: 1,
|
|
},
|
|
{
|
|
id: 11,
|
|
title: "file-11.jpg",
|
|
fileType: "image",
|
|
creationTime: 1_700_000_000_000_001,
|
|
collectionID: 1,
|
|
},
|
|
{
|
|
id: 12,
|
|
title: "file-12.jpg",
|
|
fileType: "image",
|
|
creationTime: 1_700_000_000_000_002,
|
|
collectionID: 1,
|
|
},
|
|
]);
|
|
});
|
|
|
|
// Without a collection ID, `files` lists every file in the account once
|
|
// (issue #211). File 11 is in collections 1 and 2; collection 2 is
|
|
// enumerated first, so 11 is listed once, with collection 2's record.
|
|
it("freshFiles without a collection ID lists every file once, from the first collection holding it", async () => {
|
|
const files = [
|
|
file(10, 1, 1_700_000_000_000_000),
|
|
file(11, 1, 1_700_000_000_000_001),
|
|
file(20, 2, 1_700_000_000_000_002),
|
|
file(11, 2, 1_700_000_000_000_001),
|
|
];
|
|
const lib = new FakeLibrary(
|
|
[collection(2, 100), collection(1, 200)],
|
|
files,
|
|
);
|
|
|
|
const rows = await freshFiles(lib);
|
|
expect(lib.freshCalls).toBe(1);
|
|
expect(rows?.map((f) => [f.id, f.collectionID])).toEqual([
|
|
[20, 2],
|
|
[11, 2],
|
|
[10, 1],
|
|
]);
|
|
});
|
|
|
|
it("freshFiles returns undefined for an unknown collection", async () => {
|
|
const lib = new FakeLibrary([collection(1, 100)], []);
|
|
const rows = await freshFiles(lib, 999);
|
|
expect(lib.freshCalls).toBe(0);
|
|
expect(lib.freshFilesCalls).toEqual([]);
|
|
expect(rows).toBeUndefined();
|
|
});
|
|
|
|
// Three collections, each holding one file.
|
|
const threeCollections = (): FakeLibrary =>
|
|
new FakeLibrary(
|
|
[collection(1, 100), collection(2, 200), collection(3, 300)],
|
|
[
|
|
file(10, 1, 1_700_000_000_000_000),
|
|
file(20, 2, 1_700_000_000_000_001),
|
|
file(30, 3, 1_700_000_000_000_002),
|
|
],
|
|
);
|
|
|
|
it("freshFile reads each collection's files in the server's order until one holds the file", async () => {
|
|
const lib = threeCollections();
|
|
|
|
const found = await freshFile(lib, 20);
|
|
expect(lib.freshCalls).toBe(0);
|
|
expect(lib.freshCollectionsCalls).toBe(1);
|
|
expect(lib.freshFilesCalls).toEqual([1, 2]);
|
|
expect(found?.metadata.title).toBe("file-20.jpg");
|
|
expect(found?.metadata.creationTime).toBe(1_700_000_000_000_001);
|
|
});
|
|
|
|
// The stand-in's cache holds what the server holds once `fresh()` has run.
|
|
it("freshFile reads first the files of the collection the cache says holds the file", async () => {
|
|
const lib = threeCollections();
|
|
await lib.fresh();
|
|
|
|
const found = await freshFile(lib, 30);
|
|
expect(lib.freshFilesCalls).toEqual([3]);
|
|
expect(found?.collectionID).toBe(3);
|
|
});
|
|
|
|
it("freshFile returns undefined for an unknown file, after reading every collection's files", async () => {
|
|
const lib = threeCollections();
|
|
|
|
const found = await freshFile(lib, 404);
|
|
expect(lib.freshCalls).toBe(0);
|
|
expect(lib.freshFilesCalls).toEqual([1, 2, 3]);
|
|
expect(found).toBeUndefined();
|
|
});
|
|
});
|