events unary methods (#84)

* events unary methods
* extended event information in subscription chan
* event mapping resolving

Author: vitiko

examples/cpaper_asservice/bin/api/mock/main.go

@@ -9,12 +9,12 @@ import (
 	"time"
 
 	"github.com/grpc-ecosystem/grpc-gateway/runtime"
+	"google.golang.org/grpc"
+
 	"github.com/s7techlab/cckit/examples/cpaper_asservice"
 	cpaperservice "github.com/s7techlab/cckit/examples/cpaper_asservice/service"
 	"github.com/s7techlab/cckit/gateway"
-	gwmock "github.com/s7techlab/cckit/gateway/mock"
 	"github.com/s7techlab/cckit/testing"
-	"google.golang.org/grpc"
 )
 
 const (
@@ -42,7 +42,7 @@ func main() {
 	cpaperMock := testing.NewMockStub(chaincodeName, cc)
 
 	// Chaincode invocation service mock. For real network you can use example with hlf-sdk-go
-	cpaperMockService := gwmock.New(testing.NewPeer().WithChannel(channelName, cpaperMock))
+	cpaperMockService := gateway.NewChaincodeService(testing.NewPeer().WithChannel(channelName, cpaperMock))
 
 	// default identity for signing requests to peeer (mocked)
 	apiIdentity, err := testing.IdentityFromFile(`MSP`, `../../../testdata/admin.pem`, ioutil.ReadFile)

examples/cpaper_asservice/chaincode_test.go

@@ -6,16 +6,16 @@ import (
 	"testing"
 	"time"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
 	"github.com/golang/protobuf/ptypes"
 	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/hyperledger/fabric/msp"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
 	"github.com/s7techlab/cckit/examples/cpaper_asservice"
 	"github.com/s7techlab/cckit/examples/cpaper_asservice/schema"
 	s "github.com/s7techlab/cckit/examples/cpaper_asservice/service"
-	"github.com/s7techlab/cckit/extensions/encryption"
+	enctest "github.com/s7techlab/cckit/extensions/encryption/testing"
 	"github.com/s7techlab/cckit/router"
 	testcc "github.com/s7techlab/cckit/testing"
 	expectcc "github.com/s7techlab/cckit/testing/expect"
@@ -39,7 +39,7 @@ var (
 	cc, ccEnc         *testcc.MockStub
 
 	encKey       = make([]byte, 32)
-	ccEncWrapped *encryption.MockStub
+	ccEncWrapped *enctest.MockStub
 
 	issuePayload = &schema.IssueCommercialPaper{
 		Issuer:       IssuerName,
@@ -70,7 +70,7 @@ var _ = Describe(`CommercialPaper`, func() {
 		ccEnc = testcc.NewMockStub(`cpaper_as_service_encrypted`, ccEncImpl)
 
 		// all queries/invokes arguments to cc will be encrypted
-		ccEncWrapped = encryption.NewMockStub(ccEnc, encKey)
+		ccEncWrapped = enctest.NewMockStub(ccEnc, encKey)
 
 		identity, err = testcc.IdentityFromFile(MspName, `./testdata/admin.pem`, ioutil.ReadFile)
 		Expect(err).NotTo(HaveOccurred())

examples/cpaper_asservice/service/service.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/pkg/errors"
+
 	"github.com/s7techlab/cckit/examples/cpaper_asservice/schema"
 	"github.com/s7techlab/cckit/router"
 	"github.com/s7techlab/cckit/state"
@@ -18,26 +19,32 @@ func New() *CPaperImpl {
 	return &CPaperImpl{}
 }
 
-// State with chaincode mappings
-func State(ctx router.Context) m.MappedState {
-	return m.WrapState(ctx.State(), m.StateMappings{}.
+var (
+	StateMappings = m.StateMappings{}.
 		//  Create mapping for Commercial Paper entity
 		Add(&schema.CommercialPaper{},
 			m.PKeySchema(&schema.CommercialPaperId{}), // Key namespace will be <"CommercialPaper", Issuer, PaperNumber>
 			m.List(&schema.CommercialPaperList{}),     // Structure of result for List method
 			m.UniqKey("ExternalId"),                   // External Id is unique
-		))
-}
+		)
 
-// Event with chaincode mappings
-func Event(ctx router.Context) state.Event {
-	return m.WrapEvent(ctx.Event(), m.EventMappings{}.
+	EventMappings = m.EventMappings{}.
 		// Event name will be "IssueCommercialPaper", payload - same as issue payload
 		Add(&schema.IssueCommercialPaper{}).
 		// Event name will be "BuyCommercialPaper"
 		Add(&schema.BuyCommercialPaper{}).
 		// Event name will be "RedeemCommercialPaper"
-		Add(&schema.RedeemCommercialPaper{}))
+		Add(&schema.RedeemCommercialPaper{})
+)
+
+// State with chaincode mappings
+func State(ctx router.Context) m.MappedState {
+	return m.WrapState(ctx.State(), StateMappings)
+}
+
+// Event with chaincode mappings
+func Event(ctx router.Context) state.Event {
+	return m.WrapEvent(ctx.Event(), EventMappings)
 }
 
 func (cc *CPaperImpl) List(ctx router.Context, in *empty.Empty) (*schema.CommercialPaperList, error) {

extensions/encryption/encryption_test.go

@@ -5,14 +5,15 @@ import (
 	"encoding/base64"
 	"testing"
 
+	"github.com/hyperledger/fabric-protos-go/peer"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
-	"github.com/hyperledger/fabric-protos-go/peer"
 	"github.com/s7techlab/cckit/examples/payment"
 	"github.com/s7techlab/cckit/examples/payment/schema"
 	"github.com/s7techlab/cckit/extensions/encryption"
 	"github.com/s7techlab/cckit/extensions/encryption/testdata"
+	enctest "github.com/s7techlab/cckit/extensions/encryption/testing"
 	identitytestdata "github.com/s7techlab/cckit/identity/testdata"
 	"github.com/s7techlab/cckit/state"
 	"github.com/s7techlab/cckit/state/mapping"
@@ -35,7 +36,7 @@ var (
 	encryptPaymentCCWithEncStateContext *testcc.MockStub
 	externalCC                          *testcc.MockStub
 
-	encCCInvoker *encryption.MockStub
+	encCCInvoker *enctest.MockStub
 
 	pType  = `SALE`
 	encKey []byte
@@ -80,7 +81,7 @@ var _ = Describe(`Router`, func() {
 			`paymentsEncWithContext`,
 			payment.NewEncryptedPaymentCCWithEncStateContext())
 
-		encCCInvoker = encryption.NewMockStub(encryptPaymentCCWithEncStateContext, encKey)
+		encCCInvoker = enctest.NewMockStub(encryptPaymentCCWithEncStateContext, encKey)
 		encCCInvoker.DecryptInvokeResponse = true
 
 		externalCC = testcc.NewMockStub(`external`,
@@ -180,7 +181,7 @@ var _ = Describe(`Router`, func() {
 		It("Allow to get encrypted payments by type as unencrypted values", func() {
 			// MockInvoke sets key in transient map and encrypt input arguments
 			payments := expectcc.PayloadIs(
-				encryption.MockInvoke(encryptOnDemandPaymentCC, encKey, `paymentList`, pType),
+				enctest.MockInvoke(encryptOnDemandPaymentCC, encKey, `paymentList`, pType),
 				&schema.PaymentList{}).(*schema.PaymentList)
 
 			Expect(payments.Items).To(HaveLen(1))
@@ -218,7 +219,7 @@ var _ = Describe(`Router`, func() {
 
 		It("Allow to create payment providing key in encryptPaymentCC ", func() {
 			// encode all arguments
-			expectcc.ResponseOk(encryption.MockInvoke(encryptPaymentCC, encKey, `paymentCreate`, pType, pID3, pAmount3))
+			expectcc.ResponseOk(enctest.MockInvoke(encryptPaymentCC, encKey, `paymentCreate`, pType, pID3, pAmount3))
 		})
 	})
 
@@ -252,7 +253,7 @@ var _ = Describe(`Router`, func() {
 				}),
 			})))
 
-			closer()
+			_ = closer()
 			close(done)
 		}, 0.2)
 

extensions/encryption/must.go

@@ -0,0 +1,24 @@
+package encryption
+
+import (
+	"github.com/hyperledger/fabric-protos-go/peer"
+)
+
+// MustEncryptEvent helper for EncryptEvent. Panics in case of error.
+func MustEncryptEvent(encKey []byte, event *peer.ChaincodeEvent) *peer.ChaincodeEvent {
+	encrypted, err := EncryptEvent(encKey, event)
+	if err != nil {
+		panic(err)
+	}
+	return encrypted
+}
+
+// MustDecryptEvent helper for DecryptEvent. Panics in case of error.
+func MustDecryptEvent(encKey []byte, event *peer.ChaincodeEvent) *peer.ChaincodeEvent {
+	decrypted, err := DecryptEvent(encKey, event)
+	if err != nil {
+		panic(err)
+	}
+
+	return decrypted
+}

extensions/encryption/testing.go extensions/encryption/testing/testing.goextensions/encryption/testing.go renamed to extensions/encryption/testing/testing.go

@@ -1,34 +1,36 @@
-package encryption
+package testing
 
 import (
 	"fmt"
 
 	"github.com/hyperledger/fabric-protos-go/peer"
+
+	"github.com/s7techlab/cckit/extensions/encryption"
 	"github.com/s7techlab/cckit/response"
-	"github.com/s7techlab/cckit/testing"
+	testcc "github.com/s7techlab/cckit/testing"
 )
 
 // MockInvoke helper for invoking MockStub with transient key and encrypted args
-func MockInvoke(cc *testing.MockStub, encKey []byte, args ...interface{}) peer.Response {
-	encArgs, err := EncryptArgs(encKey, args...)
+func MockInvoke(cc *testcc.MockStub, encKey []byte, args ...interface{}) peer.Response {
+	encArgs, err := encryption.EncryptArgs(encKey, args...)
 	if err != nil {
 		return response.Error(`unable to encrypt input args`)
 	}
-	return cc.AddTransient(TransientMapWithKey(encKey)).InvokeBytes(encArgs...)
+	return cc.AddTransient(encryption.TransientMapWithKey(encKey)).InvokeBytes(encArgs...)
 }
 
 // MockQuery helper for querying MockStub with transient key and encrypted args
-func MockQuery(cc *testing.MockStub, encKey []byte, args ...interface{}) peer.Response {
-	encArgs, err := EncryptArgs(encKey, args...)
+func MockQuery(cc *testcc.MockStub, encKey []byte, args ...interface{}) peer.Response {
+	encArgs, err := encryption.EncryptArgs(encKey, args...)
 	if err != nil {
 		return response.Error(`unable to encrypt input args`)
 	}
-	return cc.AddTransient(TransientMapWithKey(encKey)).QueryBytes(encArgs...)
+	return cc.AddTransient(encryption.TransientMapWithKey(encKey)).QueryBytes(encArgs...)
 }
 
 // MockStub wrapper for querying and invoking encrypted chaincode
 type MockStub struct {
-	MockStub *testing.MockStub
+	MockStub *testcc.MockStub
 	//EncKey key for encrypt data before query/invoke
 	EncKey []byte
 
@@ -37,7 +39,7 @@ type MockStub struct {
 }
 
 // NewMockStub creates wrapper for querying and invoking encrypted chaincode
-func NewMockStub(mockStub *testing.MockStub, encKey []byte) *MockStub {
+func NewMockStub(mockStub *testcc.MockStub, encKey []byte) *MockStub {
 	return &MockStub{MockStub: mockStub, EncKey: encKey}
 }
 
@@ -52,7 +54,7 @@ func (s *MockStub) Invoke(args ...interface{}) (response peer.Response) {
 	//after receiving response we can decrypt received peer response
 	// actual only for invoke, query responses are not encrypted
 	if s.DecryptInvokeResponse && len(response.Payload) > 0 && string(response.Payload) != `null` {
-		if decrypted, err = Decrypt(s.EncKey, response.Payload); err != nil {
+		if decrypted, err = encryption.Decrypt(s.EncKey, response.Payload); err != nil {
 			panic(fmt.Sprintf(
 				`decrypt mock invoke error with payload %s (%d): %s`,
 				string(response.Payload), len(response.Payload), err))
@@ -68,11 +70,11 @@ func (s *MockStub) Query(args ...interface{}) peer.Response {
 }
 
 func (s *MockStub) Init(args ...interface{}) peer.Response {
-	encArgs, err := EncryptArgs(s.EncKey, args...)
+	encArgs, err := encryption.EncryptArgs(s.EncKey, args...)
 	if err != nil {
 		return response.Error(`unable to encrypt input args`)
 	}
-	return s.MockStub.AddTransient(TransientMapWithKey(s.EncKey)).InitBytes(encArgs...)
+	return s.MockStub.AddTransient(encryption.TransientMapWithKey(s.EncKey)).InitBytes(encArgs...)
 }
 
 func (s *MockStub) From(args ...interface{}) *MockStub {
@@ -81,20 +83,5 @@ func (s *MockStub) From(args ...interface{}) *MockStub {
 }
 
 func (s *MockStub) LastEvent() *peer.ChaincodeEvent {
-	return MustDecryptEvent(s.EncKey, s.MockStub.ChaincodeEvent)
-}
-
-// MustEncryptEvent helper for EncryptEvent. Panics in case of error.
-func MustEncryptEvent(encKey []byte, event *peer.ChaincodeEvent) *peer.ChaincodeEvent {
-	encrypted, err := EncryptEvent(encKey, event)
-	testing.PanicIfError(err)
-	return encrypted
-}
-
-// MustDecryptEvent helper for DecryptEvent. Panics in case of error.
-func MustDecryptEvent(encKey []byte, event *peer.ChaincodeEvent) *peer.ChaincodeEvent {
-	decrypted, err := DecryptEvent(encKey, event)
-	testing.PanicIfError(err)
-
-	return decrypted
+	return encryption.MustDecryptEvent(s.EncKey, s.MockStub.ChaincodeEvent)
 }

gateway/Makefile

@@ -1,7 +1,7 @@
 .: generate
 
 generate:
-	@echo "chaincode invoke service"
+	@echo "chaincode gateway service"
 	@protoc -I=. \
 	 -I=../../  \
 	 -I=../vendor \