cerc-io/ipld-eth-server
18
0
Fork 1
Code Issues 10 Pull Requests 1 Actions Packages Projects Releases 37 Wiki Activity

integration test: run integration tests in GA

Browse Source
This commit is contained in:
ramil 2021-04-19 14:43:21 +03:00
parent c813ff00f4
commit 50d53535bb
5 changed files with 185 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
.github/workflows/on-pr.yaml vendored
View File

@ -33,3 +33,27 @@ jobs:
run: | run: |
sleep 10 sleep 10
PGPASSWORD=password DATABASE_USER=vdbm DATABASE_PORT=8077 DATABASE_PASSWORD=password DATABASE_HOSTNAME=127.0.0.1 make test PGPASSWORD=password DATABASE_USER=vdbm DATABASE_PORT=8077 DATABASE_PASSWORD=password DATABASE_HOSTNAME=127.0.0.1 make test
integrationtest:
name: Run integration tests
env:
GOPATH: /tmp/go
strategy:
matrix:
go-version: [1.15.x]
os: [ubuntu-latest]
runs-on: ${{ matrix.os }}
steps:
- name: Create GOPATH
run: mkdir -p /tmp/go
- name: Install Go
uses: actions/setup-go@v2
with:
go-version: ${{ matrix.go-version }}
- uses: actions/checkout@v2
- name: Run database
run: docker-compose -f docker-compose.test.yml -f docker-compose.yml up -d db dapptools contract eth-server
- name: Test
run: |
sleep 10
make integrationtest

10
Makefile
View File

@ -67,11 +67,11 @@ test: | $(GINKGO) $(GOOSE)
integrationtest: | $(GINKGO) $(GOOSE) integrationtest: | $(GINKGO) $(GOOSE)
go vet ./... go vet ./...
go fmt ./... go fmt ./...
export PGPASSWORD=$(DATABASE_PASSWORD) #export PGPASSWORD=$(DATABASE_PASSWORD)
dropdb -h $(DATABASE_HOSTNAME) -p $(DATABASE_PORT) -U $(DATABASE_USER) --if-exists $(TEST_DB) #dropdb -h $(DATABASE_HOSTNAME) -p $(DATABASE_PORT) -U $(DATABASE_USER) --if-exists $(TEST_DB)
createdb -h $(DATABASE_HOSTNAME) -p $(DATABASE_PORT) -U $(DATABASE_USER) $(TEST_DB) #createdb -h $(DATABASE_HOSTNAME) -p $(DATABASE_PORT) -U $(DATABASE_USER) $(TEST_DB)
$(GOOSE) -dir db/migrations postgres "$(TEST_CONNECT_STRING)" up #$(GOOSE) -dir db/migrations postgres "$(TEST_CONNECT_STRING)" up
$(GINKGO) -r integration_test/ $(GINKGO) -r test/ -v
.PHONY: test_local .PHONY: test_local
test_local: | $(GINKGO) $(GOOSE) test_local: | $(GINKGO) $(GOOSE)

4
docker-compose.test.yml
View File

@ -7,8 +7,8 @@ services:
build: build:
context: ./test/contract context: ./test/contract
args: args:
ETH_ADDR: "http://192.168.192.4:8545" ETH_ADDR: "http://dapptools:8545"
environment: environment:
ETH_ADDR: "http://192.168.192.4:8545" ETH_ADDR: "http://dapptools:8545"
ports: ports:
- "127.0.0.1:3000:3000" - "127.0.0.1:3000:3000"

8
docker-compose.yml
View File

