Add integration tests

pkg/validator/validator.go

@@ -98,6 +98,9 @@ func (s *service) Start(ctx context.Context, wg *sync.WaitGroup) {
 		select {
 		case <-s.quitChan:
 			s.logger.Infof("last validated block %v", idxBlockNum-1)
+			if s.progressChan != nil {
+				close(s.progressChan)
+			}
 			return
 		default:
 			idxBlockNum, err = s.Validate(ctx, api, idxBlockNum)
@@ -113,9 +116,6 @@ func (s *service) Start(ctx context.Context, wg *sync.WaitGroup) {
 // Stop is used to gracefully stop the service
 func (s *service) Stop() {
 	s.logger.Info("stopping ipld-eth-db-validator process")
-	if s.progressChan != nil {
-		close(s.progressChan)
-	}
 	close(s.quitChan)
 }
 

test/contract/contracts/Test.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.0;
+
+contract Test {
+  address payable owner;
+
+  modifier onlyOwner {
+    require(
+      msg.sender == owner,
+      "Only owner can call this function."
+    );
+    _;
+  }
+
+  uint256[100] data;
+
+  constructor() {
+    owner = payable(msg.sender);
+    data = [1];
+  }
+
+  function Put(uint256 addr, uint256 value) public {
+    data[addr] = value;
+  }
+
+  function close() public onlyOwner {
+    selfdestruct(owner);
+  }
+}

test/contract/src/index.js

@@ -63,6 +63,49 @@ fastify.get('/v1/sendEth', async (req, reply) => {
     }
 });
 
+fastify.get('/v1/deployTestContract', async (req, reply) => {
+    const testContract = await hre.ethers.getContractFactory("Test");
+    const test = await testContract.deploy();
+    await test.deployed();
+
+    return {
+        address: test.address,
+        txHash: test.deployTransaction.hash,
+        blockNumber: test.deployTransaction.blockNumber,
+        blockHash: test.deployTransaction.blockHash,
+    }
+});
+
+fastify.get('/v1/putTestValue', async (req, reply) => {
+    const addr = req.query.addr;
+    const index = req.query.index;
+    const value = req.query.value;
+
+    const testContract = await hre.ethers.getContractFactory("Test");
+    const test = await testContract.attach(addr);
+
+    const tx = await test.Put(index, value);
+    const receipt = await tx.wait();
+
+    return {
+        blockNumber: receipt.blockNumber,
+    }
+});
+
+fastify.get('/v1/destroyTestContract', async (req, reply) => {
+    const addr = req.query.addr;
+
+    const testContract = await hre.ethers.getContractFactory("Test");
+    const test = await testContract.attach(addr);
+
+    await test.destroy();
+    const blockNum = await hre.ethers.provider.getBlockNumber()
+
+    return {
+        blockNumber: blockNum,
+    }
+})
+
 async function main() {
     try {
         await fastify.listen(3000, '0.0.0.0');
@@ -72,4 +115,4 @@ async function main() {
     }
 }
 
-main();
+main();

test/helper.go

@@ -0,0 +1,54 @@
+package integration
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	ethServerIntegration "github.com/vulcanize/ipld-eth-server/v3/test"
+)
+
+type PutResult struct {
+	BlockNumber int64 `json:"blockNumber"`
+}
+
+const srvUrl = "http://localhost:3000"
+
+func DeployTestContract() (*ethServerIntegration.ContractDeployed, error) {
+	ethServerIntegration.DeployContract()
+	res, err := http.Get(fmt.Sprintf("%s/v1/deployTestContract", srvUrl))
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	var contract ethServerIntegration.ContractDeployed
+	decoder := json.NewDecoder(res.Body)
+
+	return &contract, decoder.Decode(&contract)
+}
+
+func PutTestValue(addr string, index, value int) (*PutResult, error) {
+	res, err := http.Get(fmt.Sprintf("%s/v1/putTestValue?addr=%s&index=%d&value=%d", srvUrl, addr, index, value))
+	if err != nil {
+		return nil, err
+	}
+
+	var blockNumber PutResult
+	decoder := json.NewDecoder(res.Body)
+
+	return &blockNumber, decoder.Decode(&blockNumber)
+}
+
+func DestroyTestContract(addr string) (*ethServerIntegration.ContractDestroyed, error) {
+	res, err := http.Get(fmt.Sprintf("%s/v1/destroyTestContract?addr=%s", srvUrl, addr))
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	var data ethServerIntegration.ContractDestroyed
+	decoder := json.NewDecoder(res.Body)
+
+	return &data, decoder.Decode(&data)
+}

test/integration_test.go

@@ -9,9 +9,10 @@ import (
 	. "github.com/onsi/gomega"
 
 	"github.com/vulcanize/ipld-eth-db-validator/pkg/validator"
+	integration "github.com/vulcanize/ipld-eth-db-validator/test"
 
 	"github.com/vulcanize/ipld-eth-server/v3/pkg/shared"
-	integration "github.com/vulcanize/ipld-eth-server/v3/test"
+	ethServerIntegration "github.com/vulcanize/ipld-eth-server/v3/test"
 )
 
 const (
@@ -19,12 +20,28 @@ const (
 	validatorSleepInterval = uint(5)
 )
 
+var (
+	testAddresses = []string{
+		"0x1111111111111111111111111111111111111112",
+		"0x1ca7c995f8eF0A2989BbcE08D5B7Efe50A584aa1",
+		"0x9a4b666af23a2cdb4e5538e1d222a445aeb82134",
+		"0xF7C7AEaECD2349b129d5d15790241c32eeE4607B",
+		"0x992b6E9BFCA1F7b0797Cee10b0170E536EAd3532",
+		"0x29ed93a7454Bc17a8D4A24D0627009eE0849B990",
+		"0x66E3dCA826b04B5d4988F7a37c91c9b1041e579D",
+		"0x96288939Ac7048c27E0E087b02bDaad3cd61b37b",
+		"0xD354280BCd771541c935b15bc04342c26086FE9B",
+		"0x7f887e25688c274E77b8DeB3286A55129B55AF14",
+	}
+)
+
 var _ = Describe("Integration test", func() {
 	ctx := context.Background()
 
-	var contract *integration.ContractDeployed
+	var contract *ethServerIntegration.ContractDeployed
-	var contractErr error
+	var err error
-	sleepInterval := 5 * time.Second
+	sleepInterval := 2 * time.Second
+	timeout := 4 * time.Second
 
 	db := shared.SetupDB()
 	validationProgressChan := make(chan uint64)
@@ -35,6 +52,10 @@ var _ = Describe("Integration test", func() {
 	It("test init", func() {
 		wg.Add(1)
 		go service.Start(ctx, wg)
+
+		// Deploy a dummy contract as the first contract might get deployed at block number 0
+		_, _ = ethServerIntegration.DeployContract()
+		time.Sleep(sleepInterval)
 	})
 
 	defer It("test teardown", func() {
@@ -45,20 +66,35 @@ var _ = Describe("Integration test", func() {
 	})
 
 	Describe("Validate state", func() {
-		BeforeEach(func() {
+		It("performs validation on contract deployment", func() {
-			// Deploy a dummy contract as the first contract might get deployed at block number 0
+			contract, err = integration.DeployTestContract()
-			_, _ = integration.DeployContract()
+			Expect(err).ToNot(HaveOccurred())
 			time.Sleep(sleepInterval)
 
-			contract, contractErr = integration.DeployContract()
-			time.Sleep(sleepInterval)
-		})
-
-		It("performs state root validation", func() {
-			Expect(contractErr).ToNot(HaveOccurred())
-
 			Expect(validationProgressChan).ToNot(BeClosed())
-			Eventually(validationProgressChan).Should(Receive(Equal(uint64(contract.BlockNumber))))
+			Eventually(validationProgressChan, timeout).Should(Receive(Equal(uint64(contract.BlockNumber))))
+		})
+
+		It("performs validation on contract transactions", func() {
+			for i := 0; i < 10; i++ {
+				res, txErr := integration.PutTestValue(contract.Address, i, i)
+				Expect(txErr).ToNot(HaveOccurred())
+				time.Sleep(sleepInterval)
+
+				Expect(validationProgressChan).ToNot(BeClosed())
+				Eventually(validationProgressChan, timeout).Should(Receive(Equal(uint64(res.BlockNumber))))
+			}
+		})
+
+		It("performs validation on eth transfer transactions", func() {
+			for _, address := range testAddresses {
+				tx, txErr := ethServerIntegration.SendEth(address, "0.01")
+				Expect(txErr).ToNot(HaveOccurred())
+				time.Sleep(sleepInterval)
+
+				Expect(validationProgressChan).ToNot(BeClosed())
+				Eventually(validationProgressChan, timeout).Should(Receive(Equal(uint64(tx.BlockNumber))))
+			}
 		})
 	})
 })