test(ui): refactor all tests

src/client/web/src/client/files_mock.ts

@@ -6,115 +6,164 @@ import {
   ListSharingsResp,
 } from "./";
 
-export class FilesClient {
+export interface FilesClientResps {
-  private url: string;
+  createMockRespID?: number;
+  createMockResp?: Response;
+  deleteMockResp?: Response;
+  metadataMockResp?: Response;
+  mkdirMockResp?: Response;
+  moveMockResp?: Response;
+  uploadChunkMockResp?: Response<UploadStatusResp>;
+  uploadChunkMockRespID?: number;
+  uploadStatusMockResp?: Response<UploadStatusResp>;
+  uploadStatusMockRespID?: number;
+  listMockResp?: Response<ListResp>;
+  listHomeMockResp?: Response<ListResp>;
+  listUploadingsMockResp?: Response<ListUploadingsResp>;
+  deleteUploadingMockResp?: Response;
+  addSharingMockResp?: Response;
+  deleteSharingMockResp?: Response;
+  listSharingsMockResp?: Response<ListSharingsResp>;
+  isSharingMockResp?: Response;
+}
 
-  private createMockRespID: number = 0;
+export const resps = {
-  private createMockResps: Array<Promise<Response>>;
+  createMockResp: { status: 200, statusText: "", data: {} },
-  private deleteMockResp: Promise<Response>;
+  deleteMockResp: { status: 200, statusText: "", data: {} },
-  private metadataMockResp: Promise<Response>;
+  metadataMockResp: { status: 200, statusText: "", data: {} },
-  private mkdirMockResp: Promise<Response>;
+  mkdirMockResp: { status: 200, statusText: "", data: {} },
-  private moveMockResp: Promise<Response>;
+  moveMockResp: { status: 200, statusText: "", data: {} },
-  private uploadChunkMockResps: Array<Promise<Response<UploadStatusResp>>>;
+  uploadChunkMockResp: {
-  private uploadChunkMockRespID: number = 0;
+    status: 200,
-  private uploadStatusMockResps: Array<Promise<Response<UploadStatusResp>>>;
+    statusText: "",
-  private uploadStatusMockRespID: number = 0;
+    data: {
-  private listMockResp: Promise<Response<ListResp>>;
+      path: "mockPath/file",
-  private listHomeMockResp: Promise<Response<ListResp>>;
+      isDir: false,
-  private listUploadingsMockResp: Promise<Response<ListUploadingsResp>>;
+      fileSize: 5,
-  private deleteUploadingMockResp: Promise<Response>;
+      uploaded: 3,
-  private addSharingMockResp: Promise<Response>;
+    },
-  private deleteSharingMockResp: Promise<Response>;
+  },
-  private listSharingsMockResp: Promise<Response<ListSharingsResp>>;
+  uploadChunkMockRespID: 0,
-  private isSharingMockResp: Promise<Response>;
+  uploadStatusMockResp: {
+    status: 200,
+    statusText: "",
+    data: {
+      path: "mockPath/file",
+      isDir: false,
+      fileSize: 5,
+      uploaded: 3,
+    },
+  },
+  uploadStatusMockRespID: 0,
+  listMockResp: {
+    status: 200,
+    statusText: "",
+    data: {
+      cwd: "mock_cwd",
+      metadatas: [
+        {
+          name: "mock_file",
+          size: 5,
+          modTime: "0",
+          isDir: false,
+        },
+        {
+          name: "mock_dir",
+          size: 0,
+          modTime: "0",
+          isDir: true,
+        },
+      ],
+    },
+  },
+  listHomeMockResp: {
+    status: 200,
+    statusText: "",
+    data: {
+      cwd: "mock_home/files",
+      metadatas: [
+        {
+          name: "mock_file",
+          size: 5,
+          modTime: "0",
+          isDir: false,
+        },
+        {
+          name: "mock_dir",
+          size: 0,
+          modTime: "0",
+          isDir: true,
+        },
+      ],
+    },
+  },
+  listUploadingsMockResp: {
+    status: 200,
+    statusText: "",
+    data: {
+      uploadInfos: [
+        {
+          realFilePath: "mock_ realFilePath1",
+          size: 5,
+          uploaded: 3,
+        },
+        {
+          realFilePath: "mock_ realFilePath2",
+          size: 5,
+          uploaded: 3,
+        },
+      ],
+    },
+  },
+  deleteUploadingMockResp: { status: 200, statusText: "", data: {} },
+  addSharingMockResp: { status: 200, statusText: "", data: {} },
+  deleteSharingMockResp: { status: 200, statusText: "", data: {} },
+  listSharingsMockResp: {
+    status: 200,
+    statusText: "",
+    data: {
+      sharingDirs: ["mock_sharingfolder1", "mock_sharingfolder2"],
+    },
+  },
+  isSharingMockResp: { status: 200, statusText: "", data: {} },
+};
+export class MockFilesClient {
+  private url: string;
+  private resps: FilesClientResps;
 
   constructor(url: string) {
     this.url = url;
+    this.resps = resps;
   }
 
-  createMock = (resps: Array<Promise<Response>>) => {
+  setMock = (resps: FilesClientResps) => {
-    this.createMockResps = resps;
+    this.resps = resps;
   };
 
-  deleteMock = (resp: Promise<Response>) => {
+  wrapPromise = (resp: any): Promise<any> => {
-    this.deleteMockResp = resp;
+    return new Promise<any>((resolve) => {
-  };
+      resolve(resp);
-
+    });
-  metadataMock = (resp: Promise<Response>) => {
-    this.metadataMockResp = resp;
-  };
-
-  mkdirMock = (resp: Promise<Response>) => {
-    this.mkdirMockResp = resp;
-  };
-
-  moveMock = (resp: Promise<Response>) => {
-    this.moveMockResp = resp;
-  };
-
-  uploadChunkMock = (resps: Array<Promise<Response<UploadStatusResp>>>) => {
-    this.uploadChunkMockResps = resps;
-  };
-
-  uploadStatusMock = (resps: Array<Promise<Response<UploadStatusResp>>>) => {
-    this.uploadStatusMockResps = resps;
-  };
-
-  listMock = (resp: Promise<Response<ListResp>>) => {
-    this.listMockResp = resp;
-  };
-
-  listHomeMock = (resp: Promise<Response<ListResp>>) => {
-    this.listMockResp = resp;
-  };
-
-  listUploadingsMock = (resp: Promise<Response<ListUploadingsResp>>) => {
-    this.listUploadingsMockResp = resp;
-  };
-
-  deleteUploadingMock = (resp: Promise<Response>) => {
-    this.deleteUploadingMockResp = resp;
-  };
-
-  addSharingMock = (resp: Promise<Response>) => {
-    this.addSharingMockResp = resp;
-  };
-
-  deleteSharingMock = (resp: Promise<Response>) => {
-    this.deleteSharingMockResp = resp;
-  };
-
-  listSharingsMock = (resp: Promise<Response>) => {
-    this.listSharingsMockResp = resp;
-  };
-
-  isSharingMock = (resp: Promise<Response>) => {
-    this.isSharingMockResp = resp;
   };
 
   create = (filePath: string, fileSize: number): Promise<Response> => {
-    if (this.createMockRespID < this.createMockResps.length) {
+    return this.wrapPromise(this.resps.createMockResp);
-      return this.createMockResps[this.createMockRespID++];
-    }
-    throw new Error(
-      `this.createMockRespID (${this.createMockRespID}) out of bound: ${this.createMockResps.length}`
-    );
   };
 
   delete = (filePath: string): Promise<Response> => {
-    return this.deleteMockResp;
+    return this.wrapPromise(this.resps.deleteMockResp);
   };
 
   metadata = (filePath: string): Promise<Response> => {
-    return this.metadataMockResp;
+    return this.wrapPromise(this.resps.metadataMockResp);
   };
 
   mkdir = (dirpath: string): Promise<Response> => {
-    return this.mkdirMockResp;
+    return this.wrapPromise(this.resps.mkdirMockResp);
   };
 
   move = (oldPath: string, newPath: string): Promise<Response> => {
-    return this.moveMockResp;
+    return this.wrapPromise(this.resps.moveMockResp);
   };
 
   uploadChunk = (
@@ -122,52 +171,42 @@ export class FilesClient {
     content: string | ArrayBuffer,
     offset: number
   ): Promise<Response<UploadStatusResp>> => {
-    if (this.uploadChunkMockRespID < this.uploadChunkMockResps.length) {
+    return this.wrapPromise(this.resps.uploadChunkMockResp);
-      return this.uploadChunkMockResps[this.uploadChunkMockRespID++];
-    }
-    throw new Error(
-      `this.uploadChunkMockRespID (${this.uploadChunkMockRespID}) out of bound: ${this.uploadChunkMockResps.length}`
-    );
   };
 
   uploadStatus = (filePath: string): Promise<Response<UploadStatusResp>> => {
-    if (this.uploadStatusMockRespID < this.uploadStatusMockResps.length) {
+    return this.wrapPromise(this.resps.uploadStatusMockResp);
-      return this.uploadStatusMockResps[this.uploadStatusMockRespID++];
-    }
-    throw new Error(
-      `this.uploadStatusMockRespID (${this.uploadStatusMockRespID}) out of bound: ${this.uploadStatusMockResps.length}`
-    );
   };
 
   list = (dirPath: string): Promise<Response<ListResp>> => {
-    return this.listMockResp;
+    return this.wrapPromise(this.resps.listMockResp);
   };
 
   listHome = (): Promise<Response<ListResp>> => {
-    return this.listHomeMockResp;
+    return this.wrapPromise(this.resps.listHomeMockResp);
   };
 
   listUploadings = (): Promise<Response<ListUploadingsResp>> => {
-    return this.listUploadingsMockResp;
+    return this.wrapPromise(this.resps.listUploadingsMockResp);
   };
 
   deleteUploading = (filePath: string): Promise<Response<Response>> => {
-    return this.deleteUploadingMockResp;
+    return this.wrapPromise(this.resps.deleteUploadingMockResp);
   };
 
   addSharing = (dirPath: string): Promise<Response> => {
-    return this.addSharingMockResp;
+    return this.wrapPromise(this.resps.addSharingMockResp);
   };
 
   deleteSharing = (dirPath: string): Promise<Response> => {
-    return this.deleteSharingMockResp;
+    return this.wrapPromise(this.resps.deleteSharingMockResp);
   };
 
   listSharings = (): Promise<Response<ListSharingsResp>> => {
-    return this.listSharingsMockResp;
+    return this.wrapPromise(this.resps.listSharingsMockResp);
   };
 
   isSharing = (dirPath: string): Promise<Response> => {
-    return this.isSharingMockResp;
+    return this.wrapPromise(this.resps.isSharingMockResp);
   };
 }

src/client/web/src/client/users_mock.ts

@@ -1,115 +1,157 @@
 // TODO: replace this with jest mocks
 import { Response } from "./";
 
+export interface UsersClientResps {
+  loginMockResp: Response;
+  logoutMockResp: Response;
+  isAuthedMockResp: Response;
+  setPwdMockResp: Response;
+  forceSetPwdMockResp: Response;
+  addUserMockResp: Response;
+  delUserMockResp: Response;
+  listUsersMockResp: Response;
+  addRoleMockResp: Response;
+  delRoleMockResp: Response;
+  listRolesMockResp: Response;
+  selfMockResp: Response;
+  getCaptchaIDMockResp: Response;
+}
+
+export const resps = {
+  loginMockResp: { status: 200, statusText: "", data: {} },
+  logoutMockResp: { status: 200, statusText: "", data: {} },
+  isAuthedMockResp: { status: 200, statusText: "", data: {} },
+  setPwdMockResp: { status: 200, statusText: "", data: {} },
+  forceSetPwdMockResp: { status: 200, statusText: "", data: {} },
+  addUserMockResp: { status: 200, statusText: "", data: {} },
+  delUserMockResp: { status: 200, statusText: "", data: {} },
+  listUsersMockResp: {
+    status: 200,
+    statusText: "",
+    data: {
+      users: [
+        {
+          id: "0",
+          name: "mock_username0",
+          pwd: "mock_pwd0",
+          role: "mock_role0",
+          usedSpace: "128",
+          quota: {
+            spaceLimit: 1024,
+            uploadSpeedLimit: 1024,
+            downloadSpeedLimit: 1024,
+          },
+        },
+        {
+          id: "1",
+          name: "mock_username1",
+          pwd: "mock_pwd1",
+          role: "mock_role1",
+          usedSpace: "256",
+          quota: {
+            spaceLimit: 1024,
+            uploadSpeedLimit: 1024,
+            downloadSpeedLimit: 1024,
+          },
+        },
+      ],
+    },
+  },
+  addRoleMockResp: { status: 200, statusText: "", data: {} },
+  delRoleMockResp: { status: 200, statusText: "", data: {} },
+  listRolesMockResp: {
+    status: 200,
+    statusText: "",
+    data: {
+      roles: ["admin", "users", "visitor"],
+    },
+  },
+  selfMockResp: {
+    status: 200,
+    statusText: "",
+    data: {
+      id: 0,
+      name: "mockUser",
+      role: "admin",
+      usedSpace: "256",
+    },
+  },
+  getCaptchaIDMockResp: {
+    status: 200,
+    statusText: "",
+    data: {
+      id: "mockCaptchaID",
+    },
+  },
+};
 export class MockUsersClient {
   private url: string;
-  private loginMockResp: Promise<Response>;
+  private resps: UsersClientResps;
-  private logoutMockResp: Promise<Response>;
-  private isAuthedMockResp: Promise<Response>;
-  private setPwdMockResp: Promise<Response>;
-  private forceSetPwdMockResp: Promise<Response>;
-  private addUserMockResp: Promise<Response>;
-  private delUserMockResp: Promise<Response>;
-  private listUsersMockResp: Promise<Response>;
-  private addRoleMockResp: Promise<Response>;
-  private delRoleMockResp: Promise<Response>;
-  private listRolesMockResp: Promise<Response>;
-  private selfMockResp: Promise<Response>;
-  private getCaptchaIDMockResp: Promise<Response>;
 
   constructor(url: string) {
     this.url = url;
+    this.resps = resps;
   }
 
-  loginMock = (resp: Promise<Response>) => {
+  setMock = (resps: UsersClientResps) => {
-    this.loginMockResp = resp;
+    this.resps = resps;
   };
-  logoutMock = (resp: Promise<Response>) => {
+
-    this.logoutMockResp = resp;
+  wrapPromise = (resp: any): Promise<any> => {
-  };
+    return new Promise<any>((resolve) => {
-  isAuthedMock = (resp: Promise<Response>) => {
+      resolve(resp);
-    this.isAuthedMockResp = resp;
+    });
-  };
-  setPwdMock = (resp: Promise<Response>) => {
-    this.setPwdMockResp = resp;
-  };
-  forceSetPwdMock = (resp: Promise<Response>) => {
-    this.forceSetPwdMockResp = resp;
-  };
-  addUserMock = (resp: Promise<Response>) => {
-    this.addUserMockResp = resp;
-  };
-  delUserMock = (resp: Promise<Response>) => {
-    this.delUserMockResp = resp;
-  };
-  listUsersMock = (resp: Promise<Response>) => {
-    this.listUsersMockResp = resp;
-  };
-  addRoleMock = (resp: Promise<Response>) => {
-    this.addRoleMockResp = resp;
-  };
-  delRoleMock = (resp: Promise<Response>) => {
-    this.delRoleMockResp = resp;
-  };
-  listRolesMock = (resp: Promise<Response>) => {
-    this.listRolesMockResp = resp;
-  };
-  selfMock = (resp: Promise<Response>) => {
-    this.selfMockResp = resp;
-  };
-  getCaptchaIDMock = (resp: Promise<Response>) => {
-    this.getCaptchaIDMockResp = resp;
   };
 
   login = (user: string, pwd: string): Promise<Response> => {
-    return this.loginMockResp;
+    return this.wrapPromise(this.resps.loginMockResp);
   };
 
   logout = (): Promise<Response> => {
-    return this.logoutMockResp;
+    return this.wrapPromise(this.resps.logoutMockResp);
   };
 
   isAuthed = (): Promise<Response> => {
-    return this.isAuthedMockResp;
+    return this.wrapPromise(this.resps.isAuthedMockResp);
   };
 
   setPwd = (oldPwd: string, newPwd: string): Promise<Response> => {
-    return this.setPwdMockResp;
+    return this.wrapPromise(this.resps.setPwdMockResp);
   };
 
   forceSetPwd = (userID: string, newPwd: string): Promise<Response> => {
-    return this.forceSetPwdMockResp;
+    return this.wrapPromise(this.resps.forceSetPwdMockResp);
   };
 
   addUser = (name: string, pwd: string, role: string): Promise<Response> => {
-    return this.addUserMockResp;
+    return this.wrapPromise(this.resps.addUserMockResp);
   };
 
   delUser = (userID: string): Promise<Response> => {
-    return this.delUserMockResp;
+    return this.wrapPromise(this.resps.delUserMockResp);
   };
 
   listUsers = (): Promise<Response> => {
-    return this.listUsersMockResp;
+    return this.wrapPromise(this.resps.listUsersMockResp);
   };
 
   addRole = (role: string): Promise<Response> => {
-    return this.addRoleMockResp;
+    return this.wrapPromise(this.resps.addRoleMockResp);
   };
 
   delRole = (role: string): Promise<Response> => {
-    return this.delRoleMockResp;
+    return this.wrapPromise(this.resps.delRoleMockResp);
   };
 
   listRoles = (): Promise<Response> => {
-    return this.listRolesMockResp;
+    return this.wrapPromise(this.resps.listRolesMockResp);
   };
 
   self = (): Promise<Response> => {
-    return this.selfMockResp;
+    return this.wrapPromise(this.resps.selfMockResp);
   };
 
   getCaptchaID = (): Promise<Response> => {
-    return this.getCaptchaIDMockResp;
+    return this.wrapPromise(this.resps.getCaptchaIDMockResp);
   };
 }

src/client/web/src/components/__test__/browser.test.tsx

@@ -1,283 +1,121 @@
-import * as React from "react";
+import { mock, instance, verify, when, anything } from "ts-mockito";
-import { List, Map } from "immutable";
+import { List } from "immutable";
-import { mock, instance, anyString, anything, when, verify } from "ts-mockito";
 
-import { ICoreState, newWithWorker, initState } from "../core_state";
-import {
-  makePromise,
-  makeNumberResponse,
-  mockUpdate,
-  addMockUpdate,
-  mockFileList,
-} from "../../test/helpers";
 import { Browser } from "../browser";
-// import { Updater, setUpdater } from "../browser.updater";
+import { ICoreState, newWithWorker } from "../core_state";
+import { updater } from "../state_updater";
+import { MockWorker } from "../../worker/interface";
+import { MockUsersClient, resps as usersResps } from "../../client/users_mock";
+import { MockFilesClient, resps as filesResps } from "../../client/files_mock";
+import { mockFileList } from "../../test/helpers";
 
-import { updater, Updater, setUpdater } from "../state_updater";
+describe("Browser", () => {
-import { MockUsersClient } from "../../client/users_mock";
+  const initBrowser = (): any => {
-import { UsersClient } from "../../client/users";
+    const mockWorkerClass = mock(MockWorker);
-import { FilesClient } from "../../client/files";
+    const mockWorker = instance(mockWorkerClass);
-import { FilesClient as MockFilesClient } from "../../client/files_mock";
-import { MetadataResp, UploadInfo } from "../../client";
-import { MockWorker, UploadEntry } from "../../worker/interface";
-import { UploadMgr, setUploadMgr } from "../../worker/upload_mgr";
 
-// describe("Browser", () => {
+    const coreState = newWithWorker(mockWorker);
-//   const mockWorkerClass = mock(MockWorker);
+    const usersCl = new MockUsersClient("");
-//   const mockWorker = instance(mockWorkerClass);
+    const filesCl = new MockFilesClient("");
 
-//   test("Updater: addUploads: add each files to UploadMgr", async () => {
+    updater().init(coreState);
-//     let coreState = initState();
+    updater().setClients(usersCl, filesCl);
-//     const UploadMgrClass = mock(UploadMgr);
-//     const uploadMgr = instance(UploadMgrClass);
-//     setUploadMgr(uploadMgr);
 
-//     const filePaths = ["./file1", "./file2"];
+    const browser = new Browser({
-//     const fileList = mockFileList(filePaths);
+      dirPath: coreState.browser.dirPath,
-//     // const updater = new Updater();
+      isSharing: coreState.browser.isSharing,
-//     updater().setUploadings = (infos: Map<string, UploadEntry>) => {};
+      items: coreState.browser.items,
-//     updater().init(coreState);
+      uploadings: coreState.browser.uploadings,
+      sharings: coreState.browser.sharings,
+      uploadFiles: coreState.browser.uploadFiles,
+      uploadValue: coreState.browser.uploadValue,
+      isVertical: coreState.browser.isVertical,
+      update: (updater: (prevState: ICoreState) => ICoreState) => {},
+    });
 
-//     updater().addUploads(fileList);
+    return {
+      browser,
+      usersCl,
+      filesCl,
+    };
+  };
 
-//     // it seems that new File will do some file path escaping, so just check call time here
+  test("addUploads", async () => {
-//     verify(UploadMgrClass.add(anything(), anything())).times(filePaths.length);
+    const { browser, usersCl, filesCl } = initBrowser();
-//     // filePaths.forEach((filePath, i) => {
-//     //   verify(UploadMgrClass.add(anything(), filePath)).once();
-//     // });
-//   });
 
-//   test("Updater: deleteUploads: call UploadMgr and api to delete", async () => {
+    const newSharings = [
-//     let coreState = initState();
+      "mock_sharingfolder1",
-//     const UploadMgrClass = mock(UploadMgr);
+      "mock_sharingfolder2",
-//     const uploadMgr = instance(UploadMgrClass);
+      "newSharing",
-//     setUploadMgr(uploadMgr);
+    ];
 
-//     // const updater = new Updater();
+    filesCl.setMock({
-//     const filesClientClass = mock(FilesClient);
+      ...filesResps,
-//     when(filesClientClass.deleteUploading(anyString())).thenResolve({
+      listSharingsMockResp: {
-//       status: 200,
+        status: 200,
-//       statusText: "",
+        statusText: "",
-//       data: "",
+        data: {
-//     });
+          sharingDirs: newSharings,
-//     const filesClient = instance(filesClientClass);
+        },
-//     const usersClientClass = mock(UsersClient);
+      },
-//     const usersClient = instance(usersClientClass);
+    });
-//     updater().init(coreState);
-//     updater().setClients(usersClient, filesClient);
 
-//     const filePath = "./path/file";
+    await browser.addSharing();
-//     updater().deleteUpload(filePath);
 
-//     verify(filesClientClass.deleteUploading(filePath)).once();
+    // TODO: check addSharing's input
-//     verify(UploadMgrClass.delete(filePath)).once();
+    expect(updater().props.browser.isSharing).toEqual(true);
-//   });
+    expect(updater().props.browser.sharings).toEqual(List(newSharings));
+  });
 
-//   test("Updater: delete", async () => {
+  test("deleteUploads", async () => {
-//     const tests = [
+    const { browser, usersCl, filesCl } = initBrowser();
-//       {
-//         dirPath: "path/path2",
-//         items: [
-//           {
-//             name: "file",
-//             size: 1,
-//             modTime: "1-1",
-//             isDir: false,
-//           },
-//           {
-//             name: "folder",
-//             size: 0,
-//             modTime: "1-1",
-//             isDir: true,
-//           },
-//         ],
-//         selected: {
-//           file: true,
-//         },
-//         listResp: {
-//           status: 200,
-//           statusText: "",
-//           data: {
-//             metadatas: [
-//               {
-//                 name: "folder",
-//                 size: 0,
-//                 modTime: "1-1",
-//                 isDir: true,
-//               },
-//             ],
-//           },
-//         },
-//         filePath: "path/file",
-//       },
-//     ];
 
-//     const usersClient = new MockUsersClient("");
+    const newSharings = ["mock_sharingfolder1", "mock_sharingfolder2"];
-//     const filesClient = new MockFilesClient("");
-//     for (let i = 0; i < tests.length; i++) {
-//       const tc = tests[i];
-//       // const updater = new Updater();
-//       updater().setClients(usersClient, filesClient);
-//       filesClient.listMock(makePromise(tc.listResp));
-//       filesClient.deleteMock(makeNumberResponse(200));
-//       const coreState = newWithWorker(mockWorker);
-//       updater().init(coreState);
 
-//       await updater().delete(
+    filesCl.setMock({
-//         List<string>(tc.dirPath.split("/")),
+      ...filesResps,
-//         List<MetadataResp>(tc.items),
+      listSharingsMockResp: {
-//         Map(tc.selected)
+        status: 200,
-//       );
+        statusText: "",
+        data: {
+          sharingDirs: newSharings,
+        },
+      },
+    });
 
-//       const newState = updater().updateBrowser(coreState);
+    await browser.deleteSharing();
 
-//       // TODO: check inputs of delete
+    // TODO: check delSharing's input
-//       newState.panel.browser.items.forEach((item, i) => {
+    expect(updater().props.browser.isSharing).toEqual(false);
-//         expect(item.name).toEqual(tc.listResp.data.metadatas[i].name);
+    expect(updater().props.browser.sharings).toEqual(List(newSharings));
-//         expect(item.size).toEqual(tc.listResp.data.metadatas[i].size);
+  });
-//         expect(item.modTime).toEqual(tc.listResp.data.metadatas[i].modTime);
-//         expect(item.isDir).toEqual(tc.listResp.data.metadatas[i].isDir);
-//       });
-//     }
-//   });
 
-//   test("Updater: setItems", async () => {
+  test("chdir", async () => {
-//     const tests = [
+    const { browser, usersCl, filesCl } = initBrowser();
-//       {
-//         listResp: {
-//           status: 200,
-//           statusText: "",
-//           data: {
-//             metadatas: [
-//               {
-//                 name: "file",
-//                 size: 1,
-//                 modTime: "1-1",
-//                 isDir: false,
-//               },
-//               {
-//                 name: "folder",
-//                 size: 0,
-//                 modTime: "1-1",
-//                 isDir: true,
-//               },
-//             ],
-//           },
-//         },
-//         filePath: "path/file",
-//       },
-//     ];
 
-//     const usersClient = new MockUsersClient("");
+    const newSharings = ["mock_sharingfolder1", "mock_sharingfolder2"];
-//     const filesClient = new MockFilesClient("");
+    const newCwd = List(["newPos", "subFolder"]);
 
-//     for (let i = 0; i < tests.length; i++) {
+    filesCl.setMock({
-//       const tc = tests[i];
+      ...filesResps,
+      listSharingsMockResp: {
+        status: 200,
+        statusText: "",
+        data: {
+          sharingDirs: newSharings,
+        },
+      },
+    });
 
-//       filesClient.listMock(makePromise(tc.listResp));
+    await browser.chdir(newCwd);
-//       updater().setClients(usersClient, filesClient);
-//       const coreState = newWithWorker(mockWorker);
-//       updater().init(coreState);
 
-//       await updater().setItems(List<string>(tc.filePath.split("/")));
+    expect(updater().props.browser.dirPath).toEqual(newCwd);
-//       const newState = updater().updateBrowser(coreState);
+    expect(updater().props.browser.isSharing).toEqual(true);
-
+    expect(updater().props.browser.sharings).toEqual(
-//       newState.panel.browser.items.forEach((item, i) => {
+      List(filesResps.listSharingsMockResp.data.sharingDirs)
-//         expect(item.name).toEqual(tc.listResp.data.metadatas[i].name);
+    );
-//         expect(item.size).toEqual(tc.listResp.data.metadatas[i].size);
+    expect(updater().props.browser.items).toEqual(
-//         expect(item.modTime).toEqual(tc.listResp.data.metadatas[i].modTime);
+      List(filesResps.listHomeMockResp.data.metadatas)
-//         expect(item.isDir).toEqual(tc.listResp.data.metadatas[i].isDir);
+    );
-//       });
+  });
-//     }
+});
-//   });
-
-//   test("Updater: moveHere", async () => {
-//     const tests = [
-//       {
-//         dirPath1: "path/path1",
-//         dirPath2: "path/path2",
-//         selected: {
-//           file1: true,
-//           file2: true,
-//         },
-//         listResp: {
-//           status: 200,
-//           statusText: "",
-//           data: {
-//             metadatas: [
-//               {
-//                 name: "file1",
-//                 size: 1,
-//                 modTime: "1-1",
-//                 isDir: false,
-//               },
-//               {
-//                 name: "file2",
-//                 size: 2,
-//                 modTime: "1-1",
-//                 isDir: false,
-//               },
-//             ],
-//           },
-//         },
-//       },
-//     ];
-
-//     const usersClient = new MockUsersClient("");
-//     const filesClient = new MockFilesClient("");
-//     for (let i = 0; i < tests.length; i++) {
-//       const tc = tests[i];
-
-//       filesClient.listMock(makePromise(tc.listResp));
-//       filesClient.moveMock(makeNumberResponse(200));
-//       updater().setClients(usersClient, filesClient);
-
-//       const coreState = newWithWorker(mockWorker);
-//       updater().init(coreState);
-//       await updater().moveHere(tc.dirPath1, tc.dirPath2, Map(tc.selected));
-
-//       const newState = updater().updateBrowser(coreState);
-
-//       // TODO: check inputs of move
-//       newState.panel.browser.items.forEach((item, i) => {
-//         expect(item.name).toEqual(tc.listResp.data.metadatas[i].name);
-//         expect(item.size).toEqual(tc.listResp.data.metadatas[i].size);
-//         expect(item.modTime).toEqual(tc.listResp.data.metadatas[i].modTime);
-//         expect(item.isDir).toEqual(tc.listResp.data.metadatas[i].isDir);
-//       });
-//     }
-//   });
-
-//   test("Browser: deleteUpload: tell uploader to deleteUpload and refreshUploadings", async () => {
-//     let coreState = initState();
-//     addMockUpdate(coreState.panel.browser);
-//     const component = new Browser(coreState.panel.browser);
-//     const UpdaterClass = mock(Updater);
-//     const mockUpdater = instance(UpdaterClass);
-//     setUpdater(mockUpdater);
-//     when(UpdaterClass.setItems(anything())).thenResolve();
-//     when(UpdaterClass.deleteUpload(anyString())).thenResolve(true);
-//     when(UpdaterClass.refreshUploadings()).thenResolve(true);
-
-//     const filePath = "filePath";
-//     await component.deleteUpload(filePath);
-
-//     verify(UpdaterClass.deleteUpload(filePath)).once();
-//     verify(UpdaterClass.refreshUploadings()).once();
-//   });
-
-//   test("Browser: stopUploading: tell updater to stopUploading", async () => {
-//     let coreState = initState();
-//     addMockUpdate(coreState.panel.browser);
-//     const component = new Browser(coreState.panel.browser);
-//     const UpdaterClass = mock(Updater);
-//     const mockUpdater = instance(UpdaterClass);
-//     setUpdater(mockUpdater);
-//     when(UpdaterClass.stopUploading(anyString())).thenReturn();
-
-//     const filePath = "filePath";
-//     component.stopUploading(filePath);
-
-//     verify(UpdaterClass.stopUploading(filePath)).once();
-//   });
-// });

src/client/web/src/components/__test__/pane_login.test.tsx

@@ -1,64 +1,62 @@
+import { List, Set, Map } from "immutable";
 import { mock, instance } from "ts-mockito";
 
-import { newWithWorker } from "../core_state";
+import { User } from "../../client";
+import { AuthPane } from "../pane_login";
+import { ICoreState, newWithWorker } from "../core_state";
 import { updater } from "../state_updater";
-import { MockUsersClient } from "../../client/users_mock";
-import { FilesClient } from "../../client/files_mock";
-import { Response } from "../../client";
 import { MockWorker } from "../../worker/interface";
+import { MockUsersClient, resps as usersResps } from "../../client/users_mock";
+import { MockFilesClient, resps as filesResps } from "../../client/files_mock";
 
-describe("AuthPane", () => {
+describe("Login", () => {
-  const mockWorkerClass = mock(MockWorker);
+  test("login", async () => {
-  const mockWorker = instance(mockWorkerClass);
+    const mockWorkerClass = mock(MockWorker);
+    const mockWorker = instance(mockWorkerClass);
 
-  const makePromise = (ret: any): Promise<any> => {
+    const coreState = newWithWorker(mockWorker);
-    return new Promise<any>((resolve) => {
+    const pane = new AuthPane({
-      resolve(ret);
+      authed: coreState.login.authed,
+      captchaID: coreState.login.captchaID,
+      update: (updater: (prevState: ICoreState) => ICoreState) => {},
     });
-  };
+
-  const makeNumberResponse = (status: number): Promise<Response> => {
+    const usersCl = new MockUsersClient("");
-    return makePromise({
+    const filesCl = new MockFilesClient("");
-      status: status,
+    updater().init(coreState);
-      statusText: "",
+    updater().setClients(usersCl, filesCl);
-      data: {},
+
+    await pane.login();
+
+    // TODO: state is not checked
+
+    // login
+    expect(updater().props.login).toEqual({
+      authed: true,
+      captchaID: "",
     });
-  };
 
-  test("Updater-initIsAuthed", async () => {
+    // panes
-    const tests = [
+    expect(updater().props.panes).toEqual({
-      {
+      userRole: "admin",
-        loginStatus: 200,
+      displaying: "",
-        logoutStatus: 200,
+      paneNames: Set(["settings", "login", "admin"]),
-        isAuthedStatus: 200,
+    });
-        setPwdStatus: 200,
-        isAuthed: true,
-      },
-      {
-        loginStatus: 200,
-        logoutStatus: 200,
-        isAuthedStatus: 500,
-        setPwdStatus: 200,
-        isAuthed: false,
-      },
-    ];
 
-    const usersClient = new MockUsersClient("");
+    // admin
-    const filesClient = new FilesClient("");
+    let usersMap = Map({});
-    for (let i = 0; i < tests.length; i++) {
+    usersResps.listUsersMockResp.data.users.forEach((user: User) => {
-      const tc = tests[i];
+      usersMap = usersMap.set(user.name, user);
-
+    });
-      usersClient.loginMock(makeNumberResponse(tc.loginStatus));
+    let roles = Set<string>();
-      usersClient.logoutMock(makeNumberResponse(tc.logoutStatus));
+    Object.keys(usersResps.listRolesMockResp.data.roles).forEach(
-      usersClient.isAuthedMock(makeNumberResponse(tc.isAuthedStatus));
+      (role: string) => {
-      usersClient.setPwdMock(makeNumberResponse(tc.setPwdStatus));
+        roles = roles.add(role);
-
+      }
-      const coreState = newWithWorker(mockWorker);
+    );
-      updater().setClients(usersClient, filesClient);
+    expect(updater().props.admin).toEqual({
-      updater().init(coreState);
+      users: usersMap,
-      await updater().initIsAuthed();
+      roles: roles,
-      const newState = updater().updateLogin(coreState);
+    });
-
-      expect(newState.login.authed).toEqual(tc.isAuthed);
-    }
   });
 });

src/client/web/src/components/__test__/panes.test.tsx

@@ -1,55 +1,31 @@
-import { Set } from "immutable";
+import { mock, instance } from "ts-mockito";
 
-import { ICoreState, initState } from "../core_state";
 import { Panes } from "../panes";
-import { mockUpdate } from "../../test/helpers";
+import { ICoreState, newWithWorker } from "../core_state";
 import { updater } from "../state_updater";
+import { MockWorker } from "../../worker/interface";
 
 describe("Panes", () => {
-  test("Panes: closePane", async () => {
+  test("closePane", async () => {
-    interface TestCase {
+    const mockWorkerClass = mock(MockWorker);
-      preState: ICoreState;
+    const mockWorker = instance(mockWorkerClass);
-      postState: ICoreState;
-    }
 
-    const tcs: any = [
+    const coreState = newWithWorker(mockWorker);
-      {
+    const panes = new Panes({
-        preState: {
+        panes: coreState.panes,
-          panes: {
+        admin: coreState.admin,
-            displaying: "settings",
+        login: coreState.login,
-            paneNames: Set<string>(["settings", "login"]),
+        update: (updater: (prevState: ICoreState) => ICoreState) => {},
-            update: mockUpdate,
+    });
-          },
-        },
-        postState: {
-          panes: {
-            displaying: "",
-            paneNames: Set<string>(["settings", "login"]),
-            update: mockUpdate,
-          },
-        },
-      },
-    ];
 
-    const setState = (patch: any, state: ICoreState): ICoreState => {
+    updater().init(coreState);
-      state.panes = patch.panes;
-      return state;
-    };
 
-    tcs.forEach((tc: TestCase) => {
+    panes.closePane();
-      const preState = setState(tc.preState, initState());
-      const postState = setState(tc.postState, initState());
 
-      const component = new Panes({
+    expect(updater().props.panes).toEqual({
-        panes: preState.panes,
+      userRole: coreState.panes.userRole,
-        admin: preState.admin,
+      displaying: "",
-        login: preState.login,
+      paneNames: coreState.panes.paneNames,
-        update: mockUpdate,
-      });
-      updater().init(preState);
-
-      component.closePane();
-      expect(updater().props).toEqual(postState);
     });
   });
 });

src/client/web/src/components/__test__/state_mgr.test.tsx

@@ -0,0 +1,73 @@
+import { List, Set, Map } from "immutable";
+import { mock, instance } from "ts-mockito";
+
+import { StateMgr } from "../state_mgr";
+import { User } from "../../client";
+import { MockFilesClient, resps as filesResps } from "../../client/files_mock";
+import { MockUsersClient, resps as usersResps } from "../../client/users_mock";
+import { ICoreState, newWithWorker } from "../core_state";
+import { MockWorker } from "../../worker/interface";
+
+describe("State Manager", () => {
+  test("initUpdater", async () => {
+    const usersCl = new MockUsersClient("");
+    const filesCl = new MockFilesClient("");
+
+    const mockWorkerClass = mock(MockWorker);
+    const mockWorker = instance(mockWorkerClass);
+
+    const mgr = new StateMgr({}); // it will call initUpdater
+    mgr.setUsersClient(usersCl);
+    mgr.setFilesClient(filesCl);
+
+    // TODO: depress warning
+    mgr.update = (apply: (prevState: ICoreState) => ICoreState): void => {
+        // no op
+    }; 
+
+    const coreState = newWithWorker(mockWorker);
+    await mgr.initUpdater(coreState);
+
+    // browser
+    expect(coreState.browser.dirPath.join("/")).toEqual("mock_home/files");
+    expect(coreState.browser.isSharing).toEqual(true);
+    expect(coreState.browser.sharings).toEqual(
+      List(filesResps.listSharingsMockResp.data.sharingDirs)
+    );
+    expect(coreState.browser.uploadings).toEqual(
+      List(filesResps.listUploadingsMockResp.data.uploadInfos)
+    );
+    expect(coreState.browser.items).toEqual(
+      List(filesResps.listHomeMockResp.data.metadatas)
+    );
+
+    // panes
+    expect(coreState.panes).toEqual({
+      userRole: "admin",
+      displaying: "browser",
+      paneNames: Set(["settings", "login", "admin"]),
+    });
+
+    // login
+    expect(coreState.login).toEqual({
+      authed: false,
+      captchaID: "mockCaptchaID",
+    });
+
+    // admin
+    let usersMap = Map({});
+    usersResps.listUsersMockResp.data.users.forEach((user: User) => {
+      usersMap = usersMap.set(user.name, user);
+    });
+    let roles = Set<string>();
+    Object.keys(usersResps.listRolesMockResp.data.roles).forEach(
+      (role: string) => {
+        roles = roles.add(role);
+      }
+    );
+    expect(coreState.admin).toEqual({
+      users: usersMap,
+      roles: roles,
+    });
+  });
+});

src/client/web/src/components/browser.tsx

@@ -6,10 +6,7 @@ import FileSize from "filesize";
 import { alertMsg, comfirmMsg } from "../common/env";
 import { updater } from "./state_updater";
 import { ICoreState } from "./core_state";
-import {
+import { MetadataResp, UploadInfo } from "../client";
-  MetadataResp,
-  UploadInfo,
-} from "../client";
 import { Up } from "../worker/upload_mgr";
 import { UploadEntry } from "../worker/interface";
 
@@ -181,12 +178,12 @@ export class Browser extends React.Component<Props, State, {}> {
     this.chdir(this.props.dirPath.push(childDirName));
   };
 
-  chdir = (dirPath: List<string>) => {
+  chdir = async (dirPath: List<string>) => {
     if (dirPath === this.props.dirPath) {
       return;
     }
 
-    updater()
+    return updater()
       .setItems(dirPath)
       .then(() => {
         return updater().listSharings();
@@ -238,8 +235,8 @@ export class Browser extends React.Component<Props, State, {}> {
     });
   };
 
-  addSharing = () => {
+  addSharing = async () => {
-    updater()
+    return updater()
       .addSharing()
       .then((ok) => {
         if (!ok) {
@@ -254,8 +251,8 @@ export class Browser extends React.Component<Props, State, {}> {
       });
   };
 
-  deleteSharing = (dirPath: string) => {
+  deleteSharing = async (dirPath: string) => {
-    updater()
+    return updater()
       .deleteSharing(dirPath)
       .then((ok) => {
         if (!ok) {
@@ -270,8 +267,8 @@ export class Browser extends React.Component<Props, State, {}> {
       });
   };
 
-  listSharings = () => {
+  listSharings = async () => {
-    updater()
+    return updater()
       .listSharings()
       .then((ok) => {
         if (ok) {

src/client/web/src/components/core_state.ts

@@ -30,7 +30,7 @@ export function newWithWorker(worker: IWorker): ICoreState {
 }
 
 export function newState(): ICoreState {
-  const worker = Worker == null ? new FgWorker() : new BgWorker();
+  const worker = window.Worker == null ? new FgWorker() : new BgWorker();
   initUploadMgr(worker);
 
   return initState();

src/client/web/src/components/pane_login.tsx

@@ -50,8 +50,8 @@ export class AuthPane extends React.Component<Props, State, {}> {
       });
   };
 
-  login = () => {
+  login = async () => {
-    updater()
+    return updater()
       .login(
         this.state.user,
         this.state.pwd,
@@ -72,6 +72,7 @@ export class AuthPane extends React.Component<Props, State, {}> {
           this.setState({ user: "", pwd: "" });
           alert("Failed to login.");
         }
+
       })
       .then(() => {
         return updater().refreshUploadings();
@@ -84,6 +85,23 @@ export class AuthPane extends React.Component<Props, State, {}> {
       .then(() => {
         return updater().listSharings();
       })
+      .then(() => {
+        return updater().self();
+      })
+      .then(() => {
+        // TODO: should rely on props to get userRole
+        if (updater().props.panes.userRole === "admin") {
+          // TODO: remove hardcode
+          return updater().listRoles();
+        }
+      })
+      .then(() => {
+        // TODO: should rely on props to get userRole
+        if (updater().props.panes.userRole === "admin") {
+          // TODO: remove hardcode
+          return updater().listUsers();
+        }
+      })
       .then((_: boolean) => {
         this.update(updater().updateBrowser);
       });

src/client/web/src/components/state_mgr.tsx

@@ -18,7 +18,6 @@ export class StateMgr extends React.Component<Props, State, {}> {
   constructor(p: Props) {
     super(p);
     this.state = newState();
-    this.initUpdater(this.state);
   }
 
   setUsersClient = (client: IUsersClient) => {
@@ -29,12 +28,16 @@ export class StateMgr extends React.Component<Props, State, {}> {
     this.filesClient = client;
   };
 
-  initUpdater = (state: ICoreState) => {
+  initUpdater = (state: ICoreState): Promise<void> => {
     updater().init(state);
-    updater().setClients(new UsersClient(""), new FilesClient(""));
+    if (this.usersClient == null || this.filesClient == null) {
+      console.error("updater's clients are not inited");
+      return;
+    }
+    updater().setClients(this.usersClient, this.filesClient);
 
     const params = new URLSearchParams(document.location.search.substring(1));
-    updater()
+    return updater()
       .getCaptchaID()
       .then((ok: boolean) => {
         if (!ok) {
@@ -42,10 +45,10 @@ export class StateMgr extends React.Component<Props, State, {}> {
         } else {
           this.update(updater().updateLogin);
         }
-      });
+      })
-
+      .then(() => {
-    updater()
+        return updater().refreshUploadings();
-      .refreshUploadings()
+      })
       .then(() => {
         const dir = params.get("dir");
         if (dir != null && dir !== "") {
@@ -84,6 +87,7 @@ export class StateMgr extends React.Component<Props, State, {}> {
       })
       .then(() => {
         this.update(updater().updatePanes);
+        this.update(updater().updateAdmin);
       });
   };
 

src/client/web/src/worker/__test__/uploader.test.tsx

@@ -1,152 +0,0 @@
-import { FileUploader } from "../uploader";
-import { FilesClient } from "../../client/files_mock";
-import { makePromise } from "../../test/helpers";
-
-describe("Uploader", () => {
-  const content = ["123456"];
-  const filePath = "mock/file";
-  const blob = new Blob(content);
-  const fileSize = blob.size;
-  const file = new File(content, filePath);
-
-  const makeCreateResp = (status: number): Promise<any> => {
-    return makePromise({
-      status: status,
-      statusText: "",
-      data: {
-        path: filePath,
-        fileSize: fileSize,
-      },
-    });
-  };
-
-  const makeStatusResp = (status: number, uploaded: number): Promise<any> => {
-    return makePromise({
-      status: status,
-      statusText: "",
-      data: {
-        path: filePath,
-        isDir: false,
-        fileSize: fileSize,
-        uploaded: uploaded,
-      },
-    });
-  };
-
-  interface statusResp {
-    status: number;
-    uploaded: number;
-  }
-
-  interface TestCase {
-    createResps: Array<number>;
-    uploadChunkResps: Array<any>;
-    uploadStatusResps: Array<any>;
-    result: boolean;
-  }
-
-  test("test start and upload method", async () => {
-    const testCases: Array<TestCase> = [
-      {
-        // fail to create file 4 times
-        createResps: [500, 500, 500, 500],
-        uploadChunkResps: [],
-        uploadStatusResps: [],
-        result: false,
-      },
-      {
-        // fail to get status
-        createResps: [200],
-        uploadChunkResps: [{ status: 500, uploaded: 0 }],
-        uploadStatusResps: [{ status: 600, uploaded: 0 }],
-        result: false,
-      },
-      {
-        // upload ok
-        createResps: [200],
-        uploadChunkResps: [
-          { status: 200, uploaded: 0 },
-          { status: 200, uploaded: 1 },
-          { status: 200, uploaded: fileSize },
-        ],
-        uploadStatusResps: [],
-        result: true,
-      },
-      {
-        // fail once
-        createResps: [200],
-        uploadChunkResps: [
-          { status: 200, uploaded: 0 },
-          { status: 500, uploaded: 1 },
-          { status: 200, uploaded: fileSize },
-        ],
-        uploadStatusResps: [{ status: 200, uploaded: 1 }],
-        result: true,
-      },
-      {
-        // fail twice
-        createResps: [500, 500],
-        uploadChunkResps: [],
-        uploadStatusResps: [],
-        result: false,
-      },
-      {
-        // fail twice
-        createResps: [500, 200],
-        uploadChunkResps: [
-          { status: 200, uploaded: 0 },
-          { status: 500, uploaded: 1 },
-          { status: 500, uploaded: 1 },
-          { status: 200, uploaded: fileSize },
-        ],
-        uploadStatusResps: [
-          { status: 500, uploaded: 1 },
-          { status: 500, uploaded: 1 },
-        ],
-        result: true,
-      },
-      {
-        // other errors
-        createResps: [500, 200],
-        uploadChunkResps: [
-          { status: 601, uploaded: 0 },
-          { status: 408, uploaded: fileSize },
-          { status: 200, uploaded: 1 },
-          { status: 200, uploaded: fileSize },
-        ],
-        uploadStatusResps: [
-          { status: 500, uploaded: 1 },
-          { status: 500, uploaded: 1 },
-        ],
-        result: true,
-      },
-    ];
-
-    for (let i = 0; i < testCases.length; i++) {
-      const tc = testCases[i];
-      const mockCb = (
-        filePath: string,
-        uploaded: number,
-        done: boolean,
-        err: string
-      ):void => {}; 
-      const uploader = new FileUploader(file, filePath, mockCb);
-      const mockClient = new FilesClient("");
-
-      const createResps = tc.createResps.map((resp) => makeCreateResp(resp));
-      mockClient.createMock(createResps);
-      const uploadChunkResps = tc.uploadChunkResps.map((resp) =>
-        makeStatusResp(resp.status, resp.uploaded)
-      );
-      mockClient.uploadChunkMock(uploadChunkResps);
-      const uploadStatusResps = tc.uploadStatusResps.map((resp) =>
-        makeStatusResp(resp.status, resp.uploaded)
-      );
-      mockClient.uploadStatusMock(uploadStatusResps);
-      uploader.setClient(mockClient);
-
-      const ret = await uploader.start();
-      expect(ret).toEqual(tc.result);
-    }
-  });
-});

src/userstore/user_store.go

@@ -34,7 +34,7 @@ func IsReachedLimitErr(err error) bool {
 }
 
 type Quota struct {
-	SpaceLimit         int64 `json:"spaceLimit,space"`
+	SpaceLimit         int64 `json:"spaceLimit,string"`
 	UploadSpeedLimit   int   `json:"uploadSpeedLimit"`
 	DownloadSpeedLimit int   `json:"downloadSpeedLimit"`
 }