@ -4,7 +4,7 @@ services:
dapptools: dapptools:
restart: unless-stopped restart: unless-stopped
depends_on: depends_on:
- statediff-migrations - db
image: vulcanize/dapptools:v0.29.0-v1.10.2-statediff-0.0.19 image: vulcanize/dapptools:v0.29.0-v1.10.2-statediff-0.0.19
environment: environment:
DB_USER: vdbm DB_USER: vdbm
@ -41,6 +41,7 @@ services:
- "127.0.0.1:8077:5432" - "127.0.0.1:8077:5432"
eth-server: eth-server:
restart: unless-stopped
depends_on: depends_on:
- db - db
build: build:
@ -49,17 +50,16 @@ services:
- alpine:latest - alpine:latest
- golang:1.13-alpine - golang:1.13-alpine
environment: environment:
IPLD_SERVER_GRAPHQL: "true"
IPLD_POSTGRAPHILEPATH: http://graphql:5000
VDB_COMMAND: "serve" VDB_COMMAND: "serve"
DATABASE_NAME: "vulcanize_public" DATABASE_NAME: "vulcanize_public"
DATABASE_HOSTNAME: "db" DATABASE_HOSTNAME: "db"
DATABASE_PORT: 5432 DATABASE_PORT: 5432
DATABASE_USER: "vdbm" DATABASE_USER: "vdbm"
DATABASE_PASSWORD: "password" DATABASE_PASSWORD: "password"
SERVER_WS_PATH: "0.0.0.0:8081"
SERVER_HTTP_PATH: "0.0.0.0:8082"
ports: ports:
- "127.0.0.1:8080:8080" - "127.0.0.1:8080:8080"
- "127.0.0.1:8081:8081"
graphql: graphql:
restart: unless-stopped restart: unless-stopped

274
test/integration_test.go
View File

