From 727b395482d98ec0ad542070882af03d6a16a293 Mon Sep 17 00:00:00 2001
From: Fahrrader <fhakimov@usetech.com>
Date: Tue, 14 Jun 2022 15:24:54 +0000
Subject: [PATCH] test(nesting-admin): use bob as admin, charlie as mere recipient, revert charlie reshuffle


---
--- a/tests/src/nesting/nest.test.ts
+++ b/tests/src/nesting/nest.test.ts
@@ -162,40 +162,60 @@
     await usingApi(async api => {
       const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
       await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});
-      await addCollectionAdminExpectSuccess(alice, collection, charlie.address);
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
+      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
+      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT', charlie.address);
 
       // Create a nested token
-      const nestedToken = await createItemExpectSuccess(charlie, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: alice.address});
+      const nestedToken = await createItemExpectSuccess(bob, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});
+      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: charlie.address});
       expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
 
       // Create a token to be nested and nest
-      const newToken = await createItemExpectSuccess(charlie, collection, 'NFT');
-      await transferExpectSuccess(collection, newToken, charlie, {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
+      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');
+      await transferExpectSuccess(collection, newToken, bob, {Ethereum: tokenIdToAddress(collection, targetToken)});
+      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: charlie.address});
       expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
     });
   });
 
+  it('Admin (NFT): Admin and Token Owner can operate together', async () => {
+    await usingApi(async api => {
+      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
+      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true, collectionAdmin: true}});
+      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
+      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT', charlie.address);
+
+      // Create a nested token by an administrator
+      const nestedToken = await createItemExpectSuccess(bob, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});
+      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: charlie.address});
+      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
+
+      // Create a token and allow the owner to nest too
+      const newToken = await createItemExpectSuccess(alice, collection, 'NFT', charlie.address);
+      await transferExpectSuccess(collection, newToken, charlie, {Ethereum: tokenIdToAddress(collection, nestedToken)});
+      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: charlie.address});
+      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, nestedToken).toLowerCase()});
+    });
+  });
+
   it('Admin (NFT): allows an Admin to nest a token (Restricted nesting)', async () => {
     await usingApi(async api => {
       const collectionA = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await addCollectionAdminExpectSuccess(alice, collectionA, charlie.address);
+      await addCollectionAdminExpectSuccess(alice, collectionA, bob.address);
       const collectionB = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await addCollectionAdminExpectSuccess(alice, collectionB, charlie.address);
+      await addCollectionAdminExpectSuccess(alice, collectionB, bob.address);
       await setCollectionPermissionsExpectSuccess(alice, collectionA, {nesting: {collectionAdmin: true, restricted:[collectionA, collectionB]}});
-      const targetToken = await createItemExpectSuccess(alice, collectionA, 'NFT');
+      const targetToken = await createItemExpectSuccess(alice, collectionA, 'NFT', charlie.address);
 
       // Create a nested token
-      const nestedToken = await createItemExpectSuccess(charlie, collectionB, 'NFT', {Ethereum: tokenIdToAddress(collectionA, targetToken)});
-      expect(await getTopmostTokenOwner(api, collectionB, nestedToken)).to.be.deep.equal({Substrate: alice.address});
+      const nestedToken = await createItemExpectSuccess(bob, collectionB, 'NFT', {Ethereum: tokenIdToAddress(collectionA, targetToken)});
+      expect(await getTopmostTokenOwner(api, collectionB, nestedToken)).to.be.deep.equal({Substrate: charlie.address});
       expect(await getTokenOwner(api, collectionB, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collectionA, targetToken).toLowerCase()});
 
       // Create a token to be nested and nest
-      const newToken = await createItemExpectSuccess(charlie, collectionB, 'NFT');
-      await transferExpectSuccess(collectionB, newToken, charlie, {Ethereum: tokenIdToAddress(collectionA, targetToken)});
-      expect(await getTopmostTokenOwner(api, collectionB, newToken)).to.be.deep.equal({Substrate: alice.address});
+      const newToken = await createItemExpectSuccess(bob, collectionB, 'NFT');
+      await transferExpectSuccess(collectionB, newToken, bob, {Ethereum: tokenIdToAddress(collectionA, targetToken)});
+      expect(await getTopmostTokenOwner(api, collectionB, newToken)).to.be.deep.equal({Substrate: charlie.address});
       expect(await getTokenOwner(api, collectionB, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collectionA, targetToken).toLowerCase()});
     });
   });
