@lifeready/core 1.0.1 → 1.0.3

package/src/lib/record/record.service.spec.ts

@@ -1,598 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { RecordService } from './record.service';
-import { loginTestUser } from '../auth/life-ready-auth.service.spec';
-import { CategoryService } from '../category/category.service';
-import { RecordAttachmentService } from '../record/record-attachment.service';
-import { VaultCategory, Category } from '../category/category.types';
-import { LrRecord } from './record.types';
-import { environment } from 'projects/lr-auth-app/src/environments/environment';
-import {
-  lrConfigureTestingModule,
-  lrExpectAsyncThrow,
-  lrit,
-} from '../_common/tests';
-import { CurrentUser } from '../auth/auth.types';
-
-const TIMEOUT = 1000 * 60 * 10;
-
-describe('RecordService', () => {
-  let recordService: RecordService;
-  let recordAttachmentService: RecordAttachmentService;
-  let categoryService: CategoryService;
-  let user: CurrentUser;
-
-  beforeEach(async () => {
-    lrConfigureTestingModule();
-    recordService = TestBed.inject(RecordService);
-    categoryService = TestBed.inject(CategoryService);
-    recordAttachmentService = TestBed.inject(RecordAttachmentService);
-    user = await loginTestUser();
-  }, TIMEOUT);
-
-  function categoryContent(name) {
-    return {
-      name,
-    };
-  }
-
-  async function createCategory(name: string, parentIds?: string[]) {
-    const id = await categoryService.createCategory({
-      name,
-      isCustom: false,
-      allowRecords: true,
-      allowCustomCategories: true,
-      categoryIds: parentIds,
-    });
-
-    const C = await categoryService.getCategory(id);
-
-    expect(C.category.id).toEqual(id);
-    expect(C.category.name).toEqual(name);
-    return C;
-  }
-
-  async function createRecord(name: string, categoryIds: string[]) {
-    const content = 'first text file';
-    const file = new File([content], 'attachment.txt', {
-      type: 'text/plain',
-    });
-
-    const { recordId, attachmentError } = await recordService.createRecord({
-      name,
-      recordType: {
-        id: '123',
-        name,
-        version: 123,
-      },
-      categoryIds,
-      attachments: [
-        {
-          name: 'first attachment',
-          file,
-        },
-      ],
-    });
-
-    const R = await recordService.getRecord(recordId);
-
-    expect(R.id).toEqual(recordId);
-    expect(R.name).toEqual(name);
-    matchParentCategoryIds(R, categoryIds);
-
-    const attachment = await recordAttachmentService.downloadAttachment(
-      R.attachments[0].contentId,
-      R.attachments[0].keyId
-    );
-    expect(new TextDecoder('utf-8').decode(attachment)).toEqual(content);
-
-    return R;
-  }
-
-  function matchParentCategoryIds(
-    record: LrRecord,
-    parentCategoryIds: string[]
-  ) {
-    expect(record.categories.length).toBe(
-      parentCategoryIds.length,
-      'Different number of ParentCategories'
-    );
-    expect(
-      record.categories.every((c) =>
-        parentCategoryIds.includes(c[c.length - 1].id)
-      )
-    ).toBeTrue();
-  }
-
-  function matchSubCategories(
-    category: VaultCategory,
-    children: VaultCategory[]
-  ) {
-    const childrenId = children.map((c) => c.category.id);
-
-    expect(category.subCategories.length).toBe(
-      children.length,
-      'Different number of SubCategories'
-    );
-    expect(
-      category.subCategories.every((c) => childrenId.includes(c.id))
-    ).toBeTrue();
-  }
-
-  // async function updateRecord(recordId: string, recordProps: RecordProps) {
-  //   await recordService.updateRecord(recordId, updateId: string, keyId: string, updatedRecord: UpdatedRecord);
-
-  //   const R = await recordService.getRecord({
-  //     recordId
-  //   });
-
-  //   expect(R.plainMetaJson.recordProps).toEqual(recordProps);
-
-  //   return R;
-  // }
-
-  // async function updateContent(recordId, plainCipherMetaJson) {
-  //   let R = await recordService.getRecord({
-  //     recordId
-  //   });
-
-  //   const oldVersionId = R.content.edges[0].node.childFile.currentVersion.id;
-  //   const oldVersionsCount = R.content.edges[0].node.childFile.versions.edges.length;
-  //   const oldContent = R.content.edges[0].node.childFile.currentVersion.state.plainCipherMetaJson;
-
-  //   await recordService.updateContent({
-  //     recordId,
-  //     plainCipherMetaJson
-  //   });
-
-  //   R = await recordService.getRecord({
-  //     recordId
-  //   });
-
-  //   expect(R.content.edges[0].node.childFile.currentVersion.state.plainCipherMetaJson).toEqual(plainCipherMetaJson);
-  //   const newVersionId = R.content.edges[0].node.childFile.currentVersion.id;
-  //   const newVersionsCount = R.content.edges[0].node.childFile.versions.edges.length;
-  //   const newContent = R.content.edges[0].node.childFile.currentVersion.state.plainCipherMetaJson;
-
-  //   expect(newVersionId !== oldVersionId);
-  //   expect(newVersionsCount > oldVersionsCount);
-  // }
-
-  // async function addAttachment(recordId: string, name: string, text: string) {
-  //   const fileInput = new File([text], "attachment.txt", {
-  //     type: "text/plain",
-  //   });
-
-  //   const A = await recordService.addAttachment({
-  //     recordId,
-  //     fileInput,
-  //     plainCipherMetaJson: {
-  //       name,
-  //     }
-  //   });
-
-  //   const R = await recordService.getRecord({
-  //     recordId
-  //   });
-
-  //   const hasAttachment = R.attachments.edges.some(edge => {
-  //     return edge.node.childFile.currentVersion.state.plainCipherMetaJson.name == name
-  //   });
-
-  //   expect(hasAttachment).toBeTrue();
-
-  //   return A;
-  // }
-
-  async function deleteAllCategories() {
-    // First unarchive everything
-    let ids = await categoryService.getRootDirectoryIds({ archived: true });
-    await Promise.all(
-      ids.map(async (id) => categoryService.unarchiveCategory(id, true))
-    );
-
-    // Delete everything
-    ids = await categoryService.getRootDirectoryIds({ archived: false });
-    await Promise.all(
-      ids.map(async (id) => categoryService.deleteCategory(id))
-    );
-  }
-
-  lrit(
-    'should create vault',
-    async () => {
-      await deleteAllCategories();
-
-      let vault = await categoryService.getDefaultVault();
-      expect(vault).toEqual(null);
-
-      const vaultId = await categoryService.createDefaultVault();
-      vault = await categoryService.getDefaultVault();
-      expect(vault).toBeTruthy();
-
-      const C1 = await createCategory('C1', [vault.id]);
-      const categories = await categoryService.getCategories();
-      console.log('categories', categories);
-    },
-    TIMEOUT
-  );
-
-  // it('should create a simple category and record', async () => {
-  //   // First clear existing records.
-  //   await deleteAllCategories();
-  //   const C1 = await createCategory('C1')
-  //   let R1 = await createRecord('R1', [C1.category.id]);
-
-  //   R1 = await recordService.getRecord(R1.id);
-
-  // }, TIMEOUT);
-
-  lrit(
-    'should create categories and records',
-    async () => {
-      if (!user) return;
-
-      // First clear existing records.
-      await deleteAllCategories();
-
-      //     C1  C2
-      //     |  / |
-      //     | /  |
-      //     C3   |
-      //     | \  |
-      //     |  \ |
-      //    C4   C5
-      //   / |  / |
-      //  /  | /  |
-      // R3  C6   |
-      //     | \  |
-      //     |  \ |
-      //     R1  R2
-
-      // 'C' for category, 'R' for record, 'C3__C1_C2' C3 with C1,C2 as parents.
-      let C1 = await createCategory('C1试用'); // Test unicode
-      let C2 = await createCategory('C2');
-      let C3__C1_C2 = await createCategory('C3__C1_c2', [
-        C1.category.id,
-        C2.category.id,
-      ]);
-      let C4__C3 = await createCategory('C4__C3', [C3__C1_C2.category.id]);
-      let C5__C2_C3 = await createCategory('C5__C2_C3', [
-        C3__C1_C2.category.id,
-        C2.category.id,
-      ]);
-      let C6__C4_C5 = await createCategory('C6__C4_C5', [
-        C4__C3.category.id,
-        C5__C2_C3.category.id,
-      ]);
-
-      // --------------------------------------------------
-      // Categories
-      // --------------------------------------------------
-      C1 = await categoryService.getCategory(C1.category.id);
-      C2 = await categoryService.getCategory(C2.category.id);
-      C3__C1_C2 = await categoryService.getCategory(C3__C1_C2.category.id);
-      C4__C3 = await categoryService.getCategory(C4__C3.category.id);
-      C5__C2_C3 = await categoryService.getCategory(C5__C2_C3.category.id);
-      C6__C4_C5 = await categoryService.getCategory(C6__C4_C5.category.id);
-
-      matchSubCategories(C1, [C3__C1_C2]);
-      matchSubCategories(C2, [C3__C1_C2, C5__C2_C3]);
-      matchSubCategories(C3__C1_C2, [C4__C3, C5__C2_C3]);
-      matchSubCategories(C4__C3, [C6__C4_C5]);
-      matchSubCategories(C5__C2_C3, [C6__C4_C5]);
-
-      // --------------------------------------------------
-      // Records
-      // --------------------------------------------------
-
-      // --------------------------------------------------
-      // R1
-      // --------------------------------------------------
-      let R1 = await createRecord('R1', [C6__C4_C5.category.id]);
-
-      // Delete test
-      await recordService.deleteRecord(R1.id);
-      C6__C4_C5 = await categoryService.getCategory(C6__C4_C5.category.id);
-      expect(C6__C4_C5.records.length).toBe(0);
-      expect(C6__C4_C5.category.allRecordsCount).toBe(0);
-
-      C5__C2_C3 = await categoryService.getCategory(C5__C2_C3.category.id);
-      expect(C5__C2_C3.category.allRecordsCount).toBe(0);
-
-      // Delete archived record test
-      R1 = await createRecord('R1', [C6__C4_C5.category.id]);
-      await recordService.archiveRecord(R1.id);
-      await recordService.deleteRecord(R1.id);
-      C6__C4_C5 = await categoryService.getCategory(C6__C4_C5.category.id);
-      expect(C6__C4_C5.records.length).toBe(0);
-
-      // Create record
-      R1 = await createRecord('R1', [C6__C4_C5.category.id]);
-      C6__C4_C5 = await categoryService.getCategory(C6__C4_C5.category.id);
-      expect(C6__C4_C5.records.length).toBe(1);
-
-      // todo complete the rest of the tests.
-
-      // R1 = await updateRecord(R1.id, {
-      //   archived: false,
-      //   hidden: false
-      // });
-
-      // await updateContent(R1.id, recordContent("R1 update1"));
-
-      // let A1 = await addAttachment(R1.id, "R1 A1", "R1 A1 content");
-      // let A2 = await addAttachment(R1.id, "R1 A2", "R1 A2 content");
-      // await recordService.deleteAttachment({
-      //   attachmentId: A1.id
-      // })
-      // R1 = await recordService.getRecord({
-      //   recordId: R1.id
-      // });
-      // expect(R1.attachments.edges.length).toBe(1);
-
-      // --------------------------------------------------
-      // R2
-      // --------------------------------------------------
-      const R2 = await createRecord('R2', [
-        C5__C2_C3.category.id,
-        C6__C4_C5.category.id,
-      ]);
-
-      // PlainMeta filter should filter to only categories
-      const res = await categoryService.getCategory(C5__C2_C3.category.id);
-      expect(res.records.length).toBe(1);
-      expect(res.records[0].name).toEqual('R2');
-      expect(res.subCategories.length).toBe(1);
-      expect(res.subCategories[0].name).toEqual('C6__C4_C5');
-
-      // let parentC6 = R2.parentCategories.edges.find(edge => edge.node.parentDirectory.id == C6__C4_C5.id).node.parentDirectory;
-      // matchParentCategories(parentC6, [C4__C3, C5__C2_C3])
-
-      // --------------------------------------------------
-      // R3
-      // --------------------------------------------------
-      const R3 = await createRecord('R3', [C4__C3.category.id]);
-
-      // // --------------------------------------------------
-      // // C1
-      // // --------------------------------------------------
-      // C1 = await recordService.getCategory({
-      //   categoryId: C1.id,
-      // });
-      // expect(C1.allRecordsCount).toBe(3);
-      // expect(C1.records.edges.length).toBe(0);
-      // expect(C1.subCategories.edges.length).toBe(1);
-
-      // --------------------------------------------------
-      // C2
-      // --------------------------------------------------
-      C2 = await categoryService.getCategory(C2.category.id);
-      expect(C2.category.allRecordsCount).toBe(3);
-
-      // // --------------------------------------------------
-      // // C3
-      // // --------------------------------------------------
-      // C3__C1_c2 = await recordService.getCategory({
-      //   categoryId: C3__C1_c2.id,
-      // });
-      // expect(C3__C1_c2.allRecordsCount).toBe(3);
-      // expect(C3__C1_c2.records.edges.length).toBe(0);
-      // expect(C3__C1_c2.subCategories.edges.length).toBe(2);
-
-      // // --------------------------------------------------
-      // // C4
-      // // --------------------------------------------------
-      // C4__C3 = await recordService.getCategory({
-      //   categoryId: C4__C3.id,
-      // });
-      // expect(C4__C3.allRecordsCount).toBe(3);
-      // expect(C4__C3.records.edges.length).toBe(1);
-      // expect(C4__C3.subCategories.edges.length).toBe(1);
-
-      // // --------------------------------------------------
-      // // C5
-      // // --------------------------------------------------
-      C5__C2_C3 = await categoryService.getCategory(C5__C2_C3.category.id);
-      expect(C5__C2_C3.records.length).toBe(1);
-      expect(C5__C2_C3.subCategories.length).toBe(1);
-      expect(C5__C2_C3.category.allRecordsCount).toBe(2);
-
-      // --------------------------------------------------
-      // C6
-      // --------------------------------------------------
-      C6__C4_C5 = await categoryService.getCategory(C6__C4_C5.category.id);
-      expect(C6__C4_C5.records.length).toBe(2);
-      expect(C6__C4_C5.category.allRecordsCount).toBe(2);
-      console.log(res);
-
-      // --------------------------------------------------
-      // Archived R2
-      // --------------------------------------------------
-      await recordService.archiveRecord(R2.id);
-
-      // --------------------------------------------------
-      // C5
-      // --------------------------------------------------
-      C5__C2_C3 = await categoryService.getCategory(C5__C2_C3.category.id);
-      expect(C5__C2_C3.category.allRecordsCount).toBe(1);
-
-      // --------------------------------------------------
-      // C6
-      // --------------------------------------------------
-      C6__C4_C5 = await categoryService.getCategory(C6__C4_C5.category.id);
-      expect(C6__C4_C5.category.allRecordsCount).toBe(1);
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'should access control categories and records',
-    async () => {
-      if (!environment.test) {
-        return;
-      }
-
-      // First clear existing records.
-      await deleteAllCategories();
-
-      const {
-        username: username1,
-        password: password1,
-        email: email1,
-      } = environment.test.users[0];
-      const {
-        username: username2,
-        password: password2,
-        email: email2,
-      } = environment.test.users[1];
-      const {
-        username: username3,
-        password: password3,
-        email: email3,
-      } = environment.test.users[2];
-
-      // ------------------------------------------------------------------------------
-      // User 1
-      // ------------------------------------------------------------------------------
-      await loginTestUser(username1, password1);
-
-      const C1 = await createCategory('C1');
-      const R1 = await createRecord('R1', [C1.category.id]);
-
-      // ------------------------------------------------------------------------------
-      // User 2
-      // ------------------------------------------------------------------------------
-      await loginTestUser(username2, password2);
-      const C2 = await createCategory('C2');
-      const R2 = await createRecord('R2', [C2.category.id]);
-
-      // Should not have access
-      (
-        await lrExpectAsyncThrow(categoryService.getCategory(C1.category.id))
-      ).toBeTruthy();
-      (await lrExpectAsyncThrow(recordService.getRecord(R1.id))).toBeTruthy();
-
-      // ------------------------------------------------------------------------------
-      // User 1
-      // ------------------------------------------------------------------------------
-      await loginTestUser(username1, password1);
-
-      // Should not have access
-      (
-        await lrExpectAsyncThrow(categoryService.getCategory(C2.category.id))
-      ).toBeTruthy();
-      (await lrExpectAsyncThrow(recordService.getRecord(R2.id))).toBeTruthy();
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'should archive categories and records',
-    async () => {
-      if (!user) return;
-
-      // First clear existing records.
-      await deleteAllCategories();
-      //     C1  C2
-      //     |  / |
-      //     | /  |
-      //     C3   |
-      //     | \  |
-      //     |  \ |
-      //    C4   C5
-      //   / |  / |
-      //  /  | /  |
-      // R3  C6   |
-      //     | \  |
-      //     |  \ |
-      //     R1  R2
-
-      const VAULT_ID = await categoryService.createDefaultVault();
-
-      // 'C' for category, 'R' for record, 'C3__C1_C2' C3 with C1,C2 as parents.
-      let C1 = await createCategory('C1试用', [VAULT_ID]);
-      const C2 = await createCategory('C2', [VAULT_ID]);
-      const C3__C1_C2 = await createCategory('C3__C1_c2', [
-        C1.category.id,
-        C2.category.id,
-      ]);
-      const C4__C3 = await createCategory('C4__C3', [C3__C1_C2.category.id]);
-      const C5__C2_C3 = await createCategory('C5__C2_C3', [
-        C3__C1_C2.category.id,
-        C2.category.id,
-      ]);
-      let C6__C4_C5 = await createCategory('C6__C4_C5', [
-        C4__C3.category.id,
-        C5__C2_C3.category.id,
-      ]);
-      let R1 = await createRecord('R1', [C6__C4_C5.category.id]);
-      let R2 = await createRecord('R2', [
-        C5__C2_C3.category.id,
-        C6__C4_C5.category.id,
-      ]);
-      const R3 = await createRecord('R3', [C4__C3.category.id]);
-
-      let categories: Category[];
-
-      // Before archiving
-      categories = await categoryService.getCategories();
-      expect(categories.length).toBe(2);
-      categories = await categoryService.getCategories({ archived: false });
-      expect(categories.length).toBe(2);
-      categories = await categoryService.getCategories({ archived: true });
-      expect(categories.length).toBe(0);
-
-      // Archiving C1 non-recursive
-      await categoryService.archiveCategory(C1.category.id, false);
-      categories = await categoryService.getCategories();
-      expect(categories.length).toBe(2); // Returns all categories the user has access to, either archived or not.
-      categories = await categoryService.getCategories({ archived: false });
-      expect(categories.length).toBe(1); // Returns only non-archived
-      expect(categories[0].isArchived).toBeFalse();
-      categories = await categoryService.getCategories({ archived: true });
-      expect(categories.length).toBe(1); // Returns only archived
-      expect(categories[0].isArchived).toBeTrue();
-
-      C6__C4_C5 = await categoryService.getCategory(C6__C4_C5.category.id);
-      expect(C6__C4_C5.category.isArchived).toBeFalse();
-
-      // Archiving R2
-      await recordService.archiveRecord(R2.id);
-      R2 = await recordService.getRecord(R2.id);
-      expect(R2.isArchived).toBeTrue();
-
-      // Unarchiving R2
-      await recordService.unarchiveRecord(R2.id);
-      R2 = await recordService.getRecord(R2.id);
-      expect(R2.isArchived).toBeFalse();
-
-      // Archiving C3 recursive
-      await categoryService.archiveCategory(C3__C1_C2.category.id, true);
-
-      C6__C4_C5 = await categoryService.getCategory(C6__C4_C5.category.id);
-      expect(C6__C4_C5.category.isArchived).toBeTrue();
-
-      R1 = await recordService.getRecord(R1.id);
-      expect(R1.isArchived).toBeTrue();
-
-      // Unarchiving C6
-      await categoryService.unarchiveCategory(C6__C4_C5.category.id, false);
-
-      C6__C4_C5 = await categoryService.getCategory(C6__C4_C5.category.id);
-      expect(C6__C4_C5.category.isArchived).toBeFalse();
-
-      R1 = await recordService.getRecord(R1.id);
-      expect(R1.isArchived).toBeTrue(); // Non-recursive unarchive should not affect the child record
-
-      // Unarchiving C3
-      await categoryService.unarchiveCategory(C3__C1_C2.category.id, true);
-
-      C1 = await categoryService.getCategory(C1.category.id);
-      expect(C1.category.isArchived).toBeTrue(); // Unarchive should not affect parents
-
-      R1 = await recordService.getRecord(R1.id);
-      expect(R1.isArchived).toBeFalse();
-    },
-    TIMEOUT
-  );
-});