Skip to content

A local-first personal finance app

55.2 KB
Raw Blame
// @ts-strict-ignore
import crypto from 'node:crypto';
import fs from 'node:fs';
import fsPromises from 'node:fs/promises';

import {
  create,
  MessageEnvelopeSchema,
  SyncRequestSchema,
  toBinary,
} from '@actual-app/crdt';
import request from 'supertest';

import { getAccountDb } from './account-db';
import { handlers as app } from './app-sync';
import { getPathForUserFile, isValidFileId } from './util/paths';

const ADMIN_ROLE = 'ADMIN';
const OTHER_USER_ID = 'otherUser';

const createUser = (userId, userName, role, owner = 0, enabled = 1) => {
  getAccountDb().mutate(
    'INSERT INTO users (id, user_name, display_name, enabled, owner, role) VALUES (?, ?, ?, ?, ?, ?)',
    [userId, userName, `${userName} display`, enabled, owner, role],
  );
};

const deleteUser = (userId: string) => {
  getAccountDb().mutate('DELETE FROM users WHERE id = ?', [userId]);
};

function generateFileId() {
  const id = crypto.randomBytes(16).toString('hex');
  if (!isValidFileId(id)) {
    throw new Error('Generated fileId is invalid');
  }
  return id;
}

describe('/user-get-key', () => {
  it('returns 401 if the user is not authenticated', async () => {
    const res = await request(app).post('/user-get-key');

    expect(res.statusCode).toEqual(401);
    expect(res.body).toEqual({
      details: 'token-not-found',
      reason: 'unauthorized',
      status: 'error',
    });
  });

  it('returns encryption key details for a given fileId', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const encrypt_salt = 'test-salt';
    const encrypt_keyid = 'test-key-id';
    const encrypt_test = 'test-encrypt-test';

    getAccountDb().mutate(
      'INSERT INTO files (id, encrypt_salt, encrypt_keyid, encrypt_test, owner) VALUES (?, ?, ?, ?, ?)',
      [fileId, encrypt_salt, encrypt_keyid, encrypt_test, 'genericAdmin'],
    );

    const res = await request(app)
      .post('/user-get-key')
      .set('x-actual-token', 'valid-token')
      .send({ fileId });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({
      status: 'ok',
      data: {
        id: encrypt_keyid,
        salt: encrypt_salt,
        test: encrypt_test,
      },
    });
  });

  it('returns 400 if the file is not found', async () => {
    const res = await request(app)
      .post('/user-get-key')
      .set('x-actual-token', 'valid-token')
      .send({ fileId: 'non-existent-file-id' });

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('file-not-found');
  });

  it('returns 400 for invalid fileId format', async () => {
    const res = await request(app)
      .post('/user-get-key')
      .set('x-actual-token', 'valid-token')
      .send({ fileId: 'budget@2026' });

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('invalid fileId');
  });

  it('returns 403 when non-owner gets encryption key', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    getAccountDb().mutate(
      'INSERT INTO files (id, encrypt_salt, encrypt_keyid, encrypt_test, owner) VALUES (?, ?, ?, ?, ?)',
      [fileId, 'salt', 'key-id', 'test', OTHER_USER_ID],
    );

    const res = await request(app)
      .post('/user-get-key')
      .set('x-actual-token', 'valid-token-user')
      .send({ fileId });

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');
  });

  it("allows an admin to get encryption key for another user's file", async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const encrypt_salt = 'salt';
    const encrypt_keyid = 'key-id';
    const encrypt_test = 'test';
    getAccountDb().mutate(
      'INSERT INTO files (id, encrypt_salt, encrypt_keyid, encrypt_test, owner) VALUES (?, ?, ?, ?, ?)',
      [fileId, encrypt_salt, encrypt_keyid, encrypt_test, OTHER_USER_ID],
    );

    const res = await request(app)
      .post('/user-get-key')
      .set('x-actual-token', 'valid-token-admin')
      .send({ fileId });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({
      status: 'ok',
      data: {
        id: encrypt_keyid,
        salt: encrypt_salt,
        test: encrypt_test,
      },
    });
  });
});

