🌯 wrapped ether tests added

Author: vm06007

contracts/WrappedEther.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: BCOM
+
+pragma solidity ^0.8.8;
+
+contract WrappedEther {
+
+    string public name = "Wrapped Ether";
+    string public symbol = "WETH";
+    uint8  public decimals = 18;
+
+    event Approval(
+        address indexed src,
+        address indexed guy,
+        uint256 wad
+    );
+
+    event Transfer(
+        address indexed src,
+        address indexed dst,
+        uint256 wad
+    );
+
+    event Deposit(
+        address indexed dst,
+        uint256 wad
+    );
+
+    event Withdrawal(
+        address indexed src,
+        uint256 wad
+    );
+
+    mapping (address => uint256) public balanceOf;
+    mapping (address => mapping (address => uint256)) public allowance;
+
+    receive() external payable {
+        deposit();
+    }
+
+    function deposit()
+        public
+        payable
+    {
+        balanceOf[msg.sender] =
+        balanceOf[msg.sender] + msg.value;
+
+        emit Deposit(
+            msg.sender,
+            msg.value
+        );
+    }
+
+    function withdraw(
+        uint256 _wad
+    )
+        public
+    {
+        balanceOf[msg.sender] =
+        balanceOf[msg.sender] - _wad;
+
+        payable(msg.sender).transfer(_wad);
+
+        emit Withdrawal(
+            msg.sender,
+            _wad
+        );
+    }
+
+    function totalSupply()
+        public
+        view
+        returns (uint256)
+    {
+        return address(this).balance;
+    }
+
+    function approve(
+        address _guy,
+        uint256 _wad
+    )
+        public
+        returns (bool)
+    {
+        allowance[msg.sender][_guy] = _wad;
+        emit Approval(msg.sender, _guy, _wad);
+        return true;
+    }
+
+    function transfer(
+        address dst,
+        uint wad
+    )
+        public
+        returns (bool)
+    {
+        return transferFrom(
+            msg.sender,
+            dst,
+            wad
+        );
+    }
+
+    function transferFrom(
+        address src,
+        address dst,
+        uint256 wad
+    )
+        public
+        returns (bool)
+    {
+        allowance[src][msg.sender] =
+        allowance[src][msg.sender] - wad;
+
+        balanceOf[src] =
+        balanceOf[src] - wad;
+
+        balanceOf[dst] =
+        balanceOf[dst] - wad;
+
+        emit Transfer(
+            src,
+            dst,
+            wad
+        );
+
+        return true;
+    }
+}

coverage.json

@@ -22,6 +22,7 @@
 		"compile": "truffle compile",
         "test-token": "npx truffle test test/token.test.js",
         "test-swaps": "npx truffle test test/swaps.test.js",
+        "test-wraps": "npx truffle test test/wraps.test.js",
 		"test-coverage": "npx truffle run coverage --network development",
         "flat-file": "cd contracts && truffle-flattener fileName.sol > ../flats/fileName.sol",
 		"docs": "oz-docs",

package.json

@@ -0,0 +1,107 @@
+const Weth = artifacts.require("WrappedEther");
+const catchRevert = require("./exceptionsHelpers.js").catchRevert;
+require("./utils");
+const BN = web3.utils.BN;
+
+const FOUR_ETH = web3.utils.toWei("4");
+const FIVE_ETH = web3.utils.toWei("5");
+const NINE_ETH = web3.utils.toWei("9");
+
+const getLastEvent = async (eventName, instance) => {
+    const events = await instance.getPastEvents(eventName, {
+        fromBlock: 0,
+        toBlock: "latest",
+    });
+    return events.pop().returnValues;
+};
+
+contract("Weth", ([owner, alice, bob, random]) => {
+
+    let weth;
+
+    before(async () => {
+        weth = await Weth.new();
+    });
+
+    describe("Deposit functionality", () => {
+
+        it("should credit correct amount when deposited", async () => {
+
+            const amount = FOUR_ETH;
+
+            await weth.deposit({
+                value: amount,
+                from: alice
+            });
+
+            balance = await weth.balanceOf(alice);
+
+            assert.equal(
+                balance,
+                amount
+            );
+        });
+
+        it("should emit correct deposit event", async () => {
+
+            const amount = FIVE_ETH;
+
+            await weth.deposit({
+                value: amount,
+                from: alice
+            });
+
+            const { dst, wad } = await getLastEvent(
+                "Deposit",
+                weth
+            );
+
+            assert.equal(
+                alice,
+                dst
+            );
+
+            assert.equal(
+                amount,
+                wad
+            );
+        });
+
+        it("should allow to deposit through direct transfer", async () => {
+
+            const amount = NINE_ETH;
+
+            await weth.send(amount, {
+                from: bob
+            });
+
+            balance = await weth.balanceOf(bob);
+
+            assert.equal(
+                balance,
+                amount
+            );
+        });
+    });
+
+    describe("Withdraw functionality", () => {
+
+        it("should give back correct amount", async () => {
+        });
+
+        it("should emit withdraw event", async () => {
+        });
+    });
+
+    describe.skip("Transfer functionality", () => {
+
+        it("should allow to transfer WETH token between accounts", async () => {
+        });
+
+        it("should be able to use approve/allowance", async () => {
+        });
+
+        it("should be able to use transferFrom", async () => {
+        });
+    });
+});

test/wraps.test.js

@@ -1,8 +1,8 @@
 pragma solidity ^0.4.18;
 
 contract WETH9 {
-    string public name     = "Wrapped Ether";
-    string public symbol   = "WETH";
+    string public name = "Wrapped Ether";
+    string public symbol = "WETH";
     uint8  public decimals = 18;
 
     event  Approval(address indexed src, address indexed guy, uint wad);