fixing tests

contracts/extensions/nft/NFT.sol

@@ -179,7 +179,7 @@ contract NFTExtension is IExtension, IERC721Receiver {
     ) external hasExtensionAccess(_dao, AclFlag.INTERNAL_TRANSFER) {
         require(newOwner != address(0x0), "erc721::new owner is 0");
         address currentOwner = _ownership[getNFTId(nftAddr, nftTokenId)];
-        require(_dao.notJailed(currentOwner), "member is jailed!");
+        require(_dao.notJailed(currentOwner), "member is jailed");
         require(currentOwner != address(0x0), "erc721::nft not found");
 
         _ownership[getNFTId(nftAddr, nftTokenId)] = newOwner;

test/adapters/ragequit.test.js

@@ -616,10 +616,11 @@ describe("Adapter - Ragequit", () => {
     ).to.be.revertedWith("revert");
   });
 
-  it("still be able to ragequit even if a guild kick is in progress", async () => {
+  it("should be possible to ragequit even if a guild kick is in progress", async () => {
     const member = owner;
     const newMember = accounts[2];
 
+    const bank = this.extensions.bankExt;
     const onboarding = this.adapters.onboarding;
     const voting = this.adapters.voting;
     const guildkickContract = this.adapters.guildkick;
@@ -635,7 +636,10 @@ describe("Adapter - Ragequit", () => {
       UNITS
     );
 
-    // Start a new kick poposal
+    const memberUnits = await bank.balanceOf(newMember, UNITS);
+    expect(memberUnits.toString()).equal("10000000000000000");
+
+    // Start a new kick proposal
     let memberToKick = newMember;
     let kickProposalId = getProposalCounter();
 
@@ -649,7 +653,7 @@ describe("Adapter - Ragequit", () => {
 
     await this.adapters.ragequit.ragequit(
       this.dao.address,
-      toBN(1000),
+      memberUnits,
       toBN(0),
       [], //empty token array
       {
@@ -658,16 +662,121 @@ describe("Adapter - Ragequit", () => {
       }
     );
 
-    //but the member should still be jailed
+    expect((await bank.balanceOf(memberToKick, UNITS)).toString()).equal("0");
+  });
 
-    const { erc20Ext } = this.extensions;
+  it("should be possible to partially ragequit even if a guild kick is in progress", async () => {
+    const member = owner;
+    const newMember = accounts[2];
+
+    const bank = this.extensions.bankExt;
+    const onboarding = this.adapters.onboarding;
+    const voting = this.adapters.voting;
+    const guildkickContract = this.adapters.guildkick;
+
+    await onboardingNewMember(
+      getProposalCounter(),
+      this.dao,
+      onboarding,
+      voting,
+      newMember,
+      member,
+      unitPrice,
+      UNITS
+    );
+
+    const memberUnits = await bank.balanceOf(newMember, UNITS);
+    expect(memberUnits.toString()).equal("10000000000000000");
+
+    // Start a new kick proposal
+    let memberToKick = newMember;
+    let kickProposalId = getProposalCounter();
+
+    await guildKickProposal(
+      this.dao,
+      guildkickContract,
+      memberToKick,
+      member,
+      kickProposalId
+    );
+
+    const burnUnits = toBN(50000);
+    await this.adapters.ragequit.ragequit(
+      this.dao.address,
+      burnUnits,
+      toBN(0),
+      [], //empty token array
+      {
+        from: memberToKick,
+        gasPrice: toBN("0"),
+      }
+    );
 
+    expect(await bank.balanceOf(memberToKick, UNITS)).to.be.equal(
+      memberUnits.sub(burnUnits)
+    );
+  });
+
+  it("should not be possible to transfer the remaining units after a partial ragequit if the member was in jail", async () => {
+    const member = owner;
+    const newMember = accounts[2];
+
+    const bank = this.extensions.bankExt;
+    const onboarding = this.adapters.onboarding;
+    const voting = this.adapters.voting;
+    const guildkickContract = this.adapters.guildkick;
+
+    await onboardingNewMember(
+      getProposalCounter(),
+      this.dao,
+      onboarding,
+      voting,
+      newMember,
+      member,
+      unitPrice,
+      UNITS
+    );
+
+    const memberUnits = await bank.balanceOf(newMember, UNITS);
+    expect(memberUnits.toString()).equal("10000000000000000");
+
+    // Start a new kick proposal
+    let memberToKick = newMember;
+    let kickProposalId = getProposalCounter();
+
+    await guildKickProposal(
+      this.dao,
+      guildkickContract,
+      memberToKick,
+      member,
+      kickProposalId
+    );
+
+    const burnUnits = toBN(50000);
+    await this.adapters.ragequit.ragequit(
+      this.dao.address,
+      burnUnits,
+      toBN(0),
+      [], //empty token array
+      {
+        from: memberToKick,
+        gasPrice: toBN("0"),
+      }
+    );
+
+    expect(await bank.balanceOf(memberToKick, UNITS)).to.be.equal(
+      memberUnits.sub(burnUnits)
+    );
+
+    const { erc20Ext } = this.extensions;
     const erc20 = new Contract(
       erc20Ext.address,
       erc20Ext.abi,
       await hre.ethers.getSigner(newMember)
     );
 
+    // After the partial ragequit the member must be in jail
+    // so moving the funds are not allowed
     await expect(
       erc20.transfer(owner, 1, { from: memberToKick })
     ).to.be.revertedWith("no transfer from jail");

test/extensions/erc1155.test.js

@@ -493,24 +493,7 @@ describe("Extension - ERC1155", () => {
     );
     expect(owner.toLowerCase()).equal(GUILD);
 
-    await this.adapters.erc1155TestAdapter.internalTransfer(
-      this.dao.address,
-      erc1155TestToken.address,
-      id, //tokenId
-      1, //amount
-      { from: nftOwner }
-    );
-
     //internalTransfer should revert, because nonMember is not a member
-    await erc1155Adapter.internalTransfer(
-      this.dao.address,
-      nonMember,
-      erc1155TestToken.address,
-      id, //tokenId
-      1, //amount
-      { from: nftOwner }
-    );
-
     await expect(
       erc1155Adapter.internalTransfer(
         this.dao.address,

test/extensions/erc721.test.js

@@ -31,17 +31,30 @@ const {
   fromAscii,
   GUILD,
   ZERO_ADDRESS,
+  unitPrice,
+  UNITS,
 } = require("../../utils/contract-util");
 
 const {
   takeChainSnapshot,
   revertChainSnapshot,
   deployDefaultNFTDao,
+  proposalIdGenerator,
   getAccounts,
   web3,
 } = require("../../utils/hardhat-test-util");
 
-const { encodeDaoInfo } = require("../../utils/test-util");
+const {
+  encodeDaoInfo,
+  onboardingNewMember,
+  guildKickProposal,
+} = require("../../utils/test-util");
+
+const proposalCounter = proposalIdGenerator().generator;
+
+function getProposalCounter() {
+  return proposalCounter().next().value;
+}
 
 describe("Extension - ERC721", () => {
   let accounts, daoOwner;
@@ -283,6 +296,65 @@ describe("Extension - ERC721", () => {
     expect(nftId.toString()).equal(tokenId.toString());
   });
 
+  it("should not be possible to execute an internalTransfer if the nftOwner is in jail", async () => {
+    const jailedNftOwner = accounts[2];
+    const onboarding = this.adapters.onboarding;
+    const voting = this.adapters.voting;
+    const guildkickContract = this.adapters.guildkick;
+
+    await onboardingNewMember(
+      getProposalCounter(),
+      this.dao,
+      onboarding,
+      voting,
+      jailedNftOwner,
+      daoOwner,
+      unitPrice,
+      UNITS
+    );
+
+    // Start a new kick proposal
+    let memberToKick = jailedNftOwner;
+    let kickProposalId = getProposalCounter();
+
+    await guildKickProposal(
+      this.dao,
+      guildkickContract,
+      memberToKick,
+      daoOwner,
+      kickProposalId
+    );
+
+    const pixelNFT = this.testContracts.pixelNFT;
+    const nftExtension = this.extensions.erc721Ext;
+    const erc721TestAdapter = this.adapters.erc721TestAdapter;
+
+    // Add an NFT directly into the ERC721 extension to test the internal transfer
+    await pixelNFT.mintPixel(jailedNftOwner, 1, 1, { from: daoOwner });
+    let pastEvents = await pixelNFT.getPastEvents();
+    let { tokenId } = pastEvents[1].returnValues;
+
+    await pixelNFT.methods["safeTransferFrom(address,address,uint256,bytes)"](
+      jailedNftOwner,
+      nftExtension.address,
+      tokenId,
+      encodeDaoInfo(this.dao.address),
+      {
+        from: jailedNftOwner,
+      }
+    );
+
+    await expect(
+      erc721TestAdapter.internalTransfer(
+        this.dao.address,
+        daoOwner,
+        pixelNFT.address,
+        tokenId,
+        { from: jailedNftOwner }
+      )
+    ).to.be.revertedWith("member is jailed");
+  });
+
   it("should not be possible get an NFT in the collection if it is empty", async () => {
     const nftExtension = this.extensions.erc721Ext;
     const pixelNFT = this.testContracts.pixelNFT;