Apply repository-wide ESLint auto-fix formatting pass

Co-Authored-By: Codex <codex@openai.com>

tests/stores/acctMgmt.test.js

@@ -3,27 +3,30 @@
 // Authors:
 //   imacat.yang@dsp.im (imacat), 2026/03/05
 
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { setActivePinia, createPinia } from 'pinia';
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { setActivePinia, createPinia } from "pinia";
 
-vi.mock('@/module/apiError.js', () => ({
+vi.mock("@/module/apiError.js", () => ({
   default: vi.fn(),
 }));
 
 const { mockGet, mockPost, mockPut, mockDelete } = vi.hoisted(() => ({
-  mockGet: vi.fn(), mockPost: vi.fn(), mockPut: vi.fn(), mockDelete: vi.fn(),
+  mockGet: vi.fn(),
+  mockPost: vi.fn(),
+  mockPut: vi.fn(),
+  mockDelete: vi.fn(),
 }));
-vi.mock('@/api/client.js', () => ({
+vi.mock("@/api/client.js", () => ({
   default: { get: mockGet, post: mockPost, put: mockPut, delete: mockDelete },
 }));
 
 // Mock login store to avoid its side effects
-vi.mock('@/stores/login', () => {
-  const { defineStore } = require('pinia');
+vi.mock("@/stores/login", () => {
+  const { defineStore } = require("pinia");
   return {
-    useLoginStore: defineStore('loginStore', {
+    useLoginStore: defineStore("loginStore", {
       state: () => ({
-        userData: { username: 'currentUser', name: 'Current' },
+        userData: { username: "currentUser", name: "Current" },
       }),
       actions: {
         getUserData: vi.fn(),
@@ -32,9 +35,9 @@ vi.mock('@/stores/login', () => {
   };
 });
 
-import { useAcctMgmtStore } from '@/stores/acctMgmt';
+import { useAcctMgmtStore } from "@/stores/acctMgmt";
 
-describe('acctMgmtStore', () => {
+describe("acctMgmtStore", () => {
   let store;
 
   beforeEach(() => {
@@ -43,24 +46,24 @@ describe('acctMgmtStore', () => {
     vi.clearAllMocks();
   });
 
-  it('has correct default state', () => {
+  it("has correct default state", () => {
     expect(store.allUserAccountList).toEqual([]);
     expect(store.isAcctMenuOpen).toBe(false);
   });
 
-  describe('menu actions', () => {
-    it('openAcctMenu sets true', () => {
+  describe("menu actions", () => {
+    it("openAcctMenu sets true", () => {
       store.openAcctMenu();
       expect(store.isAcctMenuOpen).toBe(true);
     });
 
-    it('closeAcctMenu sets false', () => {
+    it("closeAcctMenu sets false", () => {
       store.openAcctMenu();
       store.closeAcctMenu();
       expect(store.isAcctMenuOpen).toBe(false);
     });
 
-    it('toggleIsAcctMenuOpen toggles', () => {
+    it("toggleIsAcctMenuOpen toggles", () => {
       store.toggleIsAcctMenuOpen();
       expect(store.isAcctMenuOpen).toBe(true);
       store.toggleIsAcctMenuOpen();
@@ -68,157 +71,149 @@ describe('acctMgmtStore', () => {
     });
   });
 
-  describe('setCurrentViewingUser', () => {
-    it('finds user by username', () => {
+  describe("setCurrentViewingUser", () => {
+    it("finds user by username", () => {
       store.allUserAccountList = [
-        { username: 'alice', name: 'Alice', detail: {} },
-        { username: 'bob', name: 'Bob', detail: {} },
+        { username: "alice", name: "Alice", detail: {} },
+        { username: "bob", name: "Bob", detail: {} },
       ];
-      store.setCurrentViewingUser('bob');
-      expect(store.currentViewingUser.name).toBe('Bob');
+      store.setCurrentViewingUser("bob");
+      expect(store.currentViewingUser.name).toBe("Bob");
     });
   });
 
-  describe('clearCurrentViewingUser', () => {
-    it('resets to empty user', () => {
-      store.currentViewingUser = { username: 'test', detail: {} };
+  describe("clearCurrentViewingUser", () => {
+    it("resets to empty user", () => {
+      store.currentViewingUser = { username: "test", detail: {} };
       store.clearCurrentViewingUser();
-      expect(store.currentViewingUser.username).toBe('');
+      expect(store.currentViewingUser.username).toBe("");
     });
   });
 
-  describe('createNewAccount', () => {
-    it('posts to /api/users and sets flag on success', async () => {
+  describe("createNewAccount", () => {
+    it("posts to /api/users and sets flag on success", async () => {
       mockPost.mockResolvedValue({ status: 200 });
-      const user = { username: 'newuser', password: 'pass' };
+      const user = { username: "newuser", password: "pass" };
 
       await store.createNewAccount(user);
 
-      expect(mockPost).toHaveBeenCalledWith(
-        '/api/users', user,
-      );
+      expect(mockPost).toHaveBeenCalledWith("/api/users", user);
       expect(store.isOneAccountJustCreate).toBe(true);
-      expect(store.justCreateUsername).toBe('newuser');
+      expect(store.justCreateUsername).toBe("newuser");
     });
   });
 
-  describe('deleteAccount', () => {
-    it('returns true on success', async () => {
+  describe("deleteAccount", () => {
+    it("returns true on success", async () => {
       mockDelete.mockResolvedValue({ status: 200 });
 
-      const result = await store.deleteAccount('alice');
+      const result = await store.deleteAccount("alice");
 
-      expect(mockDelete).toHaveBeenCalledWith(
-        '/api/users/alice',
-      );
+      expect(mockDelete).toHaveBeenCalledWith("/api/users/alice");
       expect(result).toBe(true);
     });
 
-    it('encodes special characters in username', async () => {
+    it("encodes special characters in username", async () => {
       mockDelete.mockResolvedValue({ status: 200 });
 
-      await store.deleteAccount('user@domain/name');
+      await store.deleteAccount("user@domain/name");
 
       expect(mockDelete).toHaveBeenCalledWith(
-        '/api/users/user%40domain%2Fname',
+        "/api/users/user%40domain%2Fname",
       );
     });
 
-    it('returns false on error', async () => {
-      mockDelete.mockRejectedValue(new Error('fail'));
+    it("returns false on error", async () => {
+      mockDelete.mockRejectedValue(new Error("fail"));
 
-      const result = await store.deleteAccount('alice');
+      const result = await store.deleteAccount("alice");
 
       expect(result).toBe(false);
     });
   });
 
-  describe('editAccount', () => {
-    it('puts edited data', async () => {
+  describe("editAccount", () => {
+    it("puts edited data", async () => {
       mockPut.mockResolvedValue({ status: 200 });
       const detail = {
-        username: 'alice',
-        password: 'newpw',
-        name: 'Alice',
+        username: "alice",
+        password: "newpw",
+        name: "Alice",
         is_active: true,
       };
 
-      const result = await store.editAccount('alice', detail);
+      const result = await store.editAccount("alice", detail);
 
       expect(mockPut).toHaveBeenCalledWith(
-        '/api/users/alice',
-        expect.objectContaining({ password: 'newpw' }),
+        "/api/users/alice",
+        expect.objectContaining({ password: "newpw" }),
       );
       expect(result).toBe(true);
     });
   });
 
-  describe('addRoleToUser', () => {
-    it('puts role assignment', async () => {
+  describe("addRoleToUser", () => {
+    it("puts role assignment", async () => {
       mockPut.mockResolvedValue({ status: 200 });
 
-      const result = await store.addRoleToUser('alice', 'admin');
+      const result = await store.addRoleToUser("alice", "admin");
 
-      expect(mockPut).toHaveBeenCalledWith(
-        '/api/users/alice/roles/admin',
-      );
+      expect(mockPut).toHaveBeenCalledWith("/api/users/alice/roles/admin");
       expect(result).toBe(true);
     });
 
-    it('encodes special characters in username and role', async () => {
+    it("encodes special characters in username and role", async () => {
       mockPut.mockResolvedValue({ status: 200 });
 
-      await store.addRoleToUser('user@org', 'role/special');
+      await store.addRoleToUser("user@org", "role/special");
 
       expect(mockPut).toHaveBeenCalledWith(
-        '/api/users/user%40org/roles/role%2Fspecial',
+        "/api/users/user%40org/roles/role%2Fspecial",
       );
     });
   });
 
-  describe('deleteRoleToUser', () => {
-    it('deletes role', async () => {
+  describe("deleteRoleToUser", () => {
+    it("deletes role", async () => {
       mockDelete.mockResolvedValue({ status: 200 });
 
-      const result = await store.deleteRoleToUser('alice', 'admin');
+      const result = await store.deleteRoleToUser("alice", "admin");
 
-      expect(mockDelete).toHaveBeenCalledWith(
-        '/api/users/alice/roles/admin',
-      );
+      expect(mockDelete).toHaveBeenCalledWith("/api/users/alice/roles/admin");
       expect(result).toBe(true);
     });
   });
 
-  describe('getUserDetail', () => {
-    it('fetches user and sets admin flag', async () => {
+  describe("getUserDetail", () => {
+    it("fetches user and sets admin flag", async () => {
       mockGet.mockResolvedValue({
         status: 200,
         data: {
-          username: 'alice',
-          roles: [{ code: 'admin' }],
+          username: "alice",
+          roles: [{ code: "admin" }],
         },
       });
 
-      const result = await store.getUserDetail('alice');
+      const result = await store.getUserDetail("alice");
 
       expect(result).toBe(true);
       expect(store.currentViewingUser.is_admin).toBe(true);
     });
 
-    it('returns false on error', async () => {
-      mockGet.mockRejectedValue(new Error('not found'));
+    it("returns false on error", async () => {
+      mockGet.mockRejectedValue(new Error("not found"));
 
-      const result = await store.getUserDetail('ghost');
+      const result = await store.getUserDetail("ghost");
 
       expect(result).toBe(false);
     });
   });
 
-  describe('hover state actions', () => {
+  describe("hover state actions", () => {
     beforeEach(() => {
       store.allUserAccountList = [
         {
-          username: 'alice',
+          username: "alice",
           isDeleteHovered: false,
           isRowHovered: false,
           isEditHovered: false,
@@ -227,45 +222,44 @@ describe('acctMgmtStore', () => {
       ];
     });
 
-    it('changeIsDeleteHoveredByUser', () => {
-      store.changeIsDeleteHoveredByUser('alice', true);
+    it("changeIsDeleteHoveredByUser", () => {
+      store.changeIsDeleteHoveredByUser("alice", true);
       expect(store.allUserAccountList[0].isDeleteHovered).toBe(true);
     });
 
-    it('changeIsRowHoveredByUser', () => {
-      store.changeIsRowHoveredByUser('alice', true);
+    it("changeIsRowHoveredByUser", () => {
+      store.changeIsRowHoveredByUser("alice", true);
       expect(store.allUserAccountList[0].isRowHovered).toBe(true);
     });
 
-    it('changeIsEditHoveredByUser', () => {
-      store.changeIsEditHoveredByUser('alice', true);
+    it("changeIsEditHoveredByUser", () => {
+      store.changeIsEditHoveredByUser("alice", true);
       expect(store.allUserAccountList[0].isEditHovered).toBe(true);
     });
 
-    it('changeIsDetailHoveredByUser', () => {
-      store.changeIsDetailHoveredByUser('alice', true);
+    it("changeIsDetailHoveredByUser", () => {
+      store.changeIsDetailHoveredByUser("alice", true);
       expect(store.allUserAccountList[0].isDetailHovered).toBe(true);
     });
   });
 
-  it('resetJustCreateFlag resets flag', () => {
+  it("resetJustCreateFlag resets flag", () => {
     store.isOneAccountJustCreate = true;
     store.resetJustCreateFlag();
     expect(store.isOneAccountJustCreate).toBe(false);
   });
 
-  it('setShouldUpdateList sets boolean', () => {
+  it("setShouldUpdateList sets boolean", () => {
     store.setShouldUpdateList(true);
     expect(store.shouldUpdateList).toBe(true);
   });
 
-  it('updateSingleAccountPiniaState updates user', () => {
-    store.allUserAccountList = [
-      { username: 'alice', name: 'Old' },
-    ];
+  it("updateSingleAccountPiniaState updates user", () => {
+    store.allUserAccountList = [{ username: "alice", name: "Old" }];
     store.updateSingleAccountPiniaState({
-      username: 'alice', name: 'New',
+      username: "alice",
+      name: "New",
     });
-    expect(store.allUserAccountList[0].name).toBe('New');
+    expect(store.allUserAccountList[0].name).toBe("New");
   });
 });