describe('/user-create-key', () => {
  it('returns 401 if the user is not authenticated', async () => {
    const res = await request(app).post('/user-create-key');

    expect(res.statusCode).toEqual(401);
    expect(res.body).toEqual({
      details: 'token-not-found',
      reason: 'unauthorized',
      status: 'error',
    });
  });

  it('returns 400 if the file is not found', async () => {
    const res = await request(app)
      .post('/user-create-key')
      .set('x-actual-token', 'valid-token')
      .send({ fileId: 'non-existent-file-id' });

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('file-not-found');
  });

  it('returns 400 for invalid fileId format', async () => {
    const res = await request(app)
      .post('/user-create-key')
      .set('x-actual-token', 'valid-token')
      .send({ fileId: 'budget@2026' });

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('invalid fileId');
  });

  it('returns 403 when non-owner creates encryption key', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    getAccountDb().mutate(
      'INSERT INTO files (id, encrypt_salt, encrypt_keyid, encrypt_test, owner) VALUES (?, ?, ?, ?, ?)',
      [fileId, 'old-salt', 'old-key', 'old-test', OTHER_USER_ID],
    );

    const res = await request(app)
      .post('/user-create-key')
      .set('x-actual-token', 'valid-token-user')
      .send({
        fileId,
        keyId: 'new-key',
        keySalt: 'new-salt',
        testContent: 'new-test',
      });

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');
  });

  it("allows an admin to create encryption key for another user's file", async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const old_encrypt_salt = 'old-salt';
    const old_encrypt_keyid = 'old-key';
    const old_encrypt_test = 'old-test';
    const encrypt_salt = 'new-salt';
    const encrypt_keyid = 'new-key-id';
    const encrypt_test = 'new-encrypt-test';
    getAccountDb().mutate(
      'INSERT INTO files (id, encrypt_salt, encrypt_keyid, encrypt_test, owner) VALUES (?, ?, ?, ?, ?)',
      [
        fileId,
        old_encrypt_salt,
        old_encrypt_keyid,
        old_encrypt_test,
        OTHER_USER_ID,
      ],
    );

    const res = await request(app)
      .post('/user-create-key')
      .set('x-actual-token', 'valid-token-admin')
      .send({
        fileId,
        keyId: encrypt_keyid,
        keySalt: encrypt_salt,
        testContent: encrypt_test,
      });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok' });

    const rows = getAccountDb().all(
      'SELECT encrypt_salt, encrypt_keyid, encrypt_test FROM files WHERE id = ?',
      [fileId],
    );
    expect(rows[0].encrypt_salt).toEqual(encrypt_salt);
    expect(rows[0].encrypt_keyid).toEqual(encrypt_keyid);
    expect(rows[0].encrypt_test).toEqual(encrypt_test);
  });

  it('returns 403 when a shared user (user_access only) tries to create a key on a file owned by someone else', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    getAccountDb().mutate(
      'INSERT INTO files (id, encrypt_salt, encrypt_keyid, encrypt_test, owner) VALUES (?, ?, ?, ?, ?)',
      [fileId, 'old-salt', 'old-key', 'old-test', OTHER_USER_ID],
    );
    getAccountDb().mutate(
      'INSERT INTO user_access (file_id, user_id) VALUES (?, ?)',
      [fileId, 'genericUser'],
    );

    const res = await request(app)
      .post('/user-create-key')
      .set('x-actual-token', 'valid-token-user')
      .send({
        fileId,
        keyId: 'attacker-key',
        keySalt: 'attacker-salt',
        testContent: 'attacker-test',
      });

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');

    const rows = getAccountDb().all(
      'SELECT encrypt_salt, encrypt_keyid, encrypt_test FROM files WHERE id = ?',
      [fileId],
    );
    expect(rows[0].encrypt_salt).toEqual('old-salt');
    expect(rows[0].encrypt_keyid).toEqual('old-key');
    expect(rows[0].encrypt_test).toEqual('old-test');
  });

  it('creates a new encryption key for the file', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');

    const old_encrypt_salt = 'old-salt';
    const old_encrypt_keyid = 'old-key';
    const old_encrypt_test = 'old-encrypt-test';
    const encrypt_salt = 'test-salt';
    const encrypt_keyid = 'test-key-id';
    const encrypt_test = 'test-encrypt-test';

    getAccountDb().mutate(
      'INSERT INTO files (id, encrypt_salt, encrypt_keyid, encrypt_test) VALUES (?, ?, ?, ?)',
      [fileId, old_encrypt_salt, old_encrypt_keyid, old_encrypt_test],
    );

    const res = await request(app)
      .post('/user-create-key')
      .set('x-actual-token', 'valid-token')
      .send({
        fileId,
        keyId: encrypt_keyid,
        keySalt: encrypt_salt,
        testContent: encrypt_test,
      });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok' });

    const rows = getAccountDb().all(
      'SELECT encrypt_salt, encrypt_keyid, encrypt_test FROM files WHERE id = ?',
      [fileId],
    );

    expect(rows[0].encrypt_salt).toEqual(encrypt_salt);
    expect(rows[0].encrypt_keyid).toEqual(encrypt_keyid);
    expect(rows[0].encrypt_test).toEqual(encrypt_test);
  });
});

describe('/reset-user-file', () => {
  it('returns 401 if the user is not authenticated', async () => {
    const res = await request(app).post('/reset-user-file');

    expect(res.statusCode).toEqual(401);
    expect(res.body).toEqual({
      details: 'token-not-found',
      reason: 'unauthorized',
      status: 'error',
    });
  });

  it('resets the user file and deletes the group file', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'test-group-id';

    // Use addMockFile to insert a mock file into the database
    getAccountDb().mutate(
      'INSERT INTO files (id, group_id, deleted, owner) VALUES (?, ?, FALSE, ?)',
      [fileId, groupId, 'genericAdmin'],
    );

    getAccountDb().mutate(
      'INSERT INTO user_access (file_id, user_id) VALUES (?, ?)',
      [fileId, 'genericAdmin'],
    );

    const res = await request(app)
      .post('/reset-user-file')
      .set('x-actual-token', 'valid-token')
      .send({ fileId });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok' });

    // Verify that the file is marked as deleted
    const rows = getAccountDb().all('SELECT group_id FROM files WHERE id = ?', [
      fileId,
    ]);

    expect(rows[0].group_id).toBeNull();
  });

  it('returns 400 if the file is not found', async () => {
    const res = await request(app)
      .post('/reset-user-file')
      .set('x-actual-token', 'valid-token')
      .send({ fileId: 'non-existent-file-id' });

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('User or file not found');
  });

  it('returns 400 for invalid fileId format', async () => {
    const res = await request(app)
      .post('/reset-user-file')
      .set('x-actual-token', 'valid-token')
      .send({ fileId: 'budget@2026' });

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('invalid fileId');
  });

  it('returns 403 when non-owner resets another user file', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    getAccountDb().mutate(
      'INSERT OR IGNORE INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
      [fileId, OTHER_USER_ID],
    );

    const res = await request(app)
      .post('/reset-user-file')
      .set('x-actual-token', 'valid-token-user')
      .send({ fileId });

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');
  });

  it("allows an admin to reset another user's file", async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'admin-reset-group-id';
    getAccountDb().mutate(
      'INSERT INTO files (id, group_id, deleted, owner) VALUES (?, ?, FALSE, ?)',
      [fileId, groupId, OTHER_USER_ID],
    );

    const res = await request(app)
      .post('/reset-user-file')
      .set('x-actual-token', 'valid-token-admin')
      .send({ fileId });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok' });

    const rows = getAccountDb().all('SELECT group_id FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rows[0].group_id).toBeNull();
  });

  it('returns 403 when a shared user (user_access only) tries to reset a file owned by someone else', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'shared-user-reset-group-id';
    getAccountDb().mutate(
      'INSERT INTO files (id, group_id, deleted, owner) VALUES (?, ?, FALSE, ?)',
      [fileId, groupId, OTHER_USER_ID],
    );
    getAccountDb().mutate(
      'INSERT INTO user_access (file_id, user_id) VALUES (?, ?)',
      [fileId, 'genericUser'],
    );

    const res = await request(app)
      .post('/reset-user-file')
      .set('x-actual-token', 'valid-token-user')
      .send({ fileId });

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');

    const rows = getAccountDb().all('SELECT group_id FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rows[0].group_id).toEqual(groupId);
  });
});

