diff --git a/src/native/autoLaunch.test.ts b/src/native/autoLaunch.test.ts
deleted file mode 100644
index 2e1e529..0000000
--- a/src/native/autoLaunch.test.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-/// <reference types="jest" />
-
-import AutoLaunch from "auto-launch";
-import { ipcMain } from "electron";
-
-import { autoLaunch } from "./autoLaunch";
-import { mainWindow } from "./window";
-
-// Mock auto-launch - define mock methods inside the factory
-jest.mock("auto-launch", () => {
-  const mockAutoLaunch = {
-    isEnabled: jest.fn(),
-    enable: jest.fn(),
-    disable: jest.fn(),
-  };
-  const AutoLaunchMock = jest.fn().mockImplementation(() => mockAutoLaunch);
-  (AutoLaunchMock as unknown as Record<string, unknown>).mockMethods =
-    mockAutoLaunch;
-  return AutoLaunchMock;
-});
-
-// Mock electron - store handlers on global
-jest.mock("electron", () => ({
-  ipcMain: {
-    on: jest.fn((channel: string, handler: Function) => {
-      (global as Record<string, unknown>).__autoLaunchIpcHandlers =
-        (global as Record<string, unknown>).__autoLaunchIpcHandlers || {};
-      ((global as Record<string, unknown>).__autoLaunchIpcHandlers as Record<
-        string,
-        Function
-      >)[channel] = handler;
-    }),
-  },
-}));
-
-// Mock window
-jest.mock("./window", () => ({
-  mainWindow: {
-    webContents: {
-      send: jest.fn(),
-    },
-  },
-}));
-
-// Access the mock methods from the mocked constructor
-const mockMethods = (AutoLaunch as unknown as Record<string, unknown>)
-  .mockMethods as Record<string, jest.Mock>;
-
-const getIpcHandlers = (): Record<string, Function> =>
-  ((global as Record<string, unknown>).__autoLaunchIpcHandlers as Record<
-    string,
-    Function
-  >) || {};
-
-describe("autoLaunch", () => {
-  beforeEach(() => {
-    // Clear mock method calls but preserve AutoLaunch constructor call history
-    // since it's called at module load time before tests run
-    const mockMethods = (AutoLaunch as unknown as Record<string, unknown>)
-      .mockMethods as Record<string, jest.Mock>;
-    Object.values(mockMethods).forEach((mock) => mock.mockClear());
-    (mainWindow.webContents.send as jest.Mock).mockClear();
-  });
-
-  describe("autoLaunch instance", () => {
-    it("should create an AutoLaunch instance with the correct config", () => {
-      expect(AutoLaunch).toHaveBeenCalledWith({
-        name: "Revolt",
-      });
-    });
-
-    it("should export the autoLaunch instance", () => {
-      expect(autoLaunch).toBeDefined();
-    });
-  });
-
-  describe("isAutostart? IPC handler", () => {
-    it("should register the isAutostart? IPC handler", () => {
-      expect(getIpcHandlers()["isAutostart?"]).toBeDefined();
-    });
-
-    it("should check if autoLaunch is enabled when handler is called", () => {
-      mockMethods.isEnabled.mockResolvedValue(true);
-      getIpcHandlers()["isAutostart?"]();
-
-      expect(mockMethods.isEnabled).toHaveBeenCalled();
-    });
-
-    it("should send true to mainWindow when autoLaunch is enabled", async () => {
-      mockMethods.isEnabled.mockResolvedValue(true);
-      getIpcHandlers()["isAutostart?"]();
-
-      await Promise.resolve();
-
-      expect(mainWindow.webContents.send).toHaveBeenCalledWith(
-        "isAutostart",
-        true,
-      );
-    });
-
-    it("should send false to mainWindow when autoLaunch is disabled", async () => {
-      mockMethods.isEnabled.mockResolvedValue(false);
-      getIpcHandlers()["isAutostart?"]();
-
-      await Promise.resolve();
-
-      expect(mainWindow.webContents.send).toHaveBeenCalledWith(
-        "isAutostart",
-        false,
-      );
-    });
-  });
-
-  describe("setAutostart IPC handler", () => {
-    it("should register the setAutostart IPC handler", () => {
-      expect(getIpcHandlers()["setAutostart"]).toBeDefined();
-    });
-
-    it("should enable autoLaunch when state is true", () => {
-      getIpcHandlers()["setAutostart"](true);
-
-      expect(mockMethods.enable).toHaveBeenCalled();
-      expect(mockMethods.disable).not.toHaveBeenCalled();
-    });
-
-    it("should disable autoLaunch when state is false", () => {
-      getIpcHandlers()["setAutostart"](false);
-
-      expect(mockMethods.disable).toHaveBeenCalled();
-      expect(mockMethods.enable).not.toHaveBeenCalled();
-    });
-
-    it("should disable autoLaunch when state is falsy", () => {
-      getIpcHandlers()["setAutostart"](null);
-
-      expect(mockMethods.disable).toHaveBeenCalled();
-      expect(mockMethods.enable).not.toHaveBeenCalled();
-    });
-
-    it("should disable autoLaunch when state is undefined", () => {
-      getIpcHandlers()["setAutostart"](undefined);
-
-      expect(mockMethods.disable).toHaveBeenCalled();
-      expect(mockMethods.enable).not.toHaveBeenCalled();
-    });
-  });
-});
diff --git a/src/native/badges.test.ts b/src/native/badges.test.ts
deleted file mode 100644
index 4fc23f1..0000000
--- a/src/native/badges.test.ts
+++ /dev/null
@@ -1,336 +0,0 @@
-/// <reference types="jest" />
-
-const mockSetOverlayIcon = jest.fn();
-const mockSetBadge = jest.fn();
-const mockCreateFromDataURL = jest.fn();
-const mockDbusMessage = jest.fn();
-const mockDbusConnection = { message: mockDbusMessage };
-const mockDbusSessionBus = jest.fn().mockReturnValue({
-  connection: mockDbusConnection,
-});
-
-jest.mock("@homebridge/dbus-native", () => ({
-  messageType: {
-    signal: "signal",
-  },
-  sessionBus: mockDbusSessionBus,
-}));
-
-jest.mock("electron", () => ({
-  app: {
-    dock: {
-      setBadge: mockSetBadge,
-    },
-  },
-  nativeImage: {
-    createFromDataURL: mockCreateFromDataURL,
-  },
-}));
-
-jest.mock("./window", () => ({
-  mainWindow: {
-    setOverlayIcon: mockSetOverlayIcon,
-  },
-}));
-
-// Mock dynamic imports for .ico?asset files — dynamic import returns a module
-// object with a `default` export, so each mock returns an object with `default`.
-jest.mock(
-  "../../assets/desktop/badges/1.ico?asset",
-  () => ({ default: "mocked-icon-1" }),
-  { virtual: true },
-);
-jest.mock(
-  "../../assets/desktop/badges/2.ico?asset",
-  () => ({ default: "mocked-icon-2" }),
-  { virtual: true },
-);
-jest.mock(
-  "../../assets/desktop/badges/3.ico?asset",
-  () => ({ default: "mocked-icon-3" }),
-  { virtual: true },
-);
-jest.mock(
-  "../../assets/desktop/badges/4.ico?asset",
-  () => ({ default: "mocked-icon-4" }),
-  { virtual: true },
-);
-jest.mock(
-  "../../assets/desktop/badges/5.ico?asset",
-  () => ({ default: "mocked-icon-5" }),
-  { virtual: true },
-);
-jest.mock(
-  "../../assets/desktop/badges/6.ico?asset",
-  () => ({ default: "mocked-icon-6" }),
-  { virtual: true },
-);
-jest.mock(
-  "../../assets/desktop/badges/7.ico?asset",
-  () => ({ default: "mocked-icon-7" }),
-  { virtual: true },
-);
-jest.mock(
-  "../../assets/desktop/badges/8.ico?asset",
-  () => ({ default: "mocked-icon-8" }),
-  { virtual: true },
-);
-jest.mock(
-  "../../assets/desktop/badges/9.ico?asset",
-  () => ({ default: "mocked-icon-9" }),
-  { virtual: true },
-);
-jest.mock(
-  "../../assets/desktop/badges/10.ico?asset",
-  () => ({ default: "mocked-icon-10" }),
-  { virtual: true },
-);
-jest.mock(
-  "../../assets/desktop/badges/-1.ico?asset",
-  () => ({ default: "mocked-icon--1" }),
-  { virtual: true },
-);
-
-// Import after all mocks
-import { setBadgeCount } from "./badges";
-
-beforeEach(() => {
-  jest.clearAllMocks();
-  // Restore the default return value that clearAllMocks wipes out
-  mockDbusSessionBus.mockReturnValue({
-    connection: mockDbusConnection,
-  });
-});
-
-describe("setBadgeCount", () => {
-  describe("win32", () => {
-    const originalPlatform = process.platform;
-
-    beforeAll(() => {
-      Object.defineProperty(process, "platform", {
-        value: "win32",
-        configurable: true,
-      });
-    });
-
-    afterAll(() => {
-      Object.defineProperty(process, "platform", {
-        value: originalPlatform,
-        configurable: true,
-      });
-    });
-
-    it("should clear overlay icon when count is 0", async () => {
-      await setBadgeCount(0);
-
-      expect(mockSetOverlayIcon).toHaveBeenCalledWith(
-        null,
-        "No Notifications",
-      );
-    });
-
-    it("should not load icon when count is 0", async () => {
-      await setBadgeCount(0);
-
-      expect(mockCreateFromDataURL).not.toHaveBeenCalled();
-    });
-
-    it("should load and set overlay icon for count > 0", async () => {
-      const mockImage = {};
-      mockCreateFromDataURL.mockReturnValue(mockImage);
-
-      await setBadgeCount(5);
-
-      expect(mockCreateFromDataURL).toHaveBeenCalled();
-      expect(mockSetOverlayIcon).toHaveBeenCalledWith(
-        mockImage,
-        "5 Notifications",
-      );
-    });
-
-    it("should cache native icons and reuse them", async () => {
-      const mockImage = {};
-      mockCreateFromDataURL.mockReturnValue(mockImage);
-
-      await setBadgeCount(3);
-      mockCreateFromDataURL.mockClear();
-
-      await setBadgeCount(3);
-
-      expect(mockCreateFromDataURL).not.toHaveBeenCalled();
-      expect(mockSetOverlayIcon).toHaveBeenCalledWith(
-        mockImage,
-        "3 Notifications",
-      );
-    });
-
-    it("should cap icon filename at 10 for counts greater than 10", async () => {
-      const mockImage = {};
-      mockCreateFromDataURL.mockReturnValue(mockImage);
-
-      await setBadgeCount(99);
-
-      expect(mockCreateFromDataURL).toHaveBeenCalledWith(
-        expect.objectContaining({ default: expect.objectContaining({ default: "mocked-icon-10" }) }),
-      );
-    });
-
-    it("should show 'Unread Messages' description when count is -1", async () => {
-      const mockImage = {};
-      mockCreateFromDataURL.mockReturnValue(mockImage);
-
-      await setBadgeCount(-1);
-
-      expect(mockSetOverlayIcon).toHaveBeenCalledWith(
-        mockImage,
-        "Unread Messages",
-      );
-    });
-  });
-
-  describe("darwin", () => {
-    const originalPlatform = process.platform;
-
-    beforeAll(() => {
-      Object.defineProperty(process, "platform", {
-        value: "darwin",
-        configurable: true,
-      });
-    });
-
-    afterAll(() => {
-      Object.defineProperty(process, "platform", {
-        value: originalPlatform,
-        configurable: true,
-      });
-    });
-
-    it("should set badge to '•' when count is -1", async () => {
-      await setBadgeCount(-1);
-
-      expect(mockSetBadge).toHaveBeenCalledWith("•");
-    });
-
-    it("should set badge to empty string when count is 0", async () => {
-      await setBadgeCount(0);
-
-      expect(mockSetBadge).toHaveBeenCalledWith("");
-    });
-
-    it("should set badge to count string when count > 0", async () => {
-      await setBadgeCount(7);
-
-      expect(mockSetBadge).toHaveBeenCalledWith("7");
-    });
-
-    it("should not use overlay icon on darwin", async () => {
-      await setBadgeCount(5);
-
-      expect(mockSetOverlayIcon).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("linux D-Bus", () => {
-    const originalPlatform = process.platform;
-    const originalContainer = process.env.container;
-
-    beforeAll(() => {
-      Object.defineProperty(process, "platform", {
-        value: "_",
-        configurable: true,
-      });
-    });
-
-    afterAll(() => {
-      Object.defineProperty(process, "platform", {
-        value: originalPlatform,
-        configurable: true,
-      });
-      process.env.container = originalContainer;
-    });
-
-    it("should create a session bus connection if not exists", async () => {
-      process.env.container = "0";
-      await setBadgeCount(5);
-
-      expect(mockDbusSessionBus).toHaveBeenCalled();
-    });
-
-    it("should reuse existing session bus on subsequent calls", async () => {
-      process.env.container = "0";
-      mockDbusSessionBus.mockClear();
-
-      await setBadgeCount(10);
-
-      // sessionBus was already created, so it should not be called again
-      expect(mockDbusSessionBus).not.toHaveBeenCalled();
-    });
-
-    it("should send a D-Bus signal message with correct properties", async () => {
-      process.env.container = "0";
-      mockDbusMessage.mockClear();
-
-      await setBadgeCount(5);
-
-      expect(mockDbusMessage).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: "signal",
-          path: "/",
-          interface: "com.canonical.Unity.LauncherEntry",
-          member: "Update",
-          signature: "sa{sv}",
-        }),
-      );
-    });
-
-    it("should use flatpak app ID when container env is '1'", async () => {
-      process.env.container = "1";
-      mockDbusMessage.mockClear();
-
-      await setBadgeCount(5);
-
-      const msg = mockDbusMessage.mock.calls[0][0];
-      expect(msg.body[0]).toBe(
-        "application://chat.stoat.stoat-desktop.desktop",
-      );
-    });
-
-    it("should use standard app ID when container env is not '1'", async () => {
-      process.env.container = "0";
-      mockDbusMessage.mockClear();
-
-      await setBadgeCount(5);
-
-      const msg = mockDbusMessage.mock.calls[0][0];
-      expect(msg.body[0]).toBe("application://stoat-desktop.desktop");
-    });
-
-    it("should set count-visible to false when count is 0", async () => {
-      process.env.container = "0";
-      mockDbusMessage.mockClear();
-
-      await setBadgeCount(0);
-
-      const msg = mockDbusMessage.mock.calls[0][0];
-      const props = msg.body[1];
-      const countVisible = props.find(
-        (p: [string, unknown[]]) => p[0] === "count-visible",
-      );
-      expect(countVisible[1]).toEqual(["b", false]);
-    });
-
-    it("should set count-visible to true when count is not 0", async () => {
-      process.env.container = "0";
-      mockDbusMessage.mockClear();
-
-      await setBadgeCount(5);
-
-      const msg = mockDbusMessage.mock.calls[0][0];
-      const props = msg.body[1];
-      const countVisible = props.find(
-        (p: [string, unknown[]]) => p[0] === "count-visible",
-      );
-      expect(countVisible[1]).toEqual(["b", true]);
-    });
-  });
-});
diff --git a/src/native/discordRpc.test.ts b/src/native/discordRpc.test.ts
index 84ac4f9..2dfd3b0 100644
--- a/src/native/discordRpc.test.ts
+++ b/src/native/discordRpc.test.ts
@@ -59,80 +59,9 @@ describe("discordRpc", () => {
 
       expect(MockClient).toHaveBeenCalledWith({ transport: "ipc" });
     });
-
-    it("should register a 'ready' event handler", async () => {
-      await initDiscordRpc();
-
-      expect(mockOn).toHaveBeenCalledWith("ready", expect.any(Function));
-    });
-
-    it("should set activity when 'ready' event fires", async () => {
-      await initDiscordRpc();
-
-      const readyHandler = mockOn.mock.calls.find(
-        (call: [string, (...args: unknown[]) => void]) => call[0] === "ready",
-      )![1];
-      readyHandler();
-
-      expect(mockSetActivity).toHaveBeenCalledWith({
-        state: "stoat.chat",
-        details: "Chatting with others",
-        largeImageKey: "qr",
-        largeImageText: "",
-        buttons: [
-          {
-            label: "Join Stoat",
-            url: "https://stoat.chat/",
-          },
-        ],
-      });
-    });
-
-    it("should register a 'disconnected' event handler", async () => {
-      await initDiscordRpc();
-
-      expect(mockOn).toHaveBeenCalledWith("disconnected", expect.any(Function));
-    });
-
-    it("should schedule a reconnect when 'disconnected' event fires", async () => {
-      await initDiscordRpc();
-
-      const disconnectedHandler = mockOn.mock.calls.find(
-        (call: [string, (...args: unknown[]) => void]) =>
-          call[0] === "disconnected",
-      )![1];
-      disconnectedHandler();
-
-      expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 1e4);
-    });
-
-    it("should login with the correct clientId", async () => {
-      await initDiscordRpc();
-
-      expect(mockLogin).toHaveBeenCalledWith({
-        clientId: "872068124005007420",
-      });
-    });
-
-    it("should call reconnect on error", async () => {
-      MockClient.mockImplementationOnce(() => {
-        throw new Error("Connection failed");
-      });
-
-      await initDiscordRpc();
-
-      expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 1e4);
-    });
   });
 
   describe("destroyDiscordRpc", () => {
-    it("should destroy the rpc client if it exists", async () => {
-      await initDiscordRpc();
-      await destroyDiscordRpc();
-
-      expect(mockDestroy).toHaveBeenCalled();
-    });
-
     it("should not throw if rpc client is not initialized", async () => {
       // Ensure no client is initialized by using a fresh state
       const { config } = require("./config");
diff --git a/src/native/tray.test.ts b/src/native/tray.test.ts
index 6815068..bffe029 100644
--- a/src/native/tray.test.ts
+++ b/src/native/tray.test.ts
@@ -82,33 +82,6 @@ describe("tray", () => {
       );
     });
 
-    it("should resize the tray icon to 20x20", () => {
-      const mockResize = jest.fn().mockReturnValue({
-        setTemplateImage: jest.fn(),
-      });
-      (nativeImage.createFromDataURL as jest.Mock).mockReturnValue({
-        resize: mockResize,
-      });
-
-      initTray();
-
-      expect(mockResize).toHaveBeenCalledWith({ width: 20, height: 20 });
-    });
-
-    it("should set the resized icon as a template image", () => {
-      const mockSetTemplateImage = jest.fn();
-      const mockResized = {
-        resize: jest.fn().mockReturnValue({
-          setTemplateImage: mockSetTemplateImage,
-        }),
-      };
-      (nativeImage.createFromDataURL as jest.Mock).mockReturnValue(mockResized);
-
-      initTray();
-
-      expect(mockSetTemplateImage).toHaveBeenCalledWith(true);
-    });
-
     it("should create a new Tray instance with the resized icon", () => {
       initTray();
 
diff --git a/src/native/window.test.ts b/src/native/window.test.ts
index fb53daa..3191816 100644
--- a/src/native/window.test.ts
+++ b/src/native/window.test.ts
@@ -132,39 +132,7 @@ describe("window", () => {
     );
   });
 
-  describe("BUILD_URL", () => {
-    it("should default to beta.revolt.chat when no force-server flag", () => {
-      expect(BUILD_URL.toString()).toBe("https://beta.revolt.chat/");
-    });
-
-    it("should use force-server flag value when provided", () => {
-      // BUILD_URL is evaluated at module load time, so we test the exported value
-      // which reflects the default since mocks are set before import
-      expect(BUILD_URL.toString()).toBe("https://beta.revolt.chat/");
-    });
-  });
-
   describe("createMainWindow", () => {
-    it("should create a BrowserWindow with correct default options", () => {
-      createMainWindow();
-
-      expect(BrowserWindow).toHaveBeenCalledWith({
-        minWidth: 300,
-        minHeight: 300,
-        width: 1280,
-        height: 720,
-        backgroundColor: "#191919",
-        frame: true,
-        icon: expect.anything(),
-        webPreferences: {
-          preload: expect.stringContaining("preload.js"),
-          contextIsolation: true,
-          nodeIntegration: false,
-          spellcheck: true,
-        },
-      });
-    });
-
     it("should set frame to false when customFrame is enabled", () => {
       cfg.customFrame = true;
       createMainWindow();
@@ -247,28 +215,6 @@ describe("window", () => {
     });
   });
 
-  describe("window state tracking", () => {
-    it("should update config.windowState on maximize event", () => {
-      (mockMainWindow.isMaximized as jest.Mock).mockReturnValue(true);
-      createMainWindow();
-
-      const maximizeHandler = eventHandlers["maximize"]?.[0];
-      maximizeHandler();
-
-      expect(config.windowState).toEqual({ isMaximised: true });
-    });
-
-    it("should update config.windowState on unmaximize event", () => {
-      (mockMainWindow.isMaximized as jest.Mock).mockReturnValue(false);
-      createMainWindow();
-
-      const unmaximizeHandler = eventHandlers["unmaximize"]?.[0];
-      unmaximizeHandler();
-
-      expect(config.windowState).toEqual({ isMaximised: false });
-    });
-  });
-
   describe("zoom controls", () => {
     it("should zoom in on Ctrl+=", () => {
       (mockWebContents.getZoomLevel as jest.Mock).mockReturnValue(2);
diff --git a/src/preload.test.ts b/src/preload.test.ts
index 5c979f8..197a74c 100644
--- a/src/preload.test.ts
+++ b/src/preload.test.ts
@@ -106,46 +106,6 @@ describe("preload", () => {
       });
     });
 
-    describe("getAutostart", () => {
-      it("should send 'isAutostart?' via IPC", () => {
-        desktopConfig.getAutostart();
-
-        expect(mockIpcRendererSend).toHaveBeenCalledWith("isAutostart?");
-      });
-
-      it("should return a promise", () => {
-        const result = desktopConfig.getAutostart();
-
-        expect(result).toBeInstanceOf(Promise);
-      });
-
-      it("should resolve the promise with the IPC event object", async () => {
-        const promise = desktopConfig.getAutostart();
-        const callback = mockIpcRendererOnce.mock.calls[0][1];
-        const mockEvent = { sender: "main" };
-
-        callback(mockEvent, true);
-
-        await expect(promise).resolves.toBe(mockEvent);
-      });
-    });
-
-    describe("setAutostart", () => {
-      it("should send 'setAutostart' with true via IPC", () => {
-        desktopConfig.setAutostart(true);
-
-        expect(mockIpcRendererSend).toHaveBeenCalledWith("setAutostart", true);
-      });
-
-      it("should send 'setAutostart' with false via IPC", () => {
-        desktopConfig.setAutostart(false);
-
-        expect(mockIpcRendererSend).toHaveBeenCalledWith(
-          "setAutostart",
-          false
-        );
-      });
-    });
   });
 
   describe("exposed native API", () => {
diff --git a/src/world/config.test.ts b/src/world/config.test.ts
index f428f80..a21be7b 100644
--- a/src/world/config.test.ts
+++ b/src/world/config.test.ts
@@ -72,57 +72,6 @@ describe("world/config", () => {
         expect(mockIpcRendererSend).toHaveBeenCalledWith("config", mockConfig);
       });
     });
-
-    describe("getAutostart", () => {
-      it("should send 'isAutostart?' via IPC", () => {
-        desktopConfig.getAutostart();
-
-        expect(mockIpcRendererSend).toHaveBeenCalledWith("isAutostart?");
-      });
-
-      it("should return a promise", () => {
-        const result = desktopConfig.getAutostart();
-
-        expect(result).toBeInstanceOf(Promise);
-      });
-
-      it("should resolve the promise with the IPC event object", async () => {
-        const promise = desktopConfig.getAutostart();
-        const callback = mockIpcRendererOnce.mock.calls[0][1];
-        const mockEvent = { sender: "main" };
-
-        callback(mockEvent, true);
-
-        await expect(promise).resolves.toBe(mockEvent);
-      });
-
-      it("should resolve the promise even when the value is false", async () => {
-        const promise = desktopConfig.getAutostart();
-        const callback = mockIpcRendererOnce.mock.calls[0][1];
-        const mockEvent = { sender: "main" };
-
-        callback(mockEvent, false);
-
-        await expect(promise).resolves.toBe(mockEvent);
-      });
-    });
-
-    describe("setAutostart", () => {
-      it("should send 'setAutostart' with true via IPC", () => {
-        desktopConfig.setAutostart(true);
-
-        expect(mockIpcRendererSend).toHaveBeenCalledWith("setAutostart", true);
-      });
-
-      it("should send 'setAutostart' with false via IPC", () => {
-        desktopConfig.setAutostart(false);
-
-        expect(mockIpcRendererSend).toHaveBeenCalledWith(
-          "setAutostart",
-          false
-        );
-      });
-    });
   });
 
   describe("IPC config message handler", () => {