338 lines
9.1 KiB
TypeScript
338 lines
9.1 KiB
TypeScript
import { choose } from "../utils/choose";
|
|
import { v4 as uuidv4 } from "uuid";
|
|
import { assert } from "../utils/assert";
|
|
import type { RelativePath, SyncSettings } from "sync-client";
|
|
import { LogLevel } from "sync-client";
|
|
import { MockClient } from "./mock-client";
|
|
import { sleep } from "../utils/sleep";
|
|
import type { LogLine } from "sync-client/dist/types/tracing/logger";
|
|
|
|
export class MockAgent extends MockClient {
|
|
private readonly writtenContents: string[] = [];
|
|
private readonly pendingActions: Promise<unknown>[] = [];
|
|
|
|
// The renamed file finding algorithm isn't too smart so we can't both update and rename the same file
|
|
private doNotTouchWhileOffline: string[] = [];
|
|
|
|
public constructor(
|
|
initialSettings: Partial<SyncSettings>,
|
|
public readonly name: string,
|
|
private readonly doDeletes: boolean,
|
|
useSlowFileEvents: boolean,
|
|
private readonly jitterScaleInSeconds: number
|
|
) {
|
|
super(initialSettings, useSlowFileEvents);
|
|
}
|
|
|
|
public async init(): Promise<void> {
|
|
await super.init(
|
|
// flaky fetch implementation to use during testing
|
|
async (
|
|
input: string | URL | globalThis.Request,
|
|
init?: RequestInit
|
|
): Promise<Response> => {
|
|
await sleep(Math.random() * this.jitterScaleInSeconds * 1000);
|
|
const response = await fetch(input, init);
|
|
await sleep(Math.random() * this.jitterScaleInSeconds * 1000);
|
|
return response;
|
|
}
|
|
);
|
|
|
|
assert(
|
|
(await this.client.checkConnection()).isSuccessful,
|
|
"Connection check failed"
|
|
);
|
|
|
|
this.client.logger.addOnMessageListener((logLine: LogLine) => {
|
|
const state = this.client.getSettings().isSyncEnabled
|
|
? "(online) "
|
|
: "(offline)";
|
|
const formatted = `[${this.name} ${state}] ${logLine.timestamp.toISOString()} ${logLine.level} ${logLine.message}`;
|
|
|
|
// HACK: we have to ensure the file has been synced if we want to change it offline without data loss
|
|
const historyEntry = /.*History entry: (.*.md).*/.exec(
|
|
logLine.message
|
|
);
|
|
|
|
if (historyEntry) {
|
|
this.doNotTouchWhileOffline =
|
|
this.doNotTouchWhileOffline.filter(
|
|
(file) => file !== historyEntry[1]
|
|
);
|
|
}
|
|
switch (logLine.level) {
|
|
case LogLevel.ERROR:
|
|
console.error(formatted);
|
|
|
|
if (!this.useSlowFileEvents) {
|
|
// Let's not ignore errors
|
|
// eslint-disable-next-line @typescript-eslint/no-floating-promises
|
|
sleep(100).then(() => process.exit(1));
|
|
}
|
|
|
|
break;
|
|
case LogLevel.WARNING:
|
|
console.warn(formatted);
|
|
break;
|
|
case LogLevel.INFO:
|
|
console.info(formatted);
|
|
break;
|
|
case LogLevel.DEBUG:
|
|
console.debug(formatted);
|
|
break;
|
|
}
|
|
});
|
|
|
|
this.client.logger.info("Agent initialized");
|
|
}
|
|
|
|
public async act(): Promise<void> {
|
|
const options: (() => Promise<unknown>)[] = [
|
|
this.createFileAction.bind(this)
|
|
];
|
|
|
|
if (this.client.getSettings().isSyncEnabled) {
|
|
if (this.doNotTouchWhileOffline.length === 0) {
|
|
options.push(this.disableSyncAction.bind(this));
|
|
}
|
|
} else {
|
|
options.push(this.enableSyncAction.bind(this));
|
|
}
|
|
|
|
const files = await this.listAllFiles();
|
|
|
|
if (files.length > 0) {
|
|
options.push(
|
|
this.renameFileAction.bind(this, files),
|
|
this.updateFileAction.bind(this, files)
|
|
);
|
|
|
|
if (this.doDeletes) {
|
|
options.push(this.deleteFileAction.bind(this, files));
|
|
}
|
|
}
|
|
|
|
this.pendingActions.push(
|
|
(async (): Promise<unknown> => {
|
|
try {
|
|
return await choose(options)();
|
|
} catch (error) {
|
|
this.client.logger.error(
|
|
`Failed to perform an action: ${error}`
|
|
);
|
|
this.client.logger.info(JSON.stringify(this.data, null, 2));
|
|
this.client.logger.info(
|
|
JSON.stringify(this.localFiles, null, 2)
|
|
);
|
|
throw error;
|
|
}
|
|
})()
|
|
);
|
|
}
|
|
|
|
public async finish(): Promise<void> {
|
|
await this.client.setSetting("isSyncEnabled", true);
|
|
await Promise.all(this.pendingActions);
|
|
await this.client.waitAndStop();
|
|
}
|
|
|
|
public assertFileSystemsAreConsistent(otherAgent: MockAgent): void {
|
|
const globalFiles = Array.from(otherAgent.localFiles.keys());
|
|
const localFiles = Array.from(this.localFiles.keys());
|
|
|
|
const missingInOther = localFiles.filter(
|
|
(file) => !otherAgent.localFiles.has(file)
|
|
);
|
|
const missingInLocal = globalFiles.filter(
|
|
(file) => !this.localFiles.has(file)
|
|
);
|
|
|
|
try {
|
|
assert(
|
|
missingInOther.length === 0,
|
|
`Files from ${this.name} missing in ${otherAgent.name}: ${missingInOther.join(", ")}`
|
|
);
|
|
assert(
|
|
missingInLocal.length === 0,
|
|
`Files from ${otherAgent.name} missing in ${this.name}: ${missingInLocal.join(", ")}`
|
|
);
|
|
|
|
for (const file of globalFiles) {
|
|
const localContent = new TextDecoder().decode(
|
|
this.localFiles.get(file)
|
|
);
|
|
const otherContent = new TextDecoder().decode(
|
|
otherAgent.localFiles.get(file)
|
|
);
|
|
assert(
|
|
localContent === otherContent,
|
|
`Content mismatch for file ${file}:\n${localContent}\n${otherContent}`
|
|
);
|
|
}
|
|
} catch (e) {
|
|
this.client.logger.info(
|
|
"Local data: " + JSON.stringify(this.data, null, 2)
|
|
);
|
|
this.client.logger.info(
|
|
"Local files: " +
|
|
Array.from(otherAgent.localFiles.keys()).join(", ")
|
|
);
|
|
otherAgent.client.logger.info(
|
|
"Local data: " + JSON.stringify(otherAgent.data, null, 2)
|
|
);
|
|
otherAgent.client.logger.info(
|
|
"Local files: " +
|
|
Array.from(otherAgent.localFiles.keys()).join(", ")
|
|
);
|
|
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
public assertAllContentIsPresentOnce(): void {
|
|
if (this.useSlowFileEvents) {
|
|
this.client.logger.info(
|
|
// We can't ensure that we have seen every single update
|
|
`Skipping content check for ${this.name} because slow file events are enabled`
|
|
);
|
|
return;
|
|
}
|
|
|
|
for (const content of this.writtenContents) {
|
|
const found = Array.from(this.localFiles.keys()).filter((key) => {
|
|
return new TextDecoder()
|
|
.decode(this.localFiles.get(key))
|
|
.includes(content);
|
|
});
|
|
|
|
if (this.doDeletes) {
|
|
assert(
|
|
found.length <= 1,
|
|
`[${this.name}] Content ${content} found in ${found.join(", ")}`
|
|
);
|
|
} else {
|
|
assert(
|
|
found.length >= 1,
|
|
`[${this.name}] Content ${content} not found in any files`
|
|
);
|
|
|
|
assert(
|
|
found.length <= 1,
|
|
`[${this.name}] Content ${content} found in multiple files: ${found.join(", ")}`
|
|
);
|
|
|
|
const [file] = found;
|
|
const fileContent = new TextDecoder().decode(
|
|
this.localFiles.get(file)
|
|
);
|
|
assert(
|
|
fileContent.split(content).length == 2,
|
|
`Content ${content} (of ${this.name}) found more than once in '${file}'. File content:\n${fileContent}`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async createFileAction(): Promise<void> {
|
|
const file = this.getFileName();
|
|
|
|
if (
|
|
(!this.client.getSettings().isSyncEnabled &&
|
|
this.doNotTouchWhileOffline.includes(file)) ||
|
|
(await this.exists(file))
|
|
) {
|
|
return;
|
|
}
|
|
|
|
const content = this.getContent();
|
|
this.client.logger.info(
|
|
`Decided to create file ${file} with content ${content}`
|
|
);
|
|
|
|
return this.create(file, new TextEncoder().encode(` ${content} `));
|
|
}
|
|
|
|
private async disableSyncAction(): Promise<void> {
|
|
this.client.logger.info(`Decided to disable sync`);
|
|
await this.client.setSetting("isSyncEnabled", false);
|
|
}
|
|
|
|
private async enableSyncAction(): Promise<void> {
|
|
this.client.logger.info(`Decided to enable sync`);
|
|
await this.client.setSetting("isSyncEnabled", true);
|
|
}
|
|
|
|
private async renameFileAction(files: RelativePath[]): Promise<void> {
|
|
const file = choose(files);
|
|
|
|
// We can't edit files offline that have been updated while offline.
|
|
// Otherwise, the resolution logic couldn't handle it.
|
|
if (
|
|
!this.client.getSettings().isSyncEnabled &&
|
|
this.doNotTouchWhileOffline.includes(file)
|
|
) {
|
|
this.client.logger.info(
|
|
`Skipping file ${file} because it has been updated while offline`
|
|
);
|
|
return;
|
|
}
|
|
|
|
const newName = this.getFileName();
|
|
|
|
if (
|
|
(!this.client.getSettings().isSyncEnabled &&
|
|
this.doNotTouchWhileOffline.includes(newName)) ||
|
|
(await this.exists(newName))
|
|
) {
|
|
return;
|
|
}
|
|
|
|
this.client.logger.info(`Decided to rename file ${file} to ${newName}`);
|
|
this.doNotTouchWhileOffline.push(file, newName);
|
|
|
|
return this.rename(file, newName);
|
|
}
|
|
|
|
private async updateFileAction(files: RelativePath[]): Promise<void> {
|
|
const file = choose(files);
|
|
|
|
// We can't edit files offline that have been updated while offline.
|
|
// Otherwise, the resolution logic couldn't handle it.
|
|
if (
|
|
!this.client.getSettings().isSyncEnabled &&
|
|
this.doNotTouchWhileOffline.includes(file)
|
|
) {
|
|
this.client.logger.info(
|
|
`Skipping file ${file} because it has been updated while offline`
|
|
);
|
|
return;
|
|
}
|
|
|
|
const content = this.getContent();
|
|
this.client.logger.info(
|
|
`Decided to update file ${file} with ${content}`
|
|
);
|
|
this.doNotTouchWhileOffline.push(file);
|
|
await this.atomicUpdateText(file, (old) => ({
|
|
text: old.text + ` ${content} `,
|
|
cursors: []
|
|
}));
|
|
}
|
|
|
|
private async deleteFileAction(files: RelativePath[]): Promise<void> {
|
|
const file = choose(files);
|
|
this.client.logger.info(`Decided to delete file ${file}`);
|
|
return this.delete(file);
|
|
}
|
|
|
|
private getContent(): string {
|
|
const uuid = uuidv4();
|
|
this.writtenContents.push(uuid);
|
|
return uuid;
|
|
}
|
|
|
|
private getFileName(): string {
|
|
// Simulate name collisions between the clients
|
|
return `file-${Math.floor(Math.random() * 64)}.md`;
|
|
}
|
|
}
|