@@ -340,7 +360,6 @@
     await usingApi(async (_, privateKeyWrapper) => {
       alice = privateKeyWrapper('//Alice');
       bob = privateKeyWrapper('//Bob');
-      charlie = privateKeyWrapper('//Charlie');
     });
   });
 
@@ -382,24 +401,24 @@
     await usingApi(async api => {
       const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
       await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
-      await addCollectionAdminExpectSuccess(alice, collection, charlie.address);
+      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
       const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
 
       // Try to create a nested token as collection admin when it's disallowed
-      await expect(executeTransaction(api, charlie, api.tx.unique.createItem(
+      await expect(executeTransaction(api, bob, api.tx.unique.createItem(
         collection,
         {Ethereum: tokenIdToAddress(collection, targetToken)},
           {nft: {const_data: [], variable_data: []}} as any,
       )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
 
       // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(charlie, collection, 'NFT');
+      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');
       await expect(executeTransaction(
         api, 
-        charlie, 
+        bob, 
         api.tx.unique.transfer({Ethereum: tokenIdToAddress(collection, targetToken)}, collection, newToken, 1),
       ), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: charlie.address});
+      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});
     });
   });
 
@@ -407,26 +426,26 @@
     await usingApi(async api => {
       const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
       await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});
-      await addToAllowListExpectSuccess(alice, collection, charlie.address);
+      await addToAllowListExpectSuccess(alice, collection, bob.address);
       await enableAllowListExpectSuccess(alice, collection);
       await enablePublicMintingExpectSuccess(alice, collection);
       const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
 
       // Try to create a nested token as collection admin when it's disallowed
-      await expect(executeTransaction(api, charlie, api.tx.unique.createItem(
+      await expect(executeTransaction(api, bob, api.tx.unique.createItem(
         collection,
         {Ethereum: tokenIdToAddress(collection, targetToken)},
           {nft: {const_data: [], variable_data: []}} as any,
       )), 'while creating nested token').to.be.rejectedWith(/common\.AddressNotInAllowlist/); // todo is this right?
 
       // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(charlie, collection, 'NFT');
+      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');
       await expect(executeTransaction(
         api, 
-        charlie, 
+        bob, 
         api.tx.unique.transfer({Ethereum: tokenIdToAddress(collection, targetToken)}, collection, newToken, 1),
       ), 'while nesting new token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: charlie.address});
+      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});
     });
   });
 
@@ -435,22 +454,22 @@
       const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
       await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});
 
-      await addToAllowListExpectSuccess(alice, collection, charlie.address);
+      await addToAllowListExpectSuccess(alice, collection, bob.address);
       await enableAllowListExpectSuccess(alice, collection);
       await enablePublicMintingExpectSuccess(alice, collection);
 
       // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(charlie, collection, 'NFT');
+      const targetToken = await createItemExpectSuccess(bob, collection, 'NFT');
       const targetAddress = {Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()};
 
       // Try to nest somebody else's token
-      const newToken = await createItemExpectSuccess(charlie, collection, 'NFT');
+      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.transfer(targetAddress, collection, newToken, 1),
       ), 'while nesting another\'s token token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: charlie.address});
+      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});
 
       // Nest a token as admin and try to unnest it, now belonging to someone else
       const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', targetAddress);
@@ -460,7 +479,7 @@
         api.tx.unique.transferFrom(targetAddress, normalizeAccountId(alice), collection, nestedToken, 1),
       ), 'while unnesting another\'s token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);
       expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal(targetAddress);
-      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: charlie.address});
+      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: bob.address});
     });
   });
 

-- 
gitstuff