Merge branch 'imprv/page-v5-test-code-delete' into imprv/page-v5-test-code-delete-completely

packages/app/test/integration/service/pagev5.test.ts

@@ -23,38 +23,13 @@ describe('PageService page operations with only public pages', () => {
   let xssSpy;
 
   let rootPage;
-  let dummyUser1Page;
-
-  // parents
-  let parentForRename1;
-  let parentForRename2;
-  let parentForRename3;
-  let parentForRename4;
-  let parentForRename5;
-  let parentForRename6;
-  let parentForRename7;
-  let parentForRename8;
-  // children
-  let childForRename1;
-  let childForRename2;
-  let childForRename3;
-  let childForRename4;
-  let childForRename5;
-  let childForRename6;
-  let childForRename7;
-
-  /**
-   * Delete
-   */
-  let v5PageForDelete1;
-  let v5PageForDelete2;
-  let v5PageForDelete3;
-  let v5PageForDelete4;
-  let v5PageForDelete5;
-  let v5PageForDelete6;
-
-  let tagForDelete1;
-  let tagForDelete2;
+
+  // pass unless the data is one of [false, 0, '', null, undefined, NaN]
+  const expectAllToBeTruthy = (dataList) => {
+    dataList.forEach((data) => {
+      expect(data).toBeTruthy();
+    });
+  };
 
   // pass unless the data is one of [false, 0, '', null, undefined, NaN]
   const expectAllToBeTruthy = (dataList) => {
@@ -110,13 +85,32 @@ describe('PageService page operations with only public pages', () => {
         status: Page.STATUS_PUBLISHED,
       },
     ]);
-    dummyUser1Page = await Page.create('/user/dummyUser1', 'dummyUser1_page', dummyUser1._id, {});
+
+    await Page.create('/user/dummyUser1', 'dummyUser1_page', dummyUser1._id, {});
     await Page.create('/user/dummyUser2', 'dummyUser2_page', dummyUser2._id, {});
 
+    const pageIdForRename1 = new mongoose.Types.ObjectId();
+    const pageIdForRename2 = new mongoose.Types.ObjectId();
+    const pageIdForRename3 = new mongoose.Types.ObjectId();
+    const pageIdForRename4 = new mongoose.Types.ObjectId();
+    const pageIdForRename5 = new mongoose.Types.ObjectId();
+
+    const pageIdForRename7 = new mongoose.Types.ObjectId();
+    const pageIdForRename8 = new mongoose.Types.ObjectId();
+    const pageIdForRename9 = new mongoose.Types.ObjectId();
+    const pageIdForRename10 = new mongoose.Types.ObjectId();
+    const pageIdForRename11 = new mongoose.Types.ObjectId();
+    const pageIdForRename12 = new mongoose.Types.ObjectId();
+    const pageIdForRename13 = new mongoose.Types.ObjectId();
+    const pageIdForRename14 = new mongoose.Types.ObjectId();
+
+    const pageIdForRename16 = new mongoose.Types.ObjectId();
+
     // Create Pages
     await Page.insertMany([
       // parents
       {
+        _id: pageIdForRename1,
         path: '/v5_ParentForRename1',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
@@ -124,42 +118,46 @@ describe('PageService page operations with only public pages', () => {
         parent: rootPage._id,
       },
       {
+        _id: pageIdForRename2,
         path: '/v5_ParentForRename2',
         grant: Page.GRANT_PUBLIC,
-        creator: dummyUser1,
-        lastUpdateUser: dummyUser1._id,
         parent: rootPage._id,
         isEmpty: true,
       },
       {
-        path: '/v5_ParentForRename3',
+        // id not needed for this data
+        path: '/v5_ParentForRename2/dummyChild1',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
         lastUpdateUser: dummyUser1._id,
-        parent: rootPage._id,
+        parent: pageIdForRename2,
       },
       {
-        path: '/v5_ParentForRename4',
+        _id: pageIdForRename3,
+        path: '/v5_ParentForRename3',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
         lastUpdateUser: dummyUser1._id,
         parent: rootPage._id,
       },
       {
-        path: '/v5_ParentForRename5',
+        _id: pageIdForRename4,
+        path: '/v5_ParentForRename4',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
         lastUpdateUser: dummyUser1._id,
         parent: rootPage._id,
       },
       {
-        path: '/v5_ParentForRename6',
+        _id: pageIdForRename5,
+        path: '/v5_ParentForRename5',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
         lastUpdateUser: dummyUser1._id,
         parent: rootPage._id,
       },
       {
+        _id: pageIdForRename7,
         path: '/v5_ParentForRename7',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
@@ -167,6 +165,7 @@ describe('PageService page operations with only public pages', () => {
         parent: rootPage._id,
       },
       {
+        _id: pageIdForRename8,
         path: '/v5_ParentForRename8',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
@@ -174,6 +173,7 @@ describe('PageService page operations with only public pages', () => {
         parent: rootPage._id,
       },
       {
+        _id: pageIdForRename9,
         path: '/v5_ParentForRename9',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
@@ -182,6 +182,7 @@ describe('PageService page operations with only public pages', () => {
       },
       // children
       {
+        _id: pageIdForRename10,
         path: '/v5_ChildForRename1',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
@@ -189,6 +190,7 @@ describe('PageService page operations with only public pages', () => {
         parent: rootPage._id,
       },
       {
+        _id: pageIdForRename11,
         path: '/v5_ChildForRename2',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
@@ -196,6 +198,7 @@ describe('PageService page operations with only public pages', () => {
         parent: rootPage._id,
       },
       {
+        _id: pageIdForRename12,
         path: '/v5_ChildForRename3',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
@@ -204,6 +207,7 @@ describe('PageService page operations with only public pages', () => {
         updatedAt: new Date('2021'),
       },
       {
+        _id: pageIdForRename13,
         path: '/v5_ChildForRename4',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
@@ -211,6 +215,7 @@ describe('PageService page operations with only public pages', () => {
         parent: rootPage._id,
       },
       {
+        _id: pageIdForRename14,
         path: '/v5_ChildForRename5',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
@@ -218,47 +223,19 @@ describe('PageService page operations with only public pages', () => {
         parent: rootPage._id,
       },
       {
-        path: '/v5_ChildForRename6',
-        grant: Page.GRANT_RESTRICTED,
-        creator: dummyUser1,
-        lastUpdateUser: dummyUser1._id,
-        parent: rootPage._id,
-      },
-      {
+        _id: pageIdForRename16,
         path: '/v5_ChildForRename7',
         grant: Page.GRANT_PUBLIC,
         parent: rootPage._id,
         isEmpty: true,
       },
-    ]);
-
-    // Find pages as Parent
-    parentForRename1 = await Page.findOne({ path: '/v5_ParentForRename1' });
-    parentForRename2 = await Page.findOne({ path: '/v5_ParentForRename2' });
-    parentForRename3 = await Page.findOne({ path: '/v5_ParentForRename3' });
-    parentForRename4 = await Page.findOne({ path: '/v5_ParentForRename4' });
-    parentForRename5 = await Page.findOne({ path: '/v5_ParentForRename5' });
-    parentForRename6 = await Page.findOne({ path: '/v5_ParentForRename6' });
-    parentForRename7 = await Page.findOne({ path: '/v5_ParentForRename7' });
-    parentForRename8 = await Page.findOne({ path: '/v5_ParentForRename8' });
-    // Find pages as Child
-    childForRename1 = await Page.findOne({ path: '/v5_ChildForRename1' });
-    childForRename2 = await Page.findOne({ path: '/v5_ChildForRename2' });
-    childForRename3 = await Page.findOne({ path: '/v5_ChildForRename3' });
-    childForRename4 = await Page.findOne({ path: '/v5_ChildForRename4' });
-    childForRename5 = await Page.findOne({ path: '/v5_ChildForRename5' });
-    childForRename6 = await Page.findOne({ path: '/v5_ChildForRename6' });
-    childForRename7 = await Page.findOne({ path: '/v5_ChildForRename7' });
-
-    // create grandchild
-    await Page.insertMany([
       // Grandchild
       {
         path: '/v5_ChildForRename5/v5_GrandchildForRename5',
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
         lastUpdateUser: dummyUser1._id,
-        parent: childForRename5._id,
+        parent: pageIdForRename14,
         updatedAt: new Date('2021'),
       },
       {
@@ -266,7 +243,7 @@ describe('PageService page operations with only public pages', () => {
         grant: Page.GRANT_PUBLIC,
         creator: dummyUser1,
         lastUpdateUser: dummyUser1._id,
-        parent: childForRename7._id,
+        parent: pageIdForRename16,
       },
     ]);
 
@@ -330,25 +307,17 @@ describe('PageService page operations with only public pages', () => {
       },
     ]);
 
-
-    v5PageForDelete1 = await Page.findOne({ path: '/trash/v5_PageForDelete1' });
-    v5PageForDelete2 = await Page.findOne({ path: '/v5_PageForDelete2' });
-    v5PageForDelete3 = await Page.findOne({ path: '/v5_PageForDelete3' });
-    v5PageForDelete4 = await Page.findOne({ path: '/v5_PageForDelete3/v5_PageForDelete4' });
-    v5PageForDelete5 = await Page.findOne({ path: '/v5_PageForDelete3/v5_PageForDelete4/v5_PageForDelete5' });
-    v5PageForDelete6 = await Page.findOne({ path: '/v5_PageForDelete6' });
+    const tagIdForDelete1 = new mongoose.Types.ObjectId();
+    const tagIdForDelete2 = new mongoose.Types.ObjectId();
 
     await Tag.insertMany([
-      { name: 'TagForDelete1' },
-      { name: 'TagForDelete2' },
+      { _id: tagIdForDelete1, name: 'TagForDelete1' },
+      { _id: tagIdForDelete2, name: 'TagForDelete2' },
     ]);
 
-    tagForDelete1 = await Tag.findOne({ name: 'TagForDelete1' });
-    tagForDelete2 = await Tag.findOne({ name: 'TagForDelete2' });
-
     await PageTagRelation.insertMany([
-      { relatedPage: v5PageForDelete6._id, relatedTag: tagForDelete1 },
-      { relatedPage: v5PageForDelete6._id, relatedTag: tagForDelete2 },
+      { relatedPage: pageIdForDelete3, relatedTag: tagIdForDelete1 },
+      { relatedPage: pageIdForDelete3, relatedTag: tagIdForDelete2 },
     ]);
 
     /**
@@ -551,7 +520,7 @@ describe('PageService page operations with only public pages', () => {
     };
 
     test('Should NOT rename top page', async() => {
-
+      expectAllToBeTruthy([rootPage]);
       let isThrown = false;
       try {
         await crowi.pageService.renamePage(rootPage, '/new_root', dummyUser1, {});
@@ -564,36 +533,47 @@ describe('PageService page operations with only public pages', () => {
     });
 
     test('Should rename/move to under non-empty page', async() => {
-      // rename target page
+      const parentPage = await Page.findOne({ path: '/v5_ParentForRename1' });
+      const childPage = await Page.findOne({ path: '/v5_ChildForRename1' });
+      expectAllToBeTruthy([childPage, parentPage]);
+
       const newPath = '/v5_ParentForRename1/renamedChildForRename1';
-      const renamedPage = await renamePage(childForRename1, newPath, dummyUser1, {});
+      const renamedPage = await renamePage(childPage, newPath, dummyUser1, {});
 
       expect(xssSpy).toHaveBeenCalled();
       expect(renamedPage.path).toBe(newPath);
-      expect(renamedPage.parent).toStrictEqual(parentForRename1._id);
+      expect(renamedPage.parent).toStrictEqual(parentPage._id);
 
     });
 
     test('Should rename/move to under empty page', async() => {
-      // rename target page
+      const parentPage = await Page.findOne({ path: '/v5_ParentForRename2' });
+      const childPage = await Page.findOne({ path: '/v5_ChildForRename2' });
+      expectAllToBeTruthy([childPage, parentPage]);
+      expect(parentPage.isEmpty).toBe(true);
+
       const newPath = '/v5_ParentForRename2/renamedChildForRename2';
-      const renamedPage = await renamePage(childForRename2, newPath, dummyUser1, {});
+      const renamedPage = await renamePage(childPage, newPath, dummyUser1, {});
 
       expect(xssSpy).toHaveBeenCalled();
       expect(renamedPage.path).toBe(newPath);
-      expect(parentForRename2.isEmpty).toBe(true);
-      expect(renamedPage.parent).toStrictEqual(parentForRename2._id);
+      expect(parentPage.isEmpty).toBe(true);
+      expect(renamedPage.parent).toStrictEqual(parentPage._id);
     });
 
     test('Should rename/move with option updateMetadata: true', async() => {
-      // rename target page
+      const parentPage = await Page.findOne({ path: '/v5_ParentForRename3' });
+      const childPage = await Page.findOne({ path: '/v5_ChildForRename3' });
+      expectAllToBeTruthy([childPage, parentPage]);
+      expect(childPage.lastUpdateUser).toStrictEqual(dummyUser1._id);
+
       const newPath = '/v5_ParentForRename3/renamedChildForRename3';
-      const oldUdpateAt = childForRename3.updatedAt;
-      const renamedPage = await renamePage(childForRename3, newPath, dummyUser2, { updateMetadata: true });
+      const oldUdpateAt = childPage.updatedAt;
+      const renamedPage = await renamePage(childPage, newPath, dummyUser2, { updateMetadata: true });
 
       expect(xssSpy).toHaveBeenCalled();
       expect(renamedPage.path).toBe(newPath);
-      expect(renamedPage.parent).toStrictEqual(parentForRename3._id);
+      expect(renamedPage.parent).toStrictEqual(parentPage._id);
       expect(renamedPage.lastUpdateUser).toStrictEqual(dummyUser2._id);
       expect(renamedPage.updatedAt.getFullYear()).toBeGreaterThan(oldUdpateAt.getFullYear());
     });
@@ -602,66 +582,65 @@ describe('PageService page operations with only public pages', () => {
     // uncomment the next test when working on 88097
     // ******************************************
     // test('Should move with option createRedirectPage: true', async() => {
+    // const parentPage = await Page.findOne({ path: '/v5_ParentForRename4' });
+    // const childPage = await Page.findOne({ path: '/v5_ChildForRename4' });
+    // expectAllToBeTruthy([parentPage, childPage]);
+
     //   // rename target page
     //   const newPath = '/v5_ParentForRename4/renamedChildForRename4';
-    //   const renamedPage = await renamePage(childForRename4, newPath, dummyUser2, { createRedirectPage: true });
-    //   const pageRedirect = await PageRedirect.find({ fromPath: childForRename4.path, toPath: renamedPage.path });
+    //   const renamedPage = await renamePage(childPage, newPath, dummyUser2, { createRedirectPage: true });
+    //   const pageRedirect = await PageRedirect.find({ fromPath: childPage.path, toPath: renamedPage.path });
 
     // expect(xssSpy).toHaveBeenCalled();
     //   expect(renamedPage.path).toBe(newPath);
-    //   expect(renamedPage.parent).toStrictEqual(parentForRename4._id);
+    //   expect(renamedPage.parent).toStrictEqual(parentPage._id);
     //   expect(pageRedirect.length).toBeGreaterThan(0);
     // });
 
     test('Should rename/move with descendants', async() => {
-      // rename target page
+      const parentPage = await Page.findOne({ path: '/v5_ParentForRename5' });
+      const childPage = await Page.findOne({ path: '/v5_ChildForRename5' });
+      expectAllToBeTruthy([parentPage, childPage]);
+
       const newPath = '/v5_ParentForRename5/renamedChildForRename5';
-      const renamedPage = await renamePage(childForRename5, newPath, dummyUser1, {});
+      const renamedPage = await renamePage(childPage, newPath, dummyUser1, {});
       // find child of renamed page
-      const grandchildren = await Page.find({ parent: renamedPage._id });
-      const grandchild = grandchildren[0];
+      const grandchild = await Page.findOne({ parent: renamedPage._id });
 
       expect(xssSpy).toHaveBeenCalled();
       expect(renamedPage.path).toBe(newPath);
-      expect(renamedPage.parent).toStrictEqual(parentForRename5._id);
-      // grandchild's parent should be renamed page
+      expect(renamedPage.parent).toStrictEqual(parentPage._id);
+      // grandchild's parent should be the renamed page
       expect(grandchild.parent).toStrictEqual(renamedPage._id);
       expect(grandchild.path).toBe('/v5_ParentForRename5/renamedChildForRename5/v5_GrandchildForRename5');
     });
 
-    test('Should rename/move with same grant', async() => {
-      // rename target page
-      const newPath = '/v5_ParentForRename6/renamedChildForRename6';
-      expect(childForRename6.grant).toBe(Page.GRANT_RESTRICTED);
-      const renamedPage = await renamePage(childForRename6, newPath, dummyUser1, {});
-
-      expect(xssSpy).toHaveBeenCalled();
-      expect(renamedPage.path).toBe(newPath);
-      expect(renamedPage.parent).toStrictEqual(parentForRename6._id);
-      expect(renamedPage.grant).toBe(Page.GRANT_RESTRICTED);
-    });
-
     test('Should rename/move empty page', async() => {
-      // rename target page
+      const parentPage = await Page.findOne({ path: '/v5_ParentForRename7' });
+      const childPage = await Page.findOne({ path: '/v5_ChildForRename7' });
+      expectAllToBeTruthy([parentPage, childPage]);
+      expect(childPage.isEmpty).toBe(true);
+
       const newPath = '/v5_ParentForRename7/renamedChildForRename7';
-      const renamedPage = await renamePage(childForRename7, newPath, dummyUser1, {});
-      // find child of renamed page
+      const renamedPage = await renamePage(childPage, newPath, dummyUser1, {});
       const grandchild = await Page.findOne({ parent: renamedPage._id });
 
       expect(xssSpy).toHaveBeenCalled();
       expect(renamedPage.path).toBe(newPath);
       expect(renamedPage.isEmpty).toBe(true);
-      expect(renamedPage.parent).toStrictEqual(parentForRename7._id);
+      expect(renamedPage.parent).toStrictEqual(parentPage._id);
       // grandchild's parent should be renamed page
       expect(grandchild.parent).toStrictEqual(renamedPage._id);
       expect(grandchild.path).toBe('/v5_ParentForRename7/renamedChildForRename7/v5_GrandchildForRename7');
     });
     test('Should NOT rename/move with existing path', async() => {
-      // rename target page
+      const page = await Page.findOne({ path: '/v5_ParentForRename8' });
+      expectAllToBeTruthy([page]);
+
       const newPath = '/v5_ParentForRename9';
       let isThrown;
       try {
-        await renamePage(parentForRename8, newPath, dummyUser1, {});
+        await renamePage(page, newPath, dummyUser1, {});
       }
       catch (err) {
         isThrown = true;
@@ -690,66 +669,79 @@ describe('PageService page operations with only public pages', () => {
     };
     test('Should NOT delete root page', async() => {
       let isThrown;
-      try {
-        await deletePage(rootPage, dummyUser1, {}, false);
-      }
-      catch (err) {
-        isThrown = true;
-      }
+      expectAllToBeTruthy([rootPage]);
+
+      try { await deletePage(rootPage, dummyUser1, {}, false) }
+      catch (err) { isThrown = true }
+
       expect(isThrown).toBe(true);
     });
     test('Should NOT delete trashed page', async() => {
+      const page = await Page.findOne({ path: '/trash/v5_PageForDelete1' });
+      expectAllToBeTruthy([page]);
+
       let isThrown;
-      try {
-        await deletePage(v5PageForDelete1, dummyUser1, {}, false);
-      }
-      catch (err) {
-        isThrown = true;
-      }
+      try { await deletePage(page, dummyUser1, {}, false) }
+      catch (err) { isThrown = true }
+
       expect(isThrown).toBe(true);
     });
     test('Should NOT delete /user/hoge page', async() => {
+      const dummyUser1Page = await Page.findOne({ username: 'dummyUser1' });
+      expectAllToBeTruthy([dummyUser1Page]);
+
       let isThrown;
-      try {
-        await deletePage(dummyUser1Page, dummyUser1, {}, false);
-      }
-      catch (err) {
-        isThrown = true;
-      }
+      try { await deletePage(dummyUser1Page, dummyUser1, {}, false) }
+      catch (err) { isThrown = true }
+
       expect(isThrown).toBe(true);
     });
     test('Should delete single page', async() => {
-      const oldPath = v5PageForDelete2.path;
-      const deletedPage = await deletePage(v5PageForDelete2, dummyUser1, {}, false);
+      const page = await Page.findOne({ path: '/v5_PageForDelete2' });
+      expectAllToBeTruthy([page]);
+
+      const deletedPage = await deletePage(page, dummyUser1, {}, false);
 
-      expect(deletedPage.path).toBe(`/trash${oldPath}`);
+      expect(deletedPage.path).toBe(`/trash${page.path}`);
       expect(deletedPage.parent).toBeNull();
       expect(deletedPage.status).toBe(Page.STATUS_DELETED);
     });
     test('Should delete multiple pages including empty child', async() => {
-      const deletedPage = await deletePage(v5PageForDelete3, dummyUser1, {}, true);
-      const deletedV5PageForDelete4 = await Page.findOne({ path: `/trash${v5PageForDelete4.path}` });
-      const deletedV5PageForDelete5 = await Page.findOne({ path: `/trash${v5PageForDelete5.path}` });
+      const parentPage = await Page.findOne({ path: '/v5_PageForDelete3' });
+      const childPage = await Page.findOne({ path: '/v5_PageForDelete3/v5_PageForDelete4' });
+      const grandchildPage = await Page.findOne({ path: '/v5_PageForDelete3/v5_PageForDelete4/v5_PageForDelete5' });
+      expectAllToBeTruthy([parentPage, childPage, grandchildPage]);
+
+      const deletedParentPage = await deletePage(parentPage, dummyUser1, {}, true);
+      const deletedChildPage = await Page.findOne({ path: `/trash${childPage.path}` });
+      const deletedGrandchildPage = await Page.findOne({ path: `/trash${grandchildPage.path}` });
 
       // originally NOT empty page should exist with status 'deleted' and parent set null
-      expect(deletedPage._id).toStrictEqual(v5PageForDelete3._id);
-      expect(deletedPage.status).toBe(Page.STATUS_DELETED);
-      expect(deletedPage.parent).toBeNull();
+      expect(deletedParentPage._id).toStrictEqual(parentPage._id);
+      expect(deletedParentPage.status).toBe(Page.STATUS_DELETED);
+      expect(deletedParentPage.parent).toBeNull();
       // originally empty page should NOT exist
-      expect(deletedV5PageForDelete4).toBeNull();
+      expect(deletedChildPage).toBeNull();
       // originally NOT empty page should exist with status 'deleted' and parent set null
-      expect(deletedV5PageForDelete5._id).toStrictEqual(v5PageForDelete5._id);
-      expect(deletedV5PageForDelete5.status).toBe(Page.STATUS_DELETED);
-      expect(deletedV5PageForDelete5.parent).toBeNull();
+      expect(deletedGrandchildPage._id).toStrictEqual(grandchildPage._id);
+      expect(deletedGrandchildPage.status).toBe(Page.STATUS_DELETED);
+      expect(deletedGrandchildPage.parent).toBeNull();
     });
-    test('Should delete page tags', async() => {
-      const deletedPage = await deletePage(v5PageForDelete6, dummyUser1, {}, false);
-      const deletedTag1 = await PageTagRelation.findOne({ relatedpage: deletedPage._id, relatedTag: tagForDelete1 });
-      const deletedTag2 = await PageTagRelation.findOne({ relatedpage: deletedPage._id, relatedTag: tagForDelete2 });
+    test('Should delete page tag relation', async() => {
+      const page = await Page.findOne({ path: '/v5_PageForDelete6' });
+      const tag1 = await Tag.findOne({ name: 'TagForDelete1' });
+      const tag2 = await Tag.findOne({ name: 'TagForDelete2' });
+      const pageRelation1 = await PageTagRelation.findOne({ name: tag1.name });
+      const pageRelation2 = await PageTagRelation.findOne({ name: tag2.name });
+      expectAllToBeTruthy([page, tag1, tag2, pageRelation1, pageRelation2]);
+
+      const deletedPage = await deletePage(page, dummyUser1, {}, false);
+      const deletedTagRelation1 = await PageTagRelation.findOne({ _id: pageRelation1._id });
+      const deletedTagRelation2 = await PageTagRelation.findOne({ _id: pageRelation2._id });
 
       expect(deletedPage.status).toBe(Page.STATUS_DELETED);
-      expect(deletedTag1.isPageTrashed).toBe(true);
-      expect(deletedTag2.isPageTrashed).toBe(true);
+      expect(deletedTagRelation1.isPageTrashed).toBe(true);
+      expect(deletedTagRelation2.isPageTrashed).toBe(true);
     });
   });