day24. hardhat – テスト –

// contracts/Funding.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;


error Funding__NotOwner();
error Funding__NotEnoughETH();


/**
 * @title A contract for crowdfunding
 * @author simochan
 * @notice This contract is to demo a sample funding contract
 */
contract Funding {
    // State variables
    address[] private s_funders;
    mapping(address => uint256) private s_addressToAmountFunded;
    address private immutable i_owner;

    // Event
    event Funded(address indexed funder, uint256 indexed fundedAmount);

    // Modifiers
    modifier onlyOwner() {
        if (msg.sender != i_owner) {
            revert Funding__NotOwner();
        }
        _;
    }

    constructor() {
        i_owner = msg.sender;
    }

    function fund() public payable {
        if(msg.value <= 100000000000000000) {
            revert Funding__NotEnoughETH();
        }
        s_funders.push(msg.sender);
        s_addressToAmountFunded[msg.sender] += msg.value;
        emit Funded(msg.sender, msg.value);
    }

    function withdraw() public onlyOwner {
        for (uint256 i = 0; i < s_funders.length; i++) {
            address funder = s_funders[i];
            s_addressToAmountFunded[funder] = 0;
        }
        s_funders = new address[](0);
        (bool success, ) = i_owner.call{value: address(this).balance}("");
        require(success);
    }

    function getOwner() public view returns (address) {
        return i_owner;
    }

    function getFunder(uint256 index) public view returns (address) {
        return s_funders[index];
    }

    function getAddressToAmountFunded(address funder) public view returns(uint256) {
        return s_addressToAmountFunded[funder];
    }
}

// test/unit/Funding.test.ts
import { SignerWithAddress } from "@nomicfoundation/hardhat-ethers/signers"
import { assert, expect } from "chai"
import { network, deployments, ethers } from "hardhat"
import { developmentChains } from "../../helper-hardhat-config"
import { Funding } from "../../typechain-types"

describe("Funding Unit Tests", function () {
    let funding: Funding // Fundingコントラクトを格納するための変数
    let deployer: SignerWithAddress // Fundingコントラクトをデプロイしたアカウント、deployerを格納するための変数
    beforeEach(async () => {
        if (!developmentChains.includes(network.name)) {
            throw "このテストは開発用のチェーンで動かす必要があります"
        }
        const accounts = await ethers.getSigners()
        deployer = accounts[0]
        await deployments.fixture(["all"])
        funding = await ethers.getContract("Funding")
    })

    describe("fund", function () {
        it("ETHの金額が少ない場合、失敗する", async () => {
            await expect(funding.fund()).to.be.revertedWith(
                "Funding__NotEnoughETH",
            )
        })

        it("出資金額が正しく保存される", async () => {
            await funding.fund({ value: ethers.parseEther("1.0") })
            const response = await funding.getAddressToAmountFunded(
                deployer.address,
            )
            assert.equal(
                response.toString(),
                ethers.parseEther("1.0").toString(),
            )
        })
    })

    describe("withdraw", function () {
        it("普通のユーザーはfundされた金額をwithdrawできない", async () => {
            const accounts = await ethers.getSigners()
            await funding
                .connect(accounts[1])
                .fund({ value: ethers.parseEther("1") })
            await expect(
                funding.connect(accounts[1]).withdraw(),
            ).to.be.revertedWith("Funding__NotOwner")
        })
        it("Contractの所有者はfundされた金額をwithdrawできる", async () => {
            const accounts = await ethers.getSigners()
            await funding.fund({ value: ethers.parseEther("1.0") })
            await funding
                .connect(accounts[1])
                .fund({ value: ethers.parseEther("1.0") })

            const initialContractBalance = await ethers.provider.getBalance(
                funding.getAddress(),
            )
            const initialDeployerBalance = await ethers.provider.getBalance(
                deployer.address,
            )
            const withdrawTxn = await funding.withdraw()
            const txnReceipt = await withdrawTxn.wait()
            const gasUsed = txnReceipt?.gasUsed
            const gasPrice = withdrawTxn.gasPrice
            const totalGasCost = gasUsed * gasPrice

            const finalContractBalance = await ethers.provider.getBalance(
                funding.getAddress(),
            )
            const finalDeployerBalance = await ethers.provider.getBalance(
                deployer.address,
            )
            assert.equal(finalContractBalance.toString(), "0")
            const expectedDeployerBalance =
                initialDeployerBalance + initialContractBalance - totalGasCost
            assert.equal(finalDeployerBalance, expectedDeployerBalance)
        })
    })

    describe("getOwner", function () {
        it("deployerのアドレスを正しく返す", async () => {
            const response = await funding.getOwner()
            assert.equal(response.toString(), deployer.address)
        })
    })

    describe("getFunder", function () {
        it("出資者のアドレスを正しく返す", async () => {
            await funding.fund({ value: ethers.parseEther("1.0") })
            const response = await funding.getFunder(0)
            assert.equal(response.toString(), deployer.address)
        })
    })

    describe("getAddressToAmountFunded", function () {
        it("出資された金額を正しく返す", async () => {
            await funding.fund({ value: ethers.parseEther("2.0") })
            const response = await funding.getAddressToAmountFunded(
                deployer.address,
            )
            assert.equal(
                response.toString(),
                ethers.parseEther("2.0").toString(),
            )
        })
    })
})

