[api] fixed tests and imports

Gopkg.toml

@@ -32,10 +32,6 @@
   branch = "master"
   name = "github.com/Bit-Nation/x3dh"
 
-[[constraint]]
-  name = "github.com/asaskevich/govalidator"
-  version = "9.0.0"
-
 [[constraint]]
   name = "github.com/ethereum/go-ethereum"
   version = "1.8.11"

api/api.go

@@ -28,6 +28,7 @@ func New(client UpStream) *API {
 }
 
 type API struct {
+	DoubleRatchetKeyStoreApi
 	lock     sync.Mutex
 	requests map[string]chan *Response
 	client   UpStream

api/api_test.go

@@ -64,9 +64,7 @@ func TestRequestResponse(t *testing.T) {
 				panic(err)
 			}
 			receivedRequestID = req.RequestID
-			out := api.Respond(req.RequestID, &pb.Response{
-				RequestID: req.RequestID,
-			}, nil, time.Second)
+			out := api.Respond(req.RequestID, &pb.Response{}, nil, time.Second)
 			if out != nil {
 				panic("expected nil but got: " + out.Error())
 			}
@@ -76,6 +74,5 @@ func TestRequestResponse(t *testing.T) {
 	resp, err := api.request(&pb.Request{}, time.Second)
 	resp.Closer <- nil
 	require.Nil(t, err)
-	require.Equal(t, resp.Msg.RequestID, receivedRequestID)
 
 }

api/dr_key_store.go

@@ -3,11 +3,11 @@ package api
 import (
 	"errors"
 	"time"
-
-	keyManager "github.com/Bit-Nation/panthalassa/keyManager"
-	dr "github.com/tiabc/doubleratchet"
+
 	pb "github.com/Bit-Nation/panthalassa/api/pb"
 	aes "github.com/Bit-Nation/panthalassa/crypto/aes"
+	keyManager "github.com/Bit-Nation/panthalassa/keyManager"
+	dr "github.com/tiabc/doubleratchet"
 )
 
 type DoubleRatchetKeyStoreApi struct {
@@ -17,48 +17,48 @@ type DoubleRatchetKeyStoreApi struct {
 
 // get a key by it's key and msg number
 func (s *DoubleRatchetKeyStoreApi) Get(k dr.Key, msgNum uint) (mk dr.Key, ok bool) {
-	
+
 	req := pb.Request{
 		DRKeyStoreGet: &pb.Request_DRKeyStoreGet{
-			DrKey: k[:],
+			DrKey:         k[:],
 			MessageNumber: uint64(msgNum),
 		},
 	}
 
-	resp, err := s.api.request(&req, time.Second * 8)
+	resp, err := s.api.request(&req, time.Second*8)
 	if err != nil {
 		logger.Error(err)
 		return dr.Key{}, false
 	}
-	
+
 	ct, err := aes.Unmarshal(resp.Msg.DRKeyStoreGet.MessageKey)
 	if err != nil {
 		logger.Error(err)
 		resp.Closer <- err
 		return dr.Key{}, false
 	}
-	
+
 	messageKey, err := s.km.AESDecrypt(ct)
 	if err != nil {
 		logger.Error(err)
 		resp.Closer <- err
 		return dr.Key{}, false
 	}
-	
+
 	if len(messageKey) != 32 {
 		e := errors.New("a decrypted message key must have exactly 32 bytes")
 		logger.Error(e)
 		resp.Closer <- e
 		return dr.Key{}, false
 	}
-	
+
 	resp.Closer <- nil
-	
+
 	var msgKey dr.Key
 	copy(msgKey[:], messageKey)
-	
+
 	return msgKey, true
-	
+
 }
 
 // save message key (double ratchet key)
@@ -69,148 +69,148 @@ func (s *DoubleRatchetKeyStoreApi) Put(k dr.Key, msgNum uint, mk dr.Key) {
 		logger.Error(err)
 		return
 	}
-	
+
 	rawCt, err := ct.Marshal()
 	if err != nil {
 		logger.Error(err)
 		return
 	}
-	
+
 	resp, err := s.api.request(&pb.Request{
 		DRKeyStorePut: &pb.Request_DRKeyStorePut{
-			MessageKey: k[:],
+			Key:           k[:],
 			MessageNumber: uint64(msgNum),
-			Key: rawCt,
+			MessageKey:    rawCt,
 		},
-	}, time.Second * 8)
-	
+	}, time.Second*8)
+
 	if err != nil {
 		logger.Error(err)
 		return
 	}
-	
+
 	resp.Closer <- nil
 
 }
 
 func (s *DoubleRatchetKeyStoreApi) DeleteMk(k dr.Key, msgNum uint) {
-	
+
 	resp, err := s.api.request(&pb.Request{
 		DRKeyStoreDeleteMK: &pb.Request_DRKeyStoreDeleteMK{
-			Key: k[:],
+			Key:    k[:],
 			MsgNum: uint64(msgNum),
 		},
-	}, time.Second * 8)
-	
+	}, time.Second*8)
+
 	if err != nil {
 		logger.Error(err)
 		return
 	}