@ -2,11 +2,11 @@ package integration_test
import ( import (
"context" "context"
"fmt"
"github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types" //"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/rlp" //"github.com/ethereum/go-ethereum/common"
//"github.com/ethereum/go-ethereum/rlp"
. "github.com/onsi/ginkgo" . "github.com/onsi/ginkgo"
. "github.com/onsi/gomega" . "github.com/onsi/gomega"
integration "github.com/vulcanize/ipld-eth-server/test" integration "github.com/vulcanize/ipld-eth-server/test"
@ -32,138 +32,164 @@ var _ = Describe("Integration test", func() {
Describe("get Block", func() { Describe("get Block", func() {
contract, contractErr = integration.DeployContract() contract, contractErr = integration.DeployContract()
It("get block by number", func() { It("get not existing block by number", func() {
Expect(contractErr).ToNot(HaveOccurred()) Expect(contractErr).ToNot(HaveOccurred())
blockNum := contract.BlockNumber blockNum := contract.BlockNumber + 100
gethBlock, err := gethClient.BlockByNumber(ctx, big.NewInt(int64(blockNum))) gethBlock, err := gethClient.BlockByNumber(ctx, big.NewInt(int64(blockNum)))
Expect(err).ToNot(HaveOccurred()) Expect(err).To(MatchError(ethereum.NotFound))
Expect(gethBlock).To(BeZero())
ipldBlock, err := ipldClient.BlockByNumber(ctx, big.NewInt(int64(blockNum))) ipldBlock, err := ipldClient.BlockByNumber(ctx, big.NewInt(int64(blockNum)))
Expect(err).ToNot(HaveOccurred()) Expect(err).To(MatchError(ethereum.NotFound))
Expect(ipldBlock).To(BeZero())
// check headers are equals
Expect(gethBlock.Header()).To(Equal(ipldBlock.Header()))
gethTxs := gethBlock.Transactions()
ipldTxs := ipldBlock.Transactions()
Expect(gethTxs.Len()).To(Equal(ipldTxs.Len()))
Expect(types.TxDifference(gethTxs, ipldTxs).Len()).To(Equal(0))
}) })
It("get block by hash", func() { It("get not existing block by hash", func() {
nonExistingBlockHash := "0x111111111111111111111111111111111111111111111111111111111111111"
gethBlock, err := gethClient.BlockByHash(ctx, common.HexToHash(contract.BlockHash)) gethBlock, err := gethClient.BlockByHash(ctx, common.HexToHash(nonExistingBlockHash))
fmt.Printf("contract info: %+v", contract) Expect(err).To(MatchError(ethereum.NotFound))
Expect(err).ToNot(HaveOccurred()) Expect(gethBlock).To(BeZero())
ipldBlock, err := ipldClient.BlockByHash(ctx, common.HexToHash(contract.BlockHash)) ipldBlock, err := ipldClient.BlockByHash(ctx, common.HexToHash(nonExistingBlockHash))
Expect(err).ToNot(HaveOccurred()) Expect(err).To(MatchError(ethereum.NotFound))
Expect(ipldBlock).To(BeZero())
// check headers are equals
Expect(gethBlock).To(Equal(ipldBlock))
Expect(gethBlock.Header()).To(Equal(ipldBlock.Header()))
gethTxs := gethBlock.Transactions()
ipldTxs := ipldBlock.Transactions()
Expect(gethTxs.Len()).To(Equal(ipldTxs.Len()))
Expect(types.TxDifference(gethTxs, ipldTxs).Len()).To(Equal(0))
}) })
//It("get block by number", func() {
// Expect(contractErr).ToNot(HaveOccurred())
//
// blockNum := contract.BlockNumber
//
// gethBlock, err := gethClient.BlockByNumber(ctx, big.NewInt(int64(blockNum)))
// Expect(err).ToNot(HaveOccurred())
//
// ipldBlock, err := ipldClient.BlockByNumber(ctx, big.NewInt(int64(blockNum)))
// Expect(err).ToNot(HaveOccurred())
//
// // check headers are equals
// Expect(gethBlock.Header()).To(Equal(ipldBlock.Header()))
//
// gethTxs := gethBlock.Transactions()
// ipldTxs := ipldBlock.Transactions()
//
// Expect(gethTxs.Len()).To(Equal(ipldTxs.Len()))
// Expect(types.TxDifference(gethTxs, ipldTxs).Len()).To(Equal(0))
//})
//
//It("get block by hash", func() {
//
// gethBlock, err := gethClient.BlockByHash(ctx, common.HexToHash(contract.BlockHash))
// fmt.Printf("contract info: %+v", contract)
// Expect(err).ToNot(HaveOccurred())
//
// ipldBlock, err := ipldClient.BlockByHash(ctx, common.HexToHash(contract.BlockHash))
// Expect(err).ToNot(HaveOccurred())
//
// // check headers are equals
// Expect(gethBlock).To(Equal(ipldBlock))
// Expect(gethBlock.Header()).To(Equal(ipldBlock.Header()))
//
// gethTxs := gethBlock.Transactions()
// ipldTxs := ipldBlock.Transactions()
//
// Expect(gethTxs.Len()).To(Equal(ipldTxs.Len()))
// Expect(types.TxDifference(gethTxs, ipldTxs).Len()).To(Equal(0))
//})
}) })
Describe("Transaction", func() { //Describe("Transaction", func() {
txHash := "0xdb3d5ef2d4e3260e1b8c1bcbb09b2d8fe7a6423196a20b8a3fa6c09dd9d79073" // txHash := "0xdb3d5ef2d4e3260e1b8c1bcbb09b2d8fe7a6423196a20b8a3fa6c09dd9d79073"
blockHash := "0xb821ca79bd37174368073e469db92ead75148a95f7c24c49f2435fb7c7797588" // blockHash := "0xb821ca79bd37174368073e469db92ead75148a95f7c24c49f2435fb7c7797588"
//
It("Get tx by hash", func() { // It("Get tx by hash", func() {
gethTx, _, err := gethClient.TransactionByHash(ctx, common.HexToHash(txHash)) // gethTx, _, err := gethClient.TransactionByHash(ctx, common.HexToHash(txHash))
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
ipldTx, _, err := ipldClient.TransactionByHash(ctx, common.HexToHash(txHash)) // ipldTx, _, err := ipldClient.TransactionByHash(ctx, common.HexToHash(txHash))
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
Expect(gethTx).To(Equal(ipldTx)) // Expect(gethTx).To(Equal(ipldTx))
//
Expect(gethTx.Hash()).To(Equal(ipldTx.Hash())) // Expect(gethTx.Hash()).To(Equal(ipldTx.Hash()))
}) // })
//
It("Get tx by block hash and index", func() { // It("Get tx by block hash and index", func() {
gethTx, err := gethClient.TransactionInBlock(ctx, common.HexToHash(blockHash), 0) // gethTx, err := gethClient.TransactionInBlock(ctx, common.HexToHash(blockHash), 0)
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
ipldTx, err := ipldClient.TransactionInBlock(ctx, common.HexToHash(blockHash), 0) // ipldTx, err := ipldClient.TransactionInBlock(ctx, common.HexToHash(blockHash), 0)
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
Expect(gethTx).To(Equal(ipldTx)) // Expect(gethTx).To(Equal(ipldTx))
//
Expect(gethTx.Hash()).To(Equal(ipldTx.Hash())) // Expect(gethTx.Hash()).To(Equal(ipldTx.Hash()))
}) // })
//
}) //})
//
Describe("Receipt", func() { //Describe("Receipt", func() {
txHash := "0xdb3d5ef2d4e3260e1b8c1bcbb09b2d8fe7a6423196a20b8a3fa6c09dd9d79073" // txHash := "0xdb3d5ef2d4e3260e1b8c1bcbb09b2d8fe7a6423196a20b8a3fa6c09dd9d79073"
//
It("Get tx receipt", func() { // It("Get tx receipt", func() {
gethReceipt, err := gethClient.TransactionReceipt(ctx, common.HexToHash(txHash)) // gethReceipt, err := gethClient.TransactionReceipt(ctx, common.HexToHash(txHash))
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
ipldReceipt, err := ipldClient.TransactionReceipt(ctx, common.HexToHash(txHash)) // ipldReceipt, err := ipldClient.TransactionReceipt(ctx, common.HexToHash(txHash))
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
Expect(gethReceipt).To(Equal(ipldReceipt)) // Expect(gethReceipt).To(Equal(ipldReceipt))
//
rlpGeth, err := rlp.EncodeToBytes(gethReceipt) // rlpGeth, err := rlp.EncodeToBytes(gethReceipt)
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
rlpIpld, err := rlp.EncodeToBytes(ipldReceipt) // rlpIpld, err := rlp.EncodeToBytes(ipldReceipt)
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
Expect(rlpGeth).To(Equal(rlpIpld)) // Expect(rlpGeth).To(Equal(rlpIpld))
}) // })
}) //})
//
Describe("FilterLogs", func() { //Describe("FilterLogs", func() {
//txHash := "0xdb3d5ef2d4e3260e1b8c1bcbb09b2d8fe7a6423196a20b8a3fa6c09dd9d79073" // //txHash := "0xdb3d5ef2d4e3260e1b8c1bcbb09b2d8fe7a6423196a20b8a3fa6c09dd9d79073"
//blockHash := "0xb821ca79bd37174368073e469db92ead75148a95f7c24c49f2435fb7c7797588" // //blockHash := "0xb821ca79bd37174368073e469db92ead75148a95f7c24c49f2435fb7c7797588"
blockHash := common.HexToHash( // blockHash := common.HexToHash(
"0xb821ca79bd37174368073e469db92ead75148a95f7c24c49f2435fb7c7797588", // "0xb821ca79bd37174368073e469db92ead75148a95f7c24c49f2435fb7c7797588",
) // )
//
It("with blockhash", func() { // It("with blockhash", func() {
filterQuery := ethereum.FilterQuery{ // filterQuery := ethereum.FilterQuery{
//Addresses: addresses, // //Addresses: addresses,
BlockHash: &blockHash, // BlockHash: &blockHash,
Topics: [][]common.Hash{}, // Topics: [][]common.Hash{},
} // }
//
gethLogs, err := gethClient.FilterLogs(ctx, filterQuery) // gethLogs, err := gethClient.FilterLogs(ctx, filterQuery)
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
ipldLogs, err := ipldClient.FilterLogs(ctx, filterQuery) // ipldLogs, err := ipldClient.FilterLogs(ctx, filterQuery)
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
// not empty list // // not empty list
Expect(gethLogs).ToNot(BeEmpty()) // Expect(gethLogs).ToNot(BeEmpty())
//
Expect(len(gethLogs)).To(Equal(len(ipldLogs))) // Expect(len(gethLogs)).To(Equal(len(ipldLogs)))
Expect(gethLogs).To(Equal(ipldLogs)) // Expect(gethLogs).To(Equal(ipldLogs))
}) // })
}) //})
//
Describe("CodeAt", func() { //Describe("CodeAt", func() {
contractAddress := "0xdEE08501Ef5b68339ca920227d6520A10B72b65b" // contractAddress := "0xdEE08501Ef5b68339ca920227d6520A10B72b65b"
It("Get code of deployed contract without block number", func() { // It("Get code of deployed contract without block number", func() {
gethCode, err := gethClient.CodeAt(ctx, common.HexToAddress(contractAddress), nil) // gethCode, err := gethClient.CodeAt(ctx, common.HexToAddress(contractAddress), nil)
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
ipldCode, err := ipldClient.CodeAt(ctx, common.HexToAddress(contractAddress), nil) // ipldCode, err := ipldClient.CodeAt(ctx, common.HexToAddress(contractAddress), nil)
Expect(err).ToNot(HaveOccurred()) // Expect(err).ToNot(HaveOccurred())
//
Expect(gethCode).To(Equal(ipldCode)) // Expect(gethCode).To(Equal(ipldCode))
}) // })
}) //})
}) })