// test/unit/Funding.test.ts より抜粋
    beforeEach(async () => {
        if (!developmentChains.includes(network.name)) {
            throw "このテストは開発用のチェーンで動かす必要があります"
        }
        const accounts = await ethers.getSigners()
        deployer = accounts[0]
        await deployments.fixture(["all"])
        funding = await ethers.getContract("Funding")
    })

// test/unit/Funding.test.ts より抜粋
    describe("fund", function () {
        it("ETHの金額が少ない場合、失敗する", async () => {
            await expect(funding.fund()).to.be.revertedWith(
                "Funding__NotEnoughETH",
            )
        })

        it("出資金額が正しく保存される", async () => {
            await funding.fund({ value: ethers.parseEther("1.0") })
            const response = await funding.getAddressToAmountFunded(
                deployer.address,
            )
            assert.equal(
                response.toString(),
                ethers.parseEther("1.0").toString(),
            )
        })
    })

// test/unit/Funding.test.ts より抜粋
            const withdrawTxn = await funding.withdraw()
            const txnReceipt = await withdrawTxn.wait()
            const gasUsed = txnReceipt?.gasUsed
            const gasPrice = withdrawTxn.gasPrice
            const totalGasCost = gasUsed * gasPrice

# console
% yarn hardhat test # Unitテストを実行する
yarn run v1.22.19
$ /Users/username/code/token-village/funding/node_modules/.bin/hardhat test

  Funding Unit Tests
    fund
      ✓ ETHの金額が少ない場合、失敗する
      ✓ 出資金額が正しく保存される
    withdraw
      ✓ 普通のユーザーはfundされた金額をwithdrawできない
      ✓ Contractの所有者はfundされた金額をwithdrawできる
    getOwner
      ✓ deployerのアドレスを正しく返す
    getFunder
      ✓ 出資者のアドレスを正しく返す
    getAddressToAmountFunded
      ✓ 出資された金額を正しく返す


  7 passing (1s)

✨  Done in 4.56s.

// test/staging/Funding.staging.test.ts
import { assert } from "chai"
import { ethers, network } from "hardhat"
import { developmentChains } from "../../helper-hardhat-config"
import { SignerWithAddress } from "@nomicfoundation/hardhat-ethers/signers"
import { Funding } from "../../typechain-types"