-	
+
 	resp.Closer <- nil
 
 }
 
 func (s *DoubleRatchetKeyStoreApi) DeletePk(k dr.Key) {
-	
+
 	resp, err := s.api.request(&pb.Request{
 		DRKeyStoreDeleteKeys: &pb.Request_DRKeyStoreDeleteKeys{
 			Key: k[:],
 		},
-	}, time.Second * 8)
-	
+	}, time.Second*8)
+
 	if err != nil {
 		logger.Error(err)
 		return
 	}
-	
+
 	resp.Closer <- nil
 
 }
 
 func (s *DoubleRatchetKeyStoreApi) Count(k dr.Key) uint {
-	
+
 	resp, err := s.api.request(&pb.Request{
 		DRKeyStoreCount: &pb.Request_DRKeyStoreCount{
 			Key: k[:],
 		},
-	}, time.Second * 8)
-	
+	}, time.Second*8)
+
 	if err != nil {
 		logger.Error(err)
 		return 0
 	}
-	
+
 	resp.Closer <- nil
-	
+
 	return uint(resp.Msg.DRKeyStoreCount.Count)
 
 }
 
 // @todo the all method is way to heavy. Long term we need to have another solution
 func (s *DoubleRatchetKeyStoreApi) All() map[dr.Key]map[uint]dr.Key {
-	
+
 	resp, err := s.api.request(&pb.Request{
 		DRKeyStoreAll: &pb.Request_DRKeyStoreAll{},
-	}, time.Second * 8)
-	
+	}, time.Second*8)
+
 	if err != nil {
 		logger.Error(err)
 		return map[dr.Key]map[uint]dr.Key{}
 	}
-	
+
 	var keys = map[dr.Key]map[uint]dr.Key{}
-	
+
 	for _, k := range resp.Msg.DRKeyStoreAll.All {
-		
+
 		// exit if key len is incorrect
 		if len(k.Key) != 32 {
 			e := errors.New("got invalid key in All() (expected key len == 32 bytes)")
 			logger.Error(e)
 			resp.Closer <- e
 			return map[dr.Key]map[uint]dr.Key{}
 		}
-		
+
 		indexKey := dr.Key{}
 		copy(indexKey[:], k.Key)
-		
+
 		messages := map[uint]dr.Key{}
-		
+
 		for msgNum, key := range k.MessageKeys {
-			
+
 			ct, err := aes.Unmarshal(key)
 			if err != nil {
 				resp.Closer <- err
 				logger.Error(err)
 				return map[dr.Key]map[uint]dr.Key{}
 			}
-			
+
 			rawMsgKey, err := s.km.AESDecrypt(ct)
 			if err != nil {
 				resp.Closer <- err
 				logger.Error(err)
 				return map[dr.Key]map[uint]dr.Key{}
 			}
-			
+
 			if len(rawMsgKey) != 32 {
 				e := errors.New("got invalid key in All() (expected key len == 32 bytes)")
 				logger.Error(e)
 				resp.Closer <- e
 				return map[dr.Key]map[uint]dr.Key{}
 			}
-			
+
 			msgKey := dr.Key{}
 			copy(msgKey[:], rawMsgKey)
-			
+
 			messages[uint(msgNum)] = msgKey
 		}
-		
+
 		keys[indexKey] = messages
-		
+
 	}
-	
+
 	resp.Closer <- nil
-	
+
 	return keys
 
 }