describe('/upload-user-file', () => {
  it('returns 401 if the user is not authenticated', async () => {
    const res = await request(app).post('/upload-user-file');

    expect(res.statusCode).toEqual(401);
    expect(res.body).toEqual({
      details: 'token-not-found',
      reason: 'unauthorized',
      status: 'error',
    });
  });

  it('returns 400 if x-actual-name header is missing', async () => {
    const res = await request(app)
      .post('/upload-user-file')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-file-id', 'test-file-id')
      .send('file content');

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('single x-actual-name is required');
  });

  it('returns 400 if fileId is missing', async () => {
    const content = Buffer.from('file content');
    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-name', 'test-file')
      .send(content);

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('fileId is required');
  });

  it('returns 400 for invalid fileId format', async () => {
    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-name', 'test-file')
      .set('x-actual-file-id', 'budget@2026')
      .send(Buffer.from('file content'));

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('invalid fileId');
  });

  it('returns 400 for an empty x-actual-group-id header', async () => {
    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-name', 'test-file')
      .set('x-actual-file-id', generateFileId())
      .set('x-actual-group-id', '')
      .send(Buffer.from('file content'));

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('invalid groupId');
  });

  it('returns 400 for an invalid x-actual-group-id header', async () => {
    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-name', 'test-file')
      .set('x-actual-file-id', generateFileId())
      .set('x-actual-group-id', 'group@2026')
      .send(Buffer.from('file content'));

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('invalid groupId');
  });

  it('uploads a new file successfully', async () => {
    const fileId = generateFileId();
    const fileName = 'test-file.txt';
    const fileContent = 'test file content';
    const fileContentBuffer = Buffer.from(fileContent);
    const syncVersion = 2;
    const encryptMeta = JSON.stringify({ keyId: 'key-id' });
    onTestFinished(() => {
      try {
        fs.unlinkSync(getPathForUserFile(fileId));
      } catch {}
    });

    // Verify that the file does not exist before upload
    const rowsBefore = getAccountDb().all('SELECT * FROM files WHERE id = ?', [
      fileId,
    ]);

    expect(rowsBefore.length).toBe(0);

    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-name', fileName)
      .set('x-actual-file-id', fileId)
      .set('x-actual-format', syncVersion.toString())
      .set('x-actual-encrypt-meta', encryptMeta)
      .send(fileContentBuffer);

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok', groupId: expect.any(String) });

    const receivedGroupid = res.body.groupId;
    // Verify that the file exists in the accountDb
    const rowsAfter = getAccountDb().all('SELECT * FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rowsAfter.length).toBe(1);
    expect(rowsAfter[0].id).toEqual(fileId);
    expect(rowsAfter[0].group_id).toEqual(receivedGroupid);
    expect(rowsAfter[0].sync_version).toEqual(syncVersion);
    expect(rowsAfter[0].name).toEqual(fileName);
    expect(rowsAfter[0].encrypt_meta).toEqual(encryptMeta);

    // Verify that the file was written to the file system
    const filePath = getPathForUserFile(fileId);
    const writtenContent = await fs.promises.readFile(filePath, 'utf8');
    expect(writtenContent).toEqual(fileContent);
  });

  it('uploads and updates an existing file successfully', async () => {
    const fileId = generateFileId();
    const oldGroupId = null; //sync state was reset
    const oldFileName = 'old-test-file.txt';
    const newFileName = 'new-test-file.txt';
    const oldFileContent = 'old file content';
    const newFileContent = 'new file content';
    const oldSyncVersion = 1;
    const newSyncVersion = 2;
    const oldKeyId = 'old-key-id';
    const oldEncryptMeta = JSON.stringify({ keyId: oldKeyId });
    const newEncryptMeta = JSON.stringify({
      keyId: oldKeyId,
      sentinelValue: 1,
    }); //keep the same key, but change other things
    onTestFinished(() => {
      try {
        fs.unlinkSync(getPathForUserFile(fileId));
      } catch {}
    });

    // Create the old file version
    getAccountDb().mutate(
      'INSERT INTO files (id, group_id, sync_version, name, encrypt_meta, encrypt_keyid) VALUES (?, ?, ?, ?, ?, ?)',
      [
        fileId,
        oldGroupId,
        oldSyncVersion,
        oldFileName,
        oldEncryptMeta,
        oldKeyId,
      ],
    );

    fs.writeFileSync(getPathForUserFile(fileId), oldFileContent);

    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-file-id', fileId)
      .set('x-actual-name', newFileName)
      .set('x-actual-format', newSyncVersion.toString())
      .set('x-actual-encrypt-meta', newEncryptMeta)
      .send(Buffer.from(newFileContent));

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok', groupId: expect.any(String) });

    const receivedGroupid = res.body.groupId;

    // Verify that the file was updated in the accountDb
    const rowsAfter = getAccountDb().all('SELECT * FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rowsAfter.length).toBe(1);
    expect(rowsAfter[0].id).toEqual(fileId);
    expect(rowsAfter[0].group_id).toEqual(receivedGroupid);
    expect(rowsAfter[0].sync_version).toEqual(newSyncVersion);
    expect(rowsAfter[0].name).toEqual(newFileName);
    expect(rowsAfter[0].encrypt_meta).toEqual(newEncryptMeta);

    // Verify that the file was written to the file system
    const filePath = getPathForUserFile(fileId);
    const writtenContent = await fs.promises.readFile(filePath, 'utf8');
    expect(writtenContent).toEqual(newFileContent);
  });

  it('returns 400 if the file is part of an old group', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'old-group-id';
    const fileName = 'test-file.txt';
    const keyId = 'key-id';
    const syncVersion = 2;

    // Add a mock file with the old group ID
    addMockFile(
      fileId,
      'current-group-id',
      keyId,
      JSON.stringify({ keyId }),
      syncVersion,
    );

    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-file-id', fileId)
      .set('x-actual-group-id', groupId)
      .set('x-actual-name', fileName);

    expect(res.statusCode).toEqual(400);
    expect(res.text).toEqual('file-has-reset');
  });

  it('returns 400 if the file has a new encryption key', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'group-id';
    const fileName = 'test-file.txt';
    const oldKeyId = 'old-key-id';
    const newKeyId = 'new-key-id';
    const syncVersion = 2;

    // Add a mock file with the new key
    addMockFile(
      fileId,
      groupId,
      newKeyId,
      JSON.stringify({ newKeyId }),
      syncVersion,
    );

    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-file-id', fileId)
      .set('x-actual-group-id', groupId)
      .set('x-actual-name', fileName)
      .set('x-actual-encrypt-meta', JSON.stringify({ keyId: oldKeyId }));

    expect(res.statusCode).toEqual(400);
    expect(res.text).toEqual('file-has-new-key');
  });

  it('returns 403 when non-owner overwrites another user file', async () => {
    const fileId = generateFileId();
    const groupId = 'group-id';
    const keyId = 'key-id';
    const syncVersion = 2;
    fs.writeFileSync(getPathForUserFile(fileId), 'existing content');
    getAccountDb().mutate(
      'INSERT INTO files (id, group_id, sync_version, name, encrypt_meta, encrypt_keyid, deleted, owner) VALUES (?, ?, ?, ?, ?, ?, 0, ?)',
      [
        fileId,
        groupId,
        syncVersion,
        'existing.txt',
        JSON.stringify({ keyId }),
        keyId,
        OTHER_USER_ID,
      ],
    );
    onTestFinished(() => {
      try {
        fs.unlinkSync(getPathForUserFile(fileId));
      } catch {}
    });

    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token-user')
      .set('x-actual-file-id', fileId)
      .set('x-actual-name', 'hacked.txt')
      .set('x-actual-group-id', groupId)
      .set('x-actual-format', syncVersion.toString())
      .set('x-actual-encrypt-meta', JSON.stringify({ keyId }))
      .send(Buffer.from('overwrite content'));

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');
  });

  it("allows an admin to overwrite another user's file", async () => {
    const fileId = generateFileId();
    const groupId = 'admin-upload-group-id';
    const keyId = 'key-id';
    const syncVersion = 2;
    const existingContent = 'existing content';
    const newContent = 'admin overwrite content';
    fs.writeFileSync(getPathForUserFile(fileId), existingContent);
    getAccountDb().mutate(
      'INSERT INTO files (id, group_id, sync_version, name, encrypt_meta, encrypt_keyid, deleted, owner) VALUES (?, ?, ?, ?, ?, ?, 0, ?)',
      [
        fileId,
        groupId,
        syncVersion,
        'existing.txt',
        JSON.stringify({ keyId }),
        keyId,
        OTHER_USER_ID,
      ],
    );
    onTestFinished(() => {
      try {
        fs.unlinkSync(getPathForUserFile(fileId));
      } catch {}
    });

    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token-admin')
      .set('x-actual-file-id', fileId)
      .set('x-actual-name', 'admin-renamed.txt')
      .set('x-actual-group-id', groupId)
      .set('x-actual-format', syncVersion.toString())
      .set('x-actual-encrypt-meta', JSON.stringify({ keyId }))
      .send(Buffer.from(newContent));

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok', groupId });

    expect(fs.readFileSync(getPathForUserFile(fileId), 'utf8')).toEqual(
      newContent,
    );
    const rows = getAccountDb().all('SELECT name FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rows[0].name).toEqual('admin-renamed.txt');
  });

  it('returns 500 and keeps the existing file when the write fails', async () => {
    const fileId = generateFileId();
    const groupId = 'write-failure-group-id';
    const keyId = 'key-id';
    const syncVersion = 2;
    const encryptMeta = JSON.stringify({ keyId });
    const originalContent = 'original good content';
    const filePath = getPathForUserFile(fileId);

    getAccountDb().mutate(
      'INSERT INTO files (id, group_id, sync_version, name, encrypt_meta, encrypt_keyid) VALUES (?, ?, ?, ?, ?, ?)',
      [fileId, groupId, syncVersion, 'failing.txt', encryptMeta, keyId],
    );
    fs.writeFileSync(filePath, originalContent);
    onTestFinished(() => {
      try {
        fs.unlinkSync(filePath);
      } catch {}
    });

    // Some bytes land on disk before the write rejects.
    const writeFileSpy = vi
      .spyOn(fsPromises, 'writeFile')
      .mockImplementationOnce(async path => {
        fs.writeFileSync(path as fs.PathLike, 'PARTIAL-GARBAGE');
        throw new Error('simulated disk failure');
      });
    onTestFinished(() => writeFileSpy.mockRestore());

    const res = await request(app)
      .post('/upload-user-file')
      .set('Content-Type', 'application/encrypted-file')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-name', 'failing.txt')
      .set('x-actual-file-id', fileId)
      .set('x-actual-group-id', groupId)
      .set('x-actual-format', syncVersion.toString())
      .set('x-actual-encrypt-meta', encryptMeta)
      .send(Buffer.from('new content that should not land'));

    expect(res.statusCode).toEqual(500);
    expect(fs.readFileSync(filePath, 'utf8')).toEqual(originalContent);
  });
});

describe('/download-user-file', () => {
  describe('default version', () => {
    it('returns 401 if the user is not authenticated', async () => {
      const res = await request(app).get('/download-user-file');

      expect(res.statusCode).toEqual(401);
      expect(res.body).toEqual({
        details: 'token-not-found',
        reason: 'unauthorized',
        status: 'error',
      });
    });

    it('returns 401 if the user is invalid', async () => {
      const res = await request(app)
        .get('/download-user-file')
        .set('x-actual-token', 'invalid-token');

      expect(res.statusCode).toEqual(401);
      expect(res.body).toEqual({
        details: 'token-not-found',
        reason: 'unauthorized',
        status: 'error',
      });
    });

    it('returns 400 error if the file does not exist in the database', async () => {
      const res = await request(app)
        .get('/download-user-file')
        .set('x-actual-token', 'valid-token')
        .set('x-actual-file-id', 'non-existing-file-id');

      expect(res.statusCode).toEqual(400);
      expect(res.text).toBe('User or file not found');
    });

    it('returns 400 for invalid fileId format', async () => {
      const res = await request(app)
        .get('/download-user-file')
        .set('x-actual-token', 'valid-token')
        .set('x-actual-file-id', 'budget@2026');

      expect(res.statusCode).toEqual(400);
      expect(res.text).toBe('invalid fileId');
    });

    it('returns 500 error if the file does not exist on the filesystem', async () => {
      getAccountDb().mutate(
        'INSERT INTO files (id, deleted) VALUES (?, FALSE)',
        ['missing-fs-file'],
      );

      const res = await request(app)
        .get('/download-user-file')
        .set('x-actual-token', 'valid-token')
        .set('x-actual-file-id', 'missing-fs-file');

      expect(res.statusCode).toEqual(404);
    });

    it('returns an attachment file', async () => {
      const fileId = generateFileId();
      const fileContent = 'content';
      fs.writeFileSync(getPathForUserFile(fileId), fileContent);
      getAccountDb().mutate(
        'INSERT INTO files (id, deleted) VALUES (?, FALSE)',
        [fileId],
      );

      const res = await request(app)
        .get('/download-user-file')
        .set('x-actual-token', 'valid-token')
        .set('x-actual-file-id', fileId);

      expect(res.statusCode).toEqual(200);
      expect(res.headers).toEqual(
        expect.objectContaining({
          'content-disposition': `attachment;filename=${fileId}`,
          'content-type': 'application/octet-stream',
        }),
      );

      expect(res.body).toBeInstanceOf(Buffer);
      expect(res.body.toString('utf8')).toEqual(fileContent);
    });

    describe('access control', () => {
      it('returns 403 when non-owner downloads another user file', async () => {
        const fileId = generateFileId();
        const fileContent = 'sensitive content';
        fs.writeFileSync(getPathForUserFile(fileId), fileContent);
        getAccountDb().mutate(
          'INSERT INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
          [fileId, OTHER_USER_ID],
        );
        onTestFinished(() => {
          try {
            fs.unlinkSync(getPathForUserFile(fileId));
          } catch {}
        });

        const res = await request(app)
          .get('/download-user-file')
          .set('x-actual-token', 'valid-token-user')
          .set('x-actual-file-id', fileId);

        expect(res.statusCode).toEqual(403);
        expect(res.text).toEqual('file-access-not-allowed');
      });

      it("allows an admin to download another user's file", async () => {
        const fileId = generateFileId();
        const fileContent = 'admin-downloaded content';
        fs.writeFileSync(getPathForUserFile(fileId), fileContent);
        getAccountDb().mutate(
          'INSERT INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
          [fileId, OTHER_USER_ID],
        );
        onTestFinished(() => {
          try {
            fs.unlinkSync(getPathForUserFile(fileId));
          } catch {}
        });

        const res = await request(app)
          .get('/download-user-file')
          .set('x-actual-token', 'valid-token-admin')
          .set('x-actual-file-id', fileId);

        expect(res.statusCode).toEqual(200);
        expect(res.body).toBeInstanceOf(Buffer);
        expect(res.body.toString('utf8')).toEqual(fileContent);
      });

      it('allows non-owner with user_access to download via requireFileAccess (UserService.countUserAccess > 0)', async () => {
        // File owned by another user; access granted only via user_access row, not owner/admin.
        // This exercises the requireFileAccess branch that uses UserService.countUserAccess.
        const fileId = generateFileId();
        const fileContent = 'shared-user content';
        fs.writeFileSync(getPathForUserFile(fileId), fileContent);
        getAccountDb().mutate(
          'INSERT INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
          [fileId, OTHER_USER_ID],
        );
        getAccountDb().mutate(
          'INSERT INTO user_access (file_id, user_id) VALUES (?, ?)',
          [fileId, 'genericUser'],
        );
        onTestFinished(() => {
          try {
            fs.unlinkSync(getPathForUserFile(fileId));
          } catch {}
        });

        const res = await request(app)
          .get('/download-user-file')
          .set('x-actual-token', 'valid-token-user')
          .set('x-actual-file-id', fileId);

        expect(res.statusCode).toEqual(200);
        expect(res.headers).toEqual(
          expect.objectContaining({
            'content-disposition': `attachment;filename=${fileId}`,
            'content-type': 'application/octet-stream',
          }),
        );
        expect(res.body).toBeInstanceOf(Buffer);
        expect(res.body.toString('utf8')).toEqual(fileContent);
      });
    });
  });
});

describe('/update-user-filename', () => {
  it('returns 401 if the user is not authenticated', async () => {
    const res = await request(app).post('/update-user-filename');

    expect(res.statusCode).toEqual(401);
    expect(res.body).toEqual({
      details: 'token-not-found',
      reason: 'unauthorized',
      status: 'error',
    });
  });

  it('returns 400 if the file is not found', async () => {
    const res = await request(app)
      .post('/update-user-filename')
      .set('x-actual-token', 'valid-token')
      .send({ fileId: 'non-existent-file-id', name: 'new-filename' });

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('file-not-found');
  });

  it('returns 400 for invalid fileId format', async () => {
    const res = await request(app)
      .post('/update-user-filename')
      .set('x-actual-token', 'valid-token')
      .send({ fileId: 'budget@2026', name: 'new-filename' });

    expect(res.statusCode).toEqual(400);
    expect(res.text).toBe('invalid fileId');
  });

  it('successfully updates the filename', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const oldName = 'old-filename';
    const newName = 'new-filename';

    // Insert a mock file into the database
    getAccountDb().mutate(
      'INSERT INTO files (id, name, deleted) VALUES (?, ?, FALSE)',
      [fileId, oldName],
    );

    const res = await request(app)
      .post('/update-user-filename')
      .set('x-actual-token', 'valid-token')
      .send({ fileId, name: newName });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok' });

    // Verify that the filename was updated
    const rows = getAccountDb().all('SELECT name FROM files WHERE id = ?', [
      fileId,
    ]);

    expect(rows[0].name).toEqual(newName);
  });

  it('returns 403 when non-owner renames another user file', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    getAccountDb().mutate(
      'INSERT INTO files (id, name, deleted, owner) VALUES (?, ?, FALSE, ?)',
      [fileId, 'original-name', OTHER_USER_ID],
    );

    const res = await request(app)
      .post('/update-user-filename')
      .set('x-actual-token', 'valid-token-user')
      .send({ fileId, name: 'stolen' });

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');
  });

  it("allows an admin to rename another user's file", async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const originalName = 'original-name';
    const newName = 'admin-renamed-file';
    getAccountDb().mutate(
      'INSERT INTO files (id, name, deleted, owner) VALUES (?, ?, FALSE, ?)',
      [fileId, originalName, OTHER_USER_ID],
    );

    const res = await request(app)
      .post('/update-user-filename')
      .set('x-actual-token', 'valid-token-admin')
      .send({ fileId, name: newName });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok' });

    const rows = getAccountDb().all('SELECT name FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rows[0].name).toEqual(newName);
  });
});

