add a workable test suite as preformance brench of endorsement

fix for Hyperledger-TWGC#102

Signed-off-by: SamYuan1990 <[email protected]>

azure-pipelines.yml

@@ -27,19 +27,23 @@ jobs:
         inputs:
           version: '1.14'
       - task: Go@0
+        displayName: install
         inputs:
           command: 'get'
           arguments: '-d ./...'
           workingDirectory: '$(System.DefaultWorkingDirectory)'
       - task: Go@0
+        displayName: build
         inputs:
-          command: 'test'
-          arguments: '-v ./... -cover'
+          command: 'build'
+          arguments: './...'
           workingDirectory: '$(System.DefaultWorkingDirectory)'
       - task: Go@0
+        displayName: test
         inputs:
-          command: 'build'
-          arguments: './...'
+          command: 'test'
+          # for any benchmark testing should run locally to avoid impacts from random vm on azp pipeline.
+          arguments: '-v ./... -cover'
           workingDirectory: '$(System.DefaultWorkingDirectory)'
 
   - job: dockerbuild

pkg/infra/benchmark_test.go

@@ -0,0 +1,80 @@
+package infra
+
+import (
+	"net"
+	"testing"
+
+	"github.com/guoger/tape/e2e/mock"
+	"github.com/hyperledger/fabric-protos-go/peer"
+	log "github.com/sirupsen/logrus"
+	"google.golang.org/grpc"
+)
+
+func MockingPeer() (*mock.Server, string) {
+	lis, _ := net.Listen("tcp", "127.0.0.1:0")
+	grpcServer := grpc.NewServer()
+	mockPeer := &mock.Server{GrpcServer: grpcServer, Listener: lis}
+	go mockPeer.Start()
+	return mockPeer, lis.Addr().String()
+}
+
+func PrepareClient(signed, processed chan *Elements, done chan struct{}, logger *log.Logger, threshold int, addr string) {
+	peer := Node{
+		Addr: addr,
+	}
+	Proposer, _ := CreateProposer(peer, logger)
+	go Proposer.Start(signed, processed, done, threshold)
+}
+
+func GetData() *Elements {
+	return &Elements{
+		SignedProp: &peer.SignedProposal{
+			ProposalBytes: []byte("signed-proposal-bytes"),
+			Signature:     []byte("signature"),
+		},
+	}
+}
+
+// suggestion mainter checkout pr and test locally to verify the preformance benchmark.
+// for any preformance impacts features.
+// go test --bench=. -v ./... --count=3
+
+// preformance history, just logging previous time running the benchmark below at local.
+// 2020-Nov | Sam | 113753 ns/op	    9226 B/op	     184 allocs/op
+func BenchmarkSinglePeerEndorsement(b *testing.B) {
+	mockpeer1, mockpeeraddr1 := MockingPeer()
+	processed := make(chan *Elements, 10)
+	done := make(chan struct{})
+	signed1 := make(chan *Elements, 10)
+	PrepareClient(signed1, processed, done, nil, 1, mockpeeraddr1)
+	for n := 0; n < b.N; n++ {
+		signed1 <- GetData()
+		<-processed
+	}
+	done <- struct{}{}
+	mockpeer1.Stop()
+}
+
+// 2020-Nov | Sam | 127889 ns/op	   18409 B/op	     366 allocs/op
+func BenchmarkTwoPeerEndorsement(b *testing.B) {
+	mockpeer1, mockpeeraddr1 := MockingPeer()
+	mockpeer2, mockpeeraddr2 := MockingPeer()
+
+	processed := make(chan *Elements, 10)
+	done := make(chan struct{})
+	signed1 := make(chan *Elements, 10)
+	signed2 := make(chan *Elements, 10)
+
+	PrepareClient(signed1, processed, done, nil, 2, mockpeeraddr1)
+	PrepareClient(signed2, processed, done, nil, 2, mockpeeraddr2)
+
+	for n := 0; n < b.N; n++ {
+		data := GetData()
+		signed1 <- data
+		signed2 <- data
+		<-processed
+	}
+	done <- struct{}{}
+	mockpeer1.Stop()
+	mockpeer2.Stop()
+}

pkg/infra/proposer_test.go

@@ -1,6 +1,7 @@
 package infra_test
 
 import (
+	"github.com/guoger/tape/e2e/mock"
 	"github.com/guoger/tape/pkg/infra"
 	"github.com/hyperledger/fabric-sdk-go/pkg/fab/mocks"
 	. "github.com/onsi/ginkgo"
@@ -12,6 +13,8 @@ var _ = Describe("Proposer", func() {
 
 	var addr string
 	var logger = log.New()
+	var processed, signed1, signed2 chan *infra.Elements
+	var done chan struct{}
 
 	BeforeEach(func() {
 		srv := &mocks.MockEndorserServer{}
@@ -55,4 +58,51 @@ var _ = Describe("Proposer", func() {
 			Expect(err).Should(MatchError(ContainSubstring("error connecting to invalid_addr")))
 		})
 	})
+
+	Context("Tape should do less for prepare and summary endorsement process", func() {
+
+		var mockpeer1 *mock.Server
+		var mockpeer2 *mock.Server
+		var mockpeeraddr1 string
+		var mockpeeraddr2 string
+
+		BeforeEach(func() {
+			processed = make(chan *infra.Elements, 10)
+			done = make(chan struct{})
+			signed1 = make(chan *infra.Elements, 10)
+			signed2 = make(chan *infra.Elements, 10)
+			mockpeer1, mockpeeraddr1 = infra.MockingPeer()
+			mockpeer2, mockpeeraddr2 = infra.MockingPeer()
+		})
+
+		Measure("it should do endorsement efficiently for single client", func(b Benchmarker) {
+			infra.PrepareClient(signed1, processed, done, logger, 1, mockpeeraddr1)
+			runtime := b.Time("runtime", func() {
+				signed1 <- infra.GetData()
+				<-processed
+			})
+			done <- struct{}{}
+			// 0.002 here for mac testing on azp
+			Expect(runtime.Seconds()).Should(BeNumerically("<", 0.002), "endorsement() shouldn't take too long.")
+		}, 10)
+
+		Measure("it should do endorsement efficiently for two clients", func(b Benchmarker) {
+			infra.PrepareClient(signed1, processed, done, logger, 2, mockpeeraddr1)
+			infra.PrepareClient(signed2, processed, done, logger, 2, mockpeeraddr2)
+			runtime := b.Time("runtime", func() {
+				data := infra.GetData()
+				signed1 <- data
+				signed2 <- data
+				<-processed
+			})
+			done <- struct{}{}
+			// 0.002 here for mac testing on azp
+			Expect(runtime.Seconds()).Should(BeNumerically("<", 0.002), "endorsement() shouldn't take too long.")
+		}, 10)
+
+		AfterEach(func() {
+			mockpeer1.Stop()
+			mockpeer2.Stop()
+		})
+	})
 })