Merge branch 'master' into feat/cli-interface

client/flow_test.go

@@ -1,4 +1,4 @@
-package main
+package client
 
 import (
 	"bytes"
@@ -6,24 +6,23 @@ import (
 	"crypto/md5"
 	"encoding/json"
 	"fmt"
-	"github.com/depools/dc4bc/client/types"
-	_ "image/jpeg"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"sync"
-	"time"
-
 	"github.com/depools/dc4bc/airgapped"
-	"github.com/depools/dc4bc/client"
+	"github.com/depools/dc4bc/client/types"
+	"github.com/depools/dc4bc/fsm/state_machines/dkg_proposal_fsm"
 	"github.com/depools/dc4bc/fsm/types/requests"
 	"github.com/depools/dc4bc/qr"
 	"github.com/depools/dc4bc/storage"
+	bls12381 "github.com/depools/kyber-bls12381"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"testing"
+	"time"
 )
 
 type node struct {
-	client     client.Poller
-	keyPair    *client.KeyPair
+	client     Poller
+	keyPair    *KeyPair
 	air        *airgapped.AirgappedMachine
 	listenAddr string
 }
@@ -41,7 +40,7 @@ func getOperations(url string) (*OperationsResponse, error) {
 	defer resp.Body.Close()
 	responseBody, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		log.Fatalf("failed to read body %v", err)
+		return nil, fmt.Errorf("failed to read body %v", err)
 	}
 
 	var response OperationsResponse
@@ -63,10 +62,10 @@ func handleProcessedOperation(url string, operation types.Operation) error {
 	defer resp.Body.Close()
 	responseBody, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		log.Fatalf("failed to read body %v", err)
+		return fmt.Errorf("failed to read body %v", err)
 	}
 
-	var response client.Response
+	var response Response
 	if err = json.Unmarshal(responseBody, &response); err != nil {
 		return fmt.Errorf("failed to unmarshal response: %w", err)
 	}
@@ -76,11 +75,11 @@ func handleProcessedOperation(url string, operation types.Operation) error {
 	return nil
 }
 
-func (n *node) run() {
+func (n *node) run(t *testing.T) {
 	for {
 		operationsResponse, err := getOperations(fmt.Sprintf("http://%s/getOperations", n.listenAddr))
 		if err != nil {
-			log.Fatalf("failed to get operations: %v", err)
+			t.Fatalf("failed to get operations: %v", err)
 		}
 
 		operations := operationsResponse.Result
@@ -101,6 +100,22 @@ func (n *node) run() {
 			n.client.GetLogger().Log("Operation %s handled in airgapped, result event is %s",
 				operation.Event, processedOperation.Event)
 
+			// for integration tests
+			if processedOperation.Event == dkg_proposal_fsm.EventDKGMasterKeyConfirmationReceived {
+				msg := processedOperation.ResultMsgs[0]
+				var pubKeyReq requests.DKGProposalMasterKeyConfirmationRequest
+				if err = json.Unmarshal(msg.Data, &pubKeyReq); err != nil {
+					t.Fatalf("failed to unmarshal pubKey request: %v", err)
+				}
+				pubKey := bls12381.NewBLS12381Suite().Point()
+				if err = pubKey.UnmarshalBinary(pubKeyReq.MasterKey); err != nil {
+					t.Fatalf("failed to unmarshal pubkey: %v", err)
+				}
+				if err = ioutil.WriteFile(fmt.Sprintf("/tmp/dc4bc_participant_%d.pubkey", pubKeyReq.ParticipantId), []byte(pubKey.String()), 666); err != nil {
+					t.Fatalf("failed to write pubkey to temp file: %v", err)
+				}
+			}
+
 			if err = handleProcessedOperation(fmt.Sprintf("http://%s/handleProcessedOperationJSON", n.listenAddr),
 				processedOperation); err != nil {
 				n.client.GetLogger().Log("Failed to handle processed operation: %v", err)
@@ -112,7 +127,7 @@ func (n *node) run() {
 	}
 }
 
-func main() {
+func TestFullFlow(t *testing.T) {
 	var numNodes = 4
 	var threshold = 3
 	var storagePath = "/tmp/dc4bc_storage"
@@ -121,32 +136,32 @@ func main() {
 	for nodeID := 0; nodeID < numNodes; nodeID++ {
 		var ctx = context.Background()
 		var userName = fmt.Sprintf("node_%d", nodeID)
-		var state, err = client.NewLevelDBState(fmt.Sprintf("/tmp/dc4bc_node_%d_state", nodeID))
+		var state, err = NewLevelDBState(fmt.Sprintf("/tmp/dc4bc_node_%d_state", nodeID))
 		if err != nil {
-			log.Fatalf("node %d failed to init state: %v\n", nodeID, err)
+			t.Fatalf("node %d failed to init state: %v\n", nodeID, err)
 		}
 
 		stg, err := storage.NewFileStorage(storagePath)
 		if err != nil {
-			log.Fatalf("node %d failed to init storage: %v\n", nodeID, err)
+			t.Fatalf("node %d failed to init storage: %v\n", nodeID, err)
 		}
 
-		keyStore, err := client.NewLevelDBKeyStore(userName, fmt.Sprintf("/tmp/dc4bc_node_%d_key_store", nodeID))
+		keyStore, err := NewLevelDBKeyStore(userName, fmt.Sprintf("/tmp/dc4bc_node_%d_key_store", nodeID))
 		if err != nil {
-			log.Fatalf("Failed to init key store: %v", err)
+			t.Fatalf("Failed to init key store: %v", err)
 		}
 
-		keyPair := client.NewKeyPair()
+		keyPair := NewKeyPair()
 		if err := keyStore.PutKeys(userName, keyPair); err != nil {
-			log.Fatalf("Failed to PutKeys: %v\n", err)
+			t.Fatalf("Failed to PutKeys: %v\n", err)
 		}
 
 		airgappedMachine, err := airgapped.NewAirgappedMachine(fmt.Sprintf("/tmp/dc4bc_node_%d_airgapped_db", nodeID))
 		if err != nil {
-			log.Fatalf("Failed to create airgapped machine: %v", err)
+			t.Fatalf("Failed to create airgapped machine: %v", err)
 		}
 
-		clt, err := client.NewClient(
+		clt, err := NewClient(
 			ctx,
 			userName,
 			state,
@@ -155,7 +170,7 @@ func main() {
 			qr.NewCameraProcessor(),
 		)
 		if err != nil {
-			log.Fatalf("node %d failed to init client: %v\n", nodeID, err)
+			t.Fatalf("node %d failed to init client: %v\n", nodeID, err)
 		}
 		airgappedMachine.SetAddress(clt.GetAddr())
 
@@ -172,15 +187,15 @@ func main() {
 	for nodeID, n := range nodes {
 		go func(nodeID int, node *node) {
 			if err := node.client.StartHTTPServer(node.listenAddr); err != nil {
-				log.Fatalf("failed to start HTTP server for nodeID #%d: %v\n", nodeID, err)
+				t.Fatalf("failed to start HTTP server for nodeID #%d: %v\n", nodeID, err)
 			}
 		}(nodeID, n)
 		time.Sleep(1 * time.Second)
-		go nodes[nodeID].run()
+		go nodes[nodeID].run(t)
 
-		go func(nodeID int, node client.Poller) {
+		go func(nodeID int, node Poller) {
 			if err := node.Poll(); err != nil {
-				log.Fatalf("client %d poller failed: %v\n", nodeID, err)
+				t.Fatalf("client %d poller failed: %v\n", nodeID, err)
 			}
 		}(nodeID, n.client)
 
@@ -207,12 +222,12 @@ func main() {
 	}
 	messageDataBz, err := json.Marshal(messageData)
 	if err != nil {
-		log.Fatalf("failed to marshal SignatureProposalParticipantsListRequest: %v\n", err)
+		t.Fatalf("failed to marshal SignatureProposalParticipantsListRequest: %v\n", err)
 	}
 
 	if _, err := http.Post(fmt.Sprintf("http://localhost:%d/startDKG", startingPort-1),
 		"application/json", bytes.NewReader(messageDataBz)); err != nil {
-		log.Fatalf("failed to send HTTP request to start DKG: %v\n", err)
+		t.Fatalf("failed to send HTTP request to start DKG: %v\n", err)
 	}
 
 	// i haven't a better idea to test signing without big changes in the client code
@@ -227,21 +242,18 @@ func main() {
 	}
 	messageDataSignBz, err := json.Marshal(messageDataSign)
 	if err != nil {
-		log.Fatalf("failed to marshal SigningProposalStartRequest: %v\n", err)
+		t.Fatalf("failed to marshal SigningProposalStartRequest: %v\n", err)
 	}
 
 	messageDataBz, err = json.Marshal(map[string][]byte{"data": messageDataSignBz,
 		"dkgID": dkgRoundID[:]})
 	if err != nil {
-		log.Fatalf("failed to marshal SignatureProposalParticipantsListRequest: %v\n", err)
+		t.Fatalf("failed to marshal SignatureProposalParticipantsListRequest: %v\n", err)
 	}
 
 	if _, err := http.Post(fmt.Sprintf("http://localhost:%d/proposeSignMessage", startingPort-1),
 		"application/json", bytes.NewReader(messageDataBz)); err != nil {
-		log.Fatalf("failed to send HTTP request to sign message: %v\n", err)
+		t.Fatalf("failed to send HTTP request to sign message: %v\n", err)
 	}
-
-	var wg = sync.WaitGroup{}
-	wg.Add(1)
-	wg.Wait()
+	time.Sleep(5 * time.Second)
 }