describe('/list-user-files', () => {
  it('returns 401 if the user is not authenticated', async () => {
    const res = await request(app).get('/list-user-files');

    expect(res.statusCode).toEqual(401);
    expect(res.body).toEqual({
      details: 'token-not-found',
      reason: 'unauthorized',
      status: 'error',
    });
  });

  it('returns a list of user files for an authenticated user', async () => {
    createUser('fileListAdminId', 'admin', ADMIN_ROLE, 1);
    onTestFinished(() => deleteUser('fileListAdminId'));

    const fileId1 = crypto.randomBytes(16).toString('hex');
    const fileId2 = crypto.randomBytes(16).toString('hex');
    const fileName1 = 'file1.txt';
    const fileName2 = 'file2.txt';

    // Insert mock files into the database
    getAccountDb().mutate(
      'INSERT INTO files (id, name, deleted, owner) VALUES (?, ?, FALSE, ?)',
      [fileId1, fileName1, ''],
    );
    getAccountDb().mutate(
      'INSERT INTO files (id, name, deleted, owner) VALUES (?, ?, FALSE, ?)',
      [fileId2, fileName2, ''],
    );

    const res = await request(app)
      .get('/list-user-files')
      .set('x-actual-token', 'valid-token');

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual(
      expect.objectContaining({
        status: 'ok',
        data: expect.arrayContaining([
          expect.objectContaining({
            deleted: 0,
            fileId: fileId1,
            groupId: null,
            name: fileName1,
            encryptKeyId: null,
          }),
          expect.objectContaining({
            deleted: 0,
            fileId: fileId2,
            groupId: null,
            name: fileName2,
            encryptKeyId: null,
          }),
        ]),
      }),
    );
  });
});

