TESTS FOR MY ERC20 TOKEN IS NOT WORKING

[UncleKweks]

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";

contract GNairaToken is ERC20, ERC20Capped, ERC20Burnable {
    address payable public owner;
    uint256 public blockReward;

    constructor(
        uint256 cap,
        uint256 reward
    ) ERC20("GNairaToken", "gNGN") ERC20Capped(cap * (10 ** decimals())) {
        owner = payable(msg.sender);
        _mint(owner, 3000000000000 * (10 ** decimals()));
        blockReward = reward * (10 ** decimals());
    }

    function _update(
        address from,
        address to,
        uint256 value
    ) internal virtual override(ERC20, ERC20Capped) {
        super._update(from, to, value);
        if (from == address(0)) {
            uint256 maxSupply = cap();
            uint256 supply = totalSupply();
            if (supply > maxSupply) {
                revert ERC20ExceededCap(supply, maxSupply);
            }
        }
    }

    function _mintMinerReward() internal {
        _mint(block.coinbase, blockReward);
    }

    function setBlockReward(uint256 reward) public onlyOwner {
        blockReward = reward * (10 ** decimals());
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 value
    ) internal virtual {
        if (
            from != address(0) &&
            to != block.coinbase &&
            block.coinbase != address(0)
        ) {
            _mintMinerReward();
        }
        super._update(from, to, value);
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function!");
        _;
    }
}

const { expect } = require("chai");
const hre = require("hardhat");

describe("GNairaToken contract", function () {
  // global vars
  let Token;
  let GNairaToken;
  let owner;
  let addr1;
  let addr2;
  let tokenCap = 30000000000000;
  let tokenBlockReward = 19019;

  beforeEach(async function () {
    // Get the ContractFactory and Signers here.
    Token = await ethers.getContractFactory("GNairaToken");
    [owner, addr1, addr2] = await hre.ethers.getSigners();

    GNairaToken = await Token.deploy(tokenCap, tokenBlockReward);
  });

  describe("Deployment", function () {
    it("Should set the right owner", async function () {
      expect(await GNairaToken.owner()).to.equal(owner.address);
    });

    it("Should assign the total supply of tokens to the owner", async function () {
      const ownerBalance = await GNairaToken.balanceOf(owner.address);
      expect(await oceanToken.totalSupply()).to.equal(ownerBalance);
    });

    it("Should set the max capped supply to the argument provided during deployment", async function () {
      const cap = await GNairaToken.cap();
      expect(Number(hre.ethers.utils.formatEther(cap))).to.equal(tokenCap);
    });

    it("Should set the blockReward to the argument provided during deployment", async function () {
      const blockReward = await GNairaToken.blockReward();
      expect(Number(hre.ethers.utils.formatEther(blockReward))).to.equal(
        tokenBlockReward
      );
    });
  });

  describe("Transactions", function () {
    it("Should transfer tokens between accounts", async function () {
      // Transfer 50 tokens from owner to addr1
      await GNairaToken.transfer(addr1.address, 50);
      const addr1Balance = await oceanToken.balanceOf(addr1.address);
      expect(addr1Balance).to.equal(50);

      // Transfer 50 tokens from addr1 to addr2
      // We use .connect(signer) to send a transaction from another account
      await GNairaToken.connect(addr1).transfer(addr2.address, 50);
      const addr2Balance = await GNairaToken.balanceOf(addr2.address);
      expect(addr2Balance).to.equal(50);
    });

    it("Should fail if sender doesn't have enough tokens", async function () {
      const initialOwnerBalance = await GNairaToken.balanceOf(owner.address);
      // Try to send 1 token from addr1 (0 tokens) to owner (1000000 tokens).
      // `require` will evaluate false and revert the transaction.
      await expect(
        GNairaToken.connect(addr1).transfer(owner.address, 1)
      ).to.be.revertedWith("ERC20: transfer amount exceeds balance");

      // Owner balance shouldn't have changed.
      expect(await GNairaToken.balanceOf(owner.address)).to.equal(
        initialOwnerBalance
      );
    });

    it("Should update balances after transfers", async function () {
      const initialOwnerBalance = await GNairaToken.balanceOf(owner.address);

      // Transfer 100 tokens from owner to addr1.
      await GNairaToken.transfer(addr1.address, 100);

      // Transfer another 50 tokens from owner to addr2.
      await GNairaToken.transfer(addr2.address, 50);

      // Check balances.
      const finalOwnerBalance = await GNairaToken.balanceOf(owner.address);
      expect(finalOwnerBalance).to.equal(initialOwnerBalance.sub(150));

      const addr1Balance = await GNairaToken.balanceOf(addr1.address);
      expect(addr1Balance).to.equal(100);

      const addr2Balance = await GNairaToken.balanceOf(addr2.address);
      expect(addr2Balance).to.equal(50);
    });
  });
});

Hello everyone. Complete noob here(still in my early learning phase). Copied this code(s) off the github repo of the course I am learning with. I made a few adjustments here and there and tested my code. 2 out of 7 are passing, this 5 are failing. Anybody knows why? I'd appreciate all the help I can get

1. GNairaToken contract
   Deployment
   Should set the max capped supply to the argument provided during deployment:
   TypeError: Cannot read properties of undefined (reading 'formatEther')
   at Context. (test\GNairaToken.js:34:38)

2. GNairaToken contract
   Deployment
   Should set the blockReward to the argument provided during deployment:
   TypeError: Cannot read properties of undefined (reading 'formatEther')
   at Context. (test\GNairaToken.js:39:38)

3. GNairaToken contract
   Transactions
   Should transfer tokens between accounts:
   ReferenceError: oceanToken is not defined
   at Context. (test\GNairaToken.js:49:28)

4. GNairaToken contract
   Transactions
   Should fail if sender doesn't have enough tokens:
   AssertionError: Expected transaction to be reverted with reason 'ERC20: transfer amount exceeds balance', but it reverted with a custom error
   at Context. (test\GNairaToken.js:63:7)

5. GNairaToken contract
   Transactions
   Should update balances after transfers:
   TypeError: initialOwnerBalance.sub is not a function
   at Context. (test\GNairaToken.js:84:62)

[EngrPips]

Hello @UncleKweks, All of these tests failed for apparent reasons. I will advise you to read the error messages to help you resolve the issues. If you don't know how to resolve a failed test by reading and understanding the test error message then I will advise that you take Cyfrin foundry-full-course (https://updraft.cyfrin.io/courses/foundry)