developmentChains.includes(network.name)
    ? describe.skip
    : describe("Funding Staging Tests", async function () {
          let funding: Funding
          let deployer: SignerWithAddress

          const fundingAmount = ethers.parseEther("0.11")
          beforeEach(async function () {
              const accounts = await ethers.getSigners()
              deployer = accounts[0]
              funding = await ethers.getContract("Funding", deployer.address)
          })

          it("fundとwithdrawが実行できる", async function () {
              await funding.fund({ value: fundingAmount })
              await funding.withdraw({ gasLimit: 100000 })
              const finalContractBalance = await ethers.provider.getBalance(
                  funding.getAddress(),
              )
              console.log(finalContractBalance.toString() + "(=完了後のコントラクトの残高)は0と等しくなります")
              assert.equal(finalContractBalance.toString(), "0")
          })
      })

# console
% yarn hardhat deploy --network sepolia
yarn run v1.22.19
$ /Users/username/code/token-village/funding/node_modules/.bin/hardhat deploy --network sepolia
Nothing to compile
No need to generate any newer typings.
-----------------------------------------------------
Deploying Funding and waiting for confirmations...
deploying "Funding" (tx: 0xf2e83912e0e70c4df85a91d486c115054fe0c166d41f7f7124091c591cf2a793)...: deployed at 0xfb2Cfd85618Ba0Ba983aF6A45134A120905da0e5 with 538126 gas
Funding deployed at 0xfb2Cfd85618Ba0Ba983aF6A45134A120905da0e5
Verifying contract...
Nothing to compile
No need to generate any newer typings.
Successfully submitted source code for contract
contracts/Funding.sol:Funding at 0xfb2Cfd85618Ba0Ba983aF6A45134A120905da0e5
for verification on the block explorer. Waiting for verification result...

Successfully verified contract Funding on Etherscan.
https://sepolia.etherscan.io/address/0xfb2Cfd85618Ba0Ba983aF6A45134A120905da0e5#code
✨  Done in 87.84s.

# console
% yarn hardhat test --network sepolia --grep "Staging"
yarn run v1.22.19
$ /Users/username/code/token-village/funding/node_modules/.bin/hardhat test --network sepolia --grep Staging
Compiled 1 Solidity file successfully

  Funding Staging Tests
0(=完了後のコントラクトの残高)は0と等しくなります
    ✓ fundとwithdrawが実行できる


  1 passing (4m)

✨  Done in 244.94s.

% yarn hardhat coverage
yarn run v1.22.19
$ /Users/username/code/token-village/funding/node_modules/.bin/hardhat coverage

Version
=======
> solidity-coverage: v0.8.4

Instrumenting for coverage...
=============================

> Funding.sol

Compilation:
============

Generating typings for: 1 artifacts in dir: typechain-types for target: ethers-v6
Successfully generated 6 typings!
Compiled 1 Solidity file successfully

Network Info
============
> HardhatEVM: v2.17.1
> network:    hardhat



  Funding
    fund
      ✔ ETHの金額が少ない場合、失敗する (62ms)
      ✔ 出資金額が正しく保存される (39ms)
    withdraw
      ✔ 普通のユーザーはfundされた金額をwithdrawできない (42ms)
      ✔ Contractの所有者はfundされた金額をwithdrawできる (55ms)
    getOwner
      ✔ deployerのアドレスを正しく返す
    getFunder
      ✔ 出資者のアドレスを正しく返す
    getAddressToAmountFunded
      ✔ 出資された金額を正しく返す


  7 passing (683ms)

--------------|----------|----------|----------|----------|----------------|
File          |  % Stmts | % Branch |  % Funcs |  % Lines |Uncovered Lines |
--------------|----------|----------|----------|----------|----------------|
 contracts/   |      100 |     87.5 |      100 |      100 |                |
  Funding.sol |      100 |     87.5 |      100 |      100 |                |
--------------|----------|----------|----------|----------|----------------|
All files     |      100 |     87.5 |      100 |      100 |                |
--------------|----------|----------|----------|----------|----------------|

> Istanbul reports written to ./coverage/ and ./coverage.json
✨  Done in 7.96s.