describe('/get-user-file-info', () => {
  it('returns file info for a valid fileId', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'test-group-id';
    const fileInfo = {
      id: fileId,
      group_id: groupId,
      name: 'test-file',
      encrypt_meta: JSON.stringify({ key: 'value' }),
      deleted: 0,
    };

    getAccountDb().mutate(
      'INSERT INTO files (id, group_id, name, encrypt_meta, deleted) VALUES (?, ?, ?, ?, ?)',
      [
        fileInfo.id,
        fileInfo.group_id,
        fileInfo.name,
        fileInfo.encrypt_meta,
        fileInfo.deleted,
      ],
    );

    const res = await request(app)
      .get('/get-user-file-info')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-file-id', fileId)
      .send();

    expect(res.statusCode).toEqual(200);

    expect(res.body).toEqual({
      status: 'ok',
      data: {
        deleted: fileInfo.deleted,
        fileId: fileInfo.id,
        groupId: fileInfo.group_id,
        name: fileInfo.name,
        encryptMeta: { key: 'value' },
        usersWithAccess: [],
      },
    });
  });

  it('returns error if the file is not found', async () => {
    const fileId = 'non-existent-file-id';

    const res = await request(app)
      .get('/get-user-file-info')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-file-id', fileId);

    expect(res.statusCode).toEqual(400);
    expect(res.body).toEqual({ status: 'error', reason: 'file-not-found' });
  });

  it('returns 400 for invalid fileId format', async () => {
    const res = await request(app)
      .get('/get-user-file-info')
      .set('x-actual-token', 'valid-token')
      .set('x-actual-file-id', 'budget@2026');

    expect(res.statusCode).toEqual(400);
    expect(res.text).toEqual('invalid fileId');
  });

  it('returns error if the user is not authenticated', async () => {
    // Simulate an unauthenticated request by not setting the necessary headers
    const res = await request(app).get('/get-user-file-info');

    expect(res.statusCode).toEqual(401);
    expect(res.body).toEqual({
      status: 'error',
      reason: 'unauthorized',
      details: 'token-not-found',
    });
  });

  it('returns 403 when non-owner gets another user file info', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    getAccountDb().mutate(
      'INSERT INTO files (id, group_id, name, deleted, owner) VALUES (?, ?, ?, FALSE, ?)',
      [fileId, 'group-id', 'budget', OTHER_USER_ID],
    );

    const res = await request(app)
      .get('/get-user-file-info')
      .set('x-actual-token', 'valid-token-user')
      .set('x-actual-file-id', fileId);

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');
  });

  it("allows an admin to get another user's file info", async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'admin-file-info-group';
    const name = 'admin-info-file';
    const encrypt_meta = JSON.stringify({ key: 'value' });
    getAccountDb().mutate(
      'INSERT INTO files (id, group_id, name, encrypt_meta, deleted, owner) VALUES (?, ?, ?, ?, 0, ?)',
      [fileId, groupId, name, encrypt_meta, OTHER_USER_ID],
    );

    const res = await request(app)
      .get('/get-user-file-info')
      .set('x-actual-token', 'valid-token-admin')
      .set('x-actual-file-id', fileId);

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({
      status: 'ok',
      data: {
        deleted: 0,
        fileId,
        groupId,
        name,
        encryptMeta: { key: 'value' },
        usersWithAccess: [],
      },
    });
  });
});

