add frag unit test

server/server_test.go

 package server
 
 import (
+	"fmt"
 	"github.com/stretchr/testify/assert"
 	"gitlab.33.cn/pengjun/reencrypt/common"
 	"gitlab.33.cn/pengjun/reencrypt/sdk"
@@ -9,7 +10,7 @@ import (
 	"testing"
 )
 
-func TestReencrypt(t *testing.T) {
+func handleReencrypt(t *testing.T, numSplit, threshold int, suffix string) {
 	var msg = "hello proxy-re-encrypt"
 
 	alice, err := sdk.NewAccount("")
@@ -22,46 +23,56 @@ func TestReencrypt(t *testing.T) {
 	cipher, err := crypto.AESCBCPKCS7Encrypt(enkey[1:], []byte(msg))
 	assert.Nil(t, err)
 
-	keyFragments, err := sdk.GenerateKeyFragments(alice.PrivateKey, bob.PublicKey, 1, 1)
+	keyFragments, err := sdk.GenerateKeyFragments(alice.PrivateKey, bob.PublicKey, numSplit, threshold)
 	assert.Nil(t, err)
 
 	serviceAcc, err := sdk.NewAccount("")
 	assert.Nil(t, err)
-	db, err := newGoLevelDB("pre", "cfg.DbPath", 16)
-	assert.Nil(t, err)
-	service,err  := NewNodeService(db, types.ToHex(serviceAcc.PrivateKey))
-	assert.Nil(t, err)
 
-	dhproof := types.ECDH(crypto.PrivateECDSAFromByte(alice.PrivateKey), crypto.PublicECDSAFromByte(serviceAcc.PublicKey))
-	param := &common.ReqSendKeyFragment{
-		PubOwner:             types.ToHex(alice.PublicKey),
-		PubRecipient:         types.ToHex(bob.PublicKey),
-		PubProofR:            pub_r,
-		PubProofU:            pub_u,
-		Random:               keyFragments[0].Random,
-		Value:                keyFragments[0].Value,
-		Expire:               1000000,
-		DhProof:              dhproof.String(),
-		PrecurPub:            keyFragments[0].PrecurPub,
-	}
 
-	var result interface{}
-	service.CollectFragment(param, &result)
-	assert.Equal(t, true, result.(*common.RepSendKeyFragment).Result)
+	services := make([]*NodeService, numSplit)
+	for i, keyFragment := range keyFragments {
+		dbname := fmt.Sprintf("pre%d%s", i, suffix)
+		dbpath := fmt.Sprintf("cfg.DbPath%d%s", i, suffix)
+		db, err := newGoLevelDB(dbname, dbpath, 16)
+		assert.Nil(t, err)
+		services[i], err = NewNodeService(db, types.ToHex(serviceAcc.PrivateKey))
+		assert.Nil(t, err)
+
+		dhproof := types.ECDH(crypto.PrivateECDSAFromByte(alice.PrivateKey), crypto.PublicECDSAFromByte(serviceAcc.PublicKey))
+		param := &common.ReqSendKeyFragment{
+			PubOwner:     types.ToHex(alice.PublicKey),
+			PubRecipient: types.ToHex(bob.PublicKey),
+			PubProofR:    pub_r,
+			PubProofU:    pub_u,
+			Random:       keyFragment.Random,
+			Value:        keyFragment.Value,
+			Expire:       1000000,
+			DhProof:      dhproof.String(),
+			PrecurPub:    keyFragment.PrecurPub,
+		}
+
+		var result interface{}
+		services[i].CollectFragment(param, &result)
+		assert.Equal(t, true, result.(*common.RepSendKeyFragment).Result)
+	}
 
 	param1 := &common.ReqReeencryptParam{
 		PubOwner:             types.ToHex(alice.PublicKey),
 		PubRecipient:         types.ToHex(bob.PublicKey),
 	}
-	var result1 interface{}
-	service.Reencrypt(param1, &result1)
-
-	var rekeys = make([]*sdk.ReKeyFrag, 1)
-	rekeys[0] = &sdk.ReKeyFrag{
-		ReKeyR:    result1.(common.RepReeencrypt).ReKeyR,
-		ReKeyU:    result1.(common.RepReeencrypt).ReKeyU,
-		Random:    result1.(common.RepReeencrypt).Random,
-		PrecurPub: result1.(common.RepReeencrypt).PrecurPub,
+
+	var rekeys = make([]*sdk.ReKeyFrag, threshold)
+	for i:=0; i < threshold; i++ {
+		var result interface{}
+		services[i].Reencrypt(param1, &result)
+
+		rekeys[i] = &sdk.ReKeyFrag{
+			ReKeyR:    result.(common.RepReeencrypt).ReKeyR,
+			ReKeyU:    result.(common.RepReeencrypt).ReKeyU,
+			Random:    result.(common.RepReeencrypt).Random,
+			PrecurPub: result.(common.RepReeencrypt).PrecurPub,
+		}
 	}
 
 	aesKey, err := sdk.AssembleReencryptFragment(bob.PrivateKey, rekeys)
@@ -72,3 +83,12 @@ func TestReencrypt(t *testing.T) {
 	assert.Nil(t, err)
 	assert.Equal(t, msg, string(msgDecrypt))
 }
+
+func TestReencryptSingle(t *testing.T) {
+	handleReencrypt(t, 1, 1, "")
+}
+
+func TestReencryptFrag(t *testing.T) {
+	handleReencrypt(t, 3, 2, "frag")
+}
+