Skip to content

Commit

Permalink
update tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@pavelkrolevets
pavelkrolevets committed Sep 5, 2023
1 parent 299f493 commit 5aa4e19
Show file tree
Hide file tree
Showing 4 changed files with 151 additions and 219 deletions.
4 changes: 2 additions & 2 deletions config/initiator.yaml
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
threshold: 4
threshold: 3
operatorIDs: [1, 2, 3, 4]
withdrawAddress: "0100000000000000000000001d2f14d2dffee594b4093d42e4bc1b0ea55e8aa7"
withdrawAddress: "0x0000000000000000000000000000000000000009"
owner: "0x81592c3de184a3e2c0dcb5a261bc107bfa91f494"
nonce: 4
fork: "00000000"
Expand Down
173 changes: 59 additions & 114 deletions pkgs/client/client_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -46,109 +46,61 @@ const operatorsMetaData = `[

const exmaplePath = "../../examples/"


func TestHappyFlow(t *testing.T) {
func TestClientAtOperatorMisbehave(t *testing.T) {
logger := logrus.NewEntry(logrus.New())
eg := errgroup.Group{}
srv2 := CreateTestServer(t, 2)
srv3 := CreateTestServer(t, 3)
srv4 := CreateTestServer(t, 4)
eg.Go(func() error {
return srv2.Start(3031)
})
eg.Go(func() error {
return srv3.Start(3032)
})
eg.Go(func() error {
return srv4.Start(3033)
})
logger.Infof("Servers created")
t.Run("test wrong server key", func(t *testing.T) {
logger := logrus.NewEntry(logrus.New())
logger.Infof("Starting intg test")
srv1 := CreateTestServerRandomKey(t, 1)
srv2 := CreateTestServer(t, 2)
srv3 := CreateTestServer(t, 3)
srv4 := CreateTestServer(t, 4)
logger.Infof("Servers created")
eg := errgroup.Group{}
eg.Go(func() error {
return srv1.Start(3030)
})
eg.Go(func() error {
return srv2.Start(3031)
})
eg.Go(func() error {
return srv3.Start(3032)
})
eg.Go(func() error {
return srv4.Start(3033)
})
logger.Infof("Servers Started")
opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData))
require.NoError(t, err)
clnt := client.New(opmap)
logger.Infof("Client created")
logger.Infof("Client Starting dkg")
_, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 3, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0)
require.ErrorContains(t, err, "my operator is missing inside the op list")
srv1.Stop()
srv2.Stop()
srv3.Stop()
srv4.Stop()

require.ErrorIs(t, http.ErrServerClosed, eg.Wait())
})

t.Run("test wrong partial deposit signature", func(t *testing.T) {
logger := logrus.NewEntry(logrus.New())
logger.Infof("Starting intg test")
eveMsg := dkg.EveTest{
WrongPartialSig: "0x87912f24669427628885cf0b70385b94694951626805ff565f4d2a0b74c433a45b279769ff23c23c8dd4ae3625fa06c20df368c0dc24931f3ebe133b3e1fed7d3477c51fa291e61052b0286c7fc453bb5e10346c43eadda9ef1bac8db14acda4",
}

srv1 := CreateEveTestServer(t, 1, &eveMsg)
srv2 := CreateTestServer(t, 2)
srv3 := CreateTestServer(t, 3)
srv4 := CreateTestServer(t, 4)
logger.Infof("Servers created")
eg := errgroup.Group{}
eg.Go(func() error {
return srv1.Start(3030)
})
eg.Go(func() error {
return srv2.Start(3031)
})
eg.Go(func() error {
return srv3.Start(3032)
})
eg.Go(func() error {
return srv4.Start(3033)
})
logger.Infof("Servers Started")

opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData))
require.NoError(t, err)
clnt := client.New(opmap)
logger.Infof("Client created")
logger.Infof("Client Starting dkg")
_, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 3, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0)
require.ErrorContains(t, err, "error verifying partial deposit signature")
srv1.Stop()
srv2.Stop()
srv3.Stop()
srv4.Stop()
require.ErrorIs(t, http.ErrServerClosed, eg.Wait())
})

t.Run("test wrong request ID", func(t *testing.T) {
logger := logrus.NewEntry(logrus.New())
logger.Infof("Starting intg test")
eveMsg := dkg.EveTest{
WrongID: "0x0000000000000000630ab8af69364a6db7b6d7d59bb60f23",
}
srv1 := CreateEveTestServer(t, 1, &eveMsg)
srv2 := CreateTestServer(t, 2)
srv3 := CreateTestServer(t, 3)
srv4 := CreateTestServer(t, 4)
logger.Infof("Servers created")
eg := errgroup.Group{}
eg.Go(func() error {
return srv1.Start(3030)
})
eg.Go(func() error {
return srv2.Start(3031)
})
eg.Go(func() error {
return srv3.Start(3032)
})
eg.Go(func() error {
return srv4.Start(3033)
})
logger.Infof("Servers Started")
opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData))
require.NoError(t, err)
Expand All @@ -158,48 +110,6 @@ func TestHappyFlow(t *testing.T) {
_, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 3, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0)
require.ErrorContains(t, err, "DKG result has wrong ID")
srv1.Stop()
srv2.Stop()
srv3.Stop()
srv4.Stop()
require.ErrorIs(t, http.ErrServerClosed, eg.Wait())
})
t.Run("test operator timeout", func(t *testing.T) {
logger := logrus.NewEntry(logrus.New())
logger.Infof("Starting intg test")
eveMsg := dkg.EveTest{
Timeout: time.Second * 30,
}
srv1 := CreateEveTestServer(t, 1, &eveMsg)
srv2 := CreateTestServer(t, 2)
srv3 := CreateTestServer(t, 3)
srv4 := CreateTestServer(t, 4)
logger.Infof("Servers created")
eg := errgroup.Group{}
eg.Go(func() error {
return srv1.Start(3030)
})
eg.Go(func() error {
return srv2.Start(3031)
})
eg.Go(func() error {
return srv3.Start(3032)
})
eg.Go(func() error {
return srv4.Start(3033)
})
logger.Infof("Servers Started")
opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData))
require.NoError(t, err)
clnt := client.New(opmap)
logger.Infof("Client created")
logger.Infof("Client Starting dkg")
_, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 3, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0)
require.ErrorContains(t, err, "Client.Timeout exceeded while awaiting headers")
srv1.Stop()
srv2.Stop()
srv3.Stop()
srv4.Stop()
require.ErrorIs(t, http.ErrServerClosed, eg.Wait())
})
t.Run("test wrong threshold", func(t *testing.T) {
opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData))
Expand All @@ -208,6 +118,48 @@ func TestHappyFlow(t *testing.T) {
_, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 10, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0)
require.ErrorContains(t, err, "wrong threshold")
})
srv2.Stop()
srv3.Stop()
srv4.Stop()
require.ErrorIs(t, http.ErrServerClosed, eg.Wait())
}

func TestTimeout(t *testing.T) {
eveMsg := dkg.EveTest{
Timeout: time.Second * 30,
}

logger := logrus.NewEntry(logrus.New())
eg := errgroup.Group{}
srv1 := CreateEveTestServer(t, 1, &eveMsg)
srv2 := CreateTestServer(t, 2)
srv3 := CreateTestServer(t, 3)
srv4 := CreateTestServer(t, 4)

eg.Go(func() error {
return srv1.Start(3030)
})
eg.Go(func() error {
return srv2.Start(3031)
})
eg.Go(func() error {
return srv3.Start(3032)
})
eg.Go(func() error {
return srv4.Start(3033)
})
logger.Infof("Servers created")

opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData))
require.NoError(t, err)
clnt := client.New(opmap)
_, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 3, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0)
require.ErrorContains(t, err, "Client.Timeout exceeded while awaiting headers")
srv1.Stop()
srv2.Stop()
srv3.Stop()
srv4.Stop()
require.ErrorIs(t, http.ErrServerClosed, eg.Wait())
}
func CreateTestServer(t *testing.T, id uint64) *test_server.Server {
pk, err := load.EncryptedPrivateKey(exmaplePath+"server"+fmt.Sprintf("%v", id)+"/encrypted_private_key.json", "12345678")
Expand All @@ -233,17 +185,10 @@ func CreateEveTestServer(t *testing.T, id uint64, eveCase *dkg.EveTest) *test_se
func newEthAddress(t *testing.T) common.Address {
privateKey, err := eth_crypto.GenerateKey()
require.NoError(t, err)

//privateKeyBytes := crypto.FromECDSA(privateKey)

publicKey := privateKey.Public()
publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
require.True(t, ok)

//publicKeyBytes := crypto.FromECDSAPub(publicKeyECDSA)

address := eth_crypto.PubkeyToAddress(*publicKeyECDSA)

return address
}

Expand Down
2 changes: 1 addition & 1 deletion pkgs/dkg/drand.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -152,7 +152,7 @@ func (o *LocalOwner) StartDKG() error {
Public: p,
})
}
o.Logger.Infof("Staring DKG with nodes", nodes)
o.Logger.Infof("Staring DKG with nodes %v", nodes)

// New protocol
p, err := wire.NewDKGProtocol(&wire.Config{
Expand Down
Loading

0 comments on commit 5aa4e19

Please sign in to comment.