describe('/delete-user-file', () => {
  it('returns 401 if the user is not authenticated', async () => {
    const res = await request(app).post('/delete-user-file');

    expect(res.statusCode).toEqual(401);
    expect(res.body).toEqual({
      details: 'token-not-found',
      reason: 'unauthorized',
      status: 'error',
    });
  });

  // it returns 422 if the fileId is not provided
  it('returns 422 if the fileId is not provided', async () => {
    const res = await request(app)
      .post('/delete-user-file')
      .set('x-actual-token', 'valid-token');

    expect(res.statusCode).toEqual(422);
    expect(res.body).toEqual({
      details: 'fileId-required',
      reason: 'unprocessable-entity',
      status: 'error',
    });
  });

  it('returns 400 if the file does not exist', async () => {
    const res = await request(app)
      .post('/delete-user-file')
      .set('x-actual-token', 'valid-token')
      .send({ fileId: 'non-existing-file-id' });

    expect(res.statusCode).toEqual(400);
    expect(res.text).toEqual('file-not-found');
  });

  it('returns 400 for invalid fileId format', async () => {
    const res = await request(app)
      .post('/delete-user-file')
      .set('x-actual-token', 'valid-token')
      .send({ fileId: 'budget@2026' });

    expect(res.statusCode).toEqual(400);
    expect(res.text).toEqual('invalid fileId');
  });

  it('marks the file as deleted', async () => {
    const accountDb = getAccountDb();
    const fileId = crypto.randomBytes(16).toString('hex');

    // Insert a file into the database
    accountDb.mutate(
      'INSERT OR IGNORE INTO files (id, deleted) VALUES (?, FALSE)',
      [fileId],
    );

    const res = await request(app)
      .post('/delete-user-file')
      .set('x-actual-token', 'valid-token')
      .send({ fileId });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok' });

    // Verify that the file is marked as deleted
    const rows = accountDb.all('SELECT deleted FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rows[0].deleted).toBe(1);
  });

  it('returns 403 if the user is not the owner and not an admin', async () => {
    const accountDb = getAccountDb();
    const fileId = crypto.randomBytes(16).toString('hex');

    // Insert a file owned by another user
    accountDb.mutate(
      'INSERT OR IGNORE INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
      [fileId, 'differentUser'],
    );

    // Try to delete with a non-admin, non-owner user
    const res = await request(app)
      .post('/delete-user-file')
      .set('x-actual-token', 'valid-token-user')
      .send({ fileId });

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');

    // Verify that the file is NOT deleted
    const rows = accountDb.all('SELECT deleted FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rows[0].deleted).toBe(0);
  });

  it('allows the file owner to delete the file', async () => {
    const accountDb = getAccountDb();
    const fileId = crypto.randomBytes(16).toString('hex');

    // Insert a file owned by genericUser
    accountDb.mutate(
      'INSERT OR IGNORE INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
      [fileId, 'genericUser'],
    );

    // Delete with the owner user
    const res = await request(app)
      .post('/delete-user-file')
      .set('x-actual-token', 'valid-token-user')
      .send({ fileId });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok' });

    // Verify that the file is deleted
    const rows = accountDb.all('SELECT deleted FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rows[0].deleted).toBe(1);
  });

  it('allows an admin to delete any file', async () => {
    const accountDb = getAccountDb();
    const fileId = crypto.randomBytes(16).toString('hex');

    // Insert a file owned by another user
    accountDb.mutate(
      'INSERT OR IGNORE INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
      [fileId, 'someOtherUser'],
    );

    // Delete with an admin user
    const res = await request(app)
      .post('/delete-user-file')
      .set('x-actual-token', 'valid-token-admin')
      .send({ fileId });

    expect(res.statusCode).toEqual(200);
    expect(res.body).toEqual({ status: 'ok' });

    // Verify that the file is deleted
    const rows = accountDb.all('SELECT deleted FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rows[0].deleted).toBe(1);
  });

  it('returns 403 when a shared user (user_access only) tries to delete a file owned by someone else', async () => {
    const accountDb = getAccountDb();
    const fileId = crypto.randomBytes(16).toString('hex');

    // File owned by another user; genericUser only has shared user_access.
    accountDb.mutate(
      'INSERT OR IGNORE INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
      [fileId, OTHER_USER_ID],
    );
    accountDb.mutate(
      'INSERT INTO user_access (file_id, user_id) VALUES (?, ?)',
      [fileId, 'genericUser'],
    );

    const res = await request(app)
      .post('/delete-user-file')
      .set('x-actual-token', 'valid-token-user')
      .send({ fileId });

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');

    const rows = accountDb.all('SELECT deleted FROM files WHERE id = ?', [
      fileId,
    ]);
    expect(rows[0].deleted).toBe(0);
  });
});

describe('/sync', () => {
  it('returns 401 if the user is not authenticated', async () => {
    const res = await request(app).post('/sync');

    expect(res.statusCode).toEqual(401);
    expect(res.body).toEqual({
      details: 'token-not-found',
      reason: 'unauthorized',
      status: 'error',
    });
  });

  it('returns 200 and syncs successfully with correct file attributes', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'group-id';
    const keyId = 'key-id';
    const syncVersion = 2;
    const encryptMeta = JSON.stringify({ keyId });

    addMockFile(fileId, groupId, keyId, encryptMeta, syncVersion);

    const syncRequest = createMinimalSyncRequest(fileId, groupId, keyId);

    const res = await sendSyncRequest(syncRequest);

    expect(res.statusCode).toEqual(200);
    expect(res.headers['content-type']).toEqual('application/actual-sync');
    expect(res.headers['x-actual-sync-method']).toEqual('simple');
  });

  it('returns 500 if the request body is invalid', async () => {
    const res = await request(app)
      .post('/sync')
      .set('x-actual-token', 'valid-token')
      // Content-Type is set correctly, but the body cannot be deserialized
      .set('Content-Type', 'application/actual-sync')
      .send('invalid-body');

    expect(res.statusCode).toEqual(500);
    expect(res.body).toEqual({
      status: 'error',
      reason: 'internal-error',
    });
  });

  it('returns 422 if since is not provided', async () => {
    const syncRequest = createMinimalSyncRequest(
      'file-id',
      'group-id',
      'key-id',
    );
    // proto3 default-value semantics: '' is omitted on the wire and
    // decoded back to '', which the handler falsy-checks as missing.
    syncRequest.since = '';

    const res = await sendSyncRequest(syncRequest);

    expect(res.statusCode).toEqual(422);
    expect(res.body).toEqual({
      status: 'error',
      reason: 'unprocessable-entity',
      details: 'since-required',
    });
  });

  it('returns 400 if the file does not exist in the database', async () => {
    const syncRequest = createMinimalSyncRequest(
      'non-existant-file-id',
      'group-id',
      'key-id',
    );

    // We do not insert the file into the database, so it does not exist

    const res = await sendSyncRequest(syncRequest);

    expect(res.statusCode).toEqual(400);
    expect(res.text).toEqual('file-not-found');
  });

  it('returns 400 if the file sync version is old', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'group-id';
    const keyId = 'key-id';
    const oldSyncVersion = 1; // Assuming SYNC_FORMAT_VERSION is 2

    // Add a mock file with an old sync version
    addMockFile(
      fileId,
      groupId,
      keyId,
      JSON.stringify({ keyId }),
      oldSyncVersion,
    );

    const syncRequest = createMinimalSyncRequest(fileId, groupId, keyId);

    const res = await sendSyncRequest(syncRequest);

    expect(res.statusCode).toEqual(400);
    expect(res.text).toEqual('file-old-version');
  });

  it('returns 400 if the file needs to be uploaded (no group_id)', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = null; // No group ID
    const keyId = 'key-id';
    const syncVersion = 2;

    addMockFile(fileId, groupId, keyId, JSON.stringify({ keyId }), syncVersion);

    const syncRequest = createMinimalSyncRequest(fileId, groupId, keyId);

    const res = await sendSyncRequest(syncRequest);

    expect(res.statusCode).toEqual(400);
    expect(res.text).toEqual('file-needs-upload');
  });

  it('returns 400 if the file has a new encryption key', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'group-id';
    const keyId = 'old-key-id';
    const newKeyId = 'new-key-id';
    const syncVersion = 2;

    // Add a mock file with the old key
    addMockFile(fileId, groupId, keyId, JSON.stringify({ keyId }), syncVersion);

    // Create a sync request with the new key
    const syncRequest = createMinimalSyncRequest(fileId, groupId, newKeyId);
    const res = await sendSyncRequest(syncRequest);

    expect(res.statusCode).toEqual(400);
    expect(res.text).toEqual('file-has-new-key');
  });

  it('returns 403 when non-owner syncs another user file', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'group-id';
    const keyId = 'key-id';
    const syncVersion = 2;
    const encryptMeta = JSON.stringify({ keyId });
    addMockFile(
      fileId,
      groupId,
      keyId,
      encryptMeta,
      syncVersion,
      OTHER_USER_ID,
    );
    const syncRequest = createMinimalSyncRequest(fileId, groupId, keyId);

    const res = await sendSyncRequest(syncRequest, 'valid-token-user');

    expect(res.statusCode).toEqual(403);
    expect(res.text).toEqual('file-access-not-allowed');
  });

  it.each([
    { reason: 'clock-drift', timestamp: futureTimestamp() },
    { reason: 'invalid-timestamp', timestamp: 'invalid' },
  ])(
    'returns 400 $reason for a new message without storing it',
    async ({ reason, timestamp }) => {
      const fileId = crypto.randomBytes(16).toString('hex');
      const keyId = 'key-id';
      addMockFile(fileId, 'group-id', keyId, JSON.stringify({ keyId }), 2);

      const syncRequest = createMinimalSyncRequest(fileId, 'group-id', keyId);
      syncRequest.messages = [createMessage(timestamp)];
      const res = await sendSyncRequest(syncRequest);
      // A stored message would be accepted as a duplicate on retry
      const retryRes = await sendSyncRequest(syncRequest);

      expect(res.statusCode).toEqual(400);
      expect(res.text).toEqual(reason);
      expect(retryRes.statusCode).toEqual(400);
      expect(retryRes.text).toEqual(reason);
    },
  );

  it.each([
    { offset: 5 * 60 * 1000, status: 200 },
    { offset: 5 * 60 * 1000 + 1, status: 400 },
  ])(
    'returns $status for a message $offset ms ahead',
    async ({ offset, status }) => {
      const fileId = crypto.randomBytes(16).toString('hex');
      const groupId = crypto.randomBytes(16).toString('hex');
      const keyId = 'key-id';
      addMockFile(fileId, groupId, keyId, JSON.stringify({ keyId }), 2);

      const syncRequest = createMinimalSyncRequest(fileId, groupId, keyId);

      vi.useFakeTimers({ toFake: ['Date'], now: Date.now() });
      try {
        syncRequest.messages = [createMessage(futureTimestamp(offset))];
        const res = await sendSyncRequest(syncRequest);

        expect(res.statusCode).toEqual(status);
      } finally {
        vi.useRealTimers();
      }
    },
  );

  it('accepts a resent far-future message the server already has', async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = crypto.randomBytes(16).toString('hex');
    const keyId = 'key-id';
    addMockFile(fileId, groupId, keyId, JSON.stringify({ keyId }), 2);

    const syncRequest = createMinimalSyncRequest(fileId, groupId, keyId);
    syncRequest.messages = [createMessage(futureTimestamp())];

    vi.useFakeTimers({ toFake: ['Date'], now: Date.now() + 2 * DAY_MS });
    try {
      await sendSyncRequest(syncRequest);
    } finally {
      vi.useRealTimers();
    }

    const res = await sendSyncRequest(syncRequest);

    expect(res.statusCode).toEqual(200);
  });

  it("allows an admin to sync another user's file", async () => {
    const fileId = crypto.randomBytes(16).toString('hex');
    const groupId = 'group-id';
    const keyId = 'key-id';
    const syncVersion = 2;
    const encryptMeta = JSON.stringify({ keyId });
    addMockFile(
      fileId,
      groupId,
      keyId,
      encryptMeta,
      syncVersion,
      OTHER_USER_ID,
    );
    const syncRequest = createMinimalSyncRequest(fileId, groupId, keyId);

    const res = await sendSyncRequest(syncRequest, 'valid-token-admin');

    expect(res.statusCode).toEqual(200);
    expect(res.headers['content-type']).toEqual('application/actual-sync');
    expect(res.headers['x-actual-sync-method']).toEqual('simple');
  });
});

function addMockFile(
  fileId: string,
  groupId: string | null,
  keyId: string,
  encryptMeta: string,
  syncVersion: number,
  owner: string = 'genericAdmin',
) {
  getAccountDb().mutate(
    'INSERT INTO files (id, group_id, encrypt_keyid, encrypt_meta, sync_version, owner) VALUES (?, ?, ?,?, ?, ?)',
    [fileId, groupId, keyId, encryptMeta, syncVersion, owner],
  );
}

function createMinimalSyncRequest(fileId, groupId, keyId) {
  return create(SyncRequestSchema, {
    fileId,
    groupId,
    keyId,
    since: '2024-01-01T00:00:00.000Z',
  });
}

const DAY_MS = 24 * 60 * 60 * 1000;

function futureTimestamp(offset = 2 * DAY_MS) {
  return `${new Date(Date.now() + offset).toISOString()}-0000-0000000000000000`;
}

function createMessage(timestamp: string) {
  return create(MessageEnvelopeSchema, {
    timestamp,
    isEncrypted: false,
    content: new Uint8Array(),
  });
}

async function sendSyncRequest(syncRequest, token = 'valid-token') {
  const serializedRequest = toBinary(SyncRequestSchema, syncRequest);
  // Convert Uint8Array to Buffer
  const bufferRequest = Buffer.from(serializedRequest);

  const res = await request(app)
    .post('/sync')
    .set('x-actual-token', token)
    .set('Content-Type', 'application/actual-sync')
    .send(bufferRequest);
  return res;
}