From eadb98493f586eaef9dda83e8ac5785305218945 Mon Sep 17 00:00:00 2001 From: Dereck Date: Mon, 10 Aug 2020 10:49:04 -0400 Subject: [PATCH 1/3] Adding golang application for asset-transfer-basic sample. (#211) Signed-off-by: Chongxin Luo Improved private data Go Chaincode in idiomatic go. Adding go chaincode unit tests Signed-off-by: Sijo Cherian --- .../application-go/.gitignore | 4 + .../application-go/assetTransfer.go | 146 + asset-transfer-basic/application-go/go.mod | 5 + asset-transfer-basic/application-go/go.sum | 127 + .../asset_queries.go} | 7 +- .../asset_transfer.go} | 32 +- .../chaincode/asset_transfer_test.go | 493 +++ .../chaincode/mocks/chaincodestub.go | 2878 +++++++++++++++++ .../chaincode/mocks/clientIdentity.go | 399 +++ .../chaincode/mocks/statequeryiterator.go | 232 ++ .../chaincode/mocks/transaction.go | 164 + .../chaincode-go/go.mod | 7 +- .../chaincode-go/main.go | 23 + 13 files changed, 4488 insertions(+), 29 deletions(-) create mode 100755 asset-transfer-basic/application-go/.gitignore create mode 100644 asset-transfer-basic/application-go/assetTransfer.go create mode 100644 asset-transfer-basic/application-go/go.mod create mode 100644 asset-transfer-basic/application-go/go.sum rename asset-transfer-private-data/chaincode-go/{private_asset_queries.go => chaincode/asset_queries.go} (97%) rename asset-transfer-private-data/chaincode-go/{private_asset_transfer.go => chaincode/asset_transfer.go} (98%) create mode 100644 asset-transfer-private-data/chaincode-go/chaincode/asset_transfer_test.go create mode 100644 asset-transfer-private-data/chaincode-go/chaincode/mocks/chaincodestub.go create mode 100644 asset-transfer-private-data/chaincode-go/chaincode/mocks/clientIdentity.go create mode 100644 asset-transfer-private-data/chaincode-go/chaincode/mocks/statequeryiterator.go create mode 100644 asset-transfer-private-data/chaincode-go/chaincode/mocks/transaction.go create mode 100644 asset-transfer-private-data/chaincode-go/main.go diff --git a/asset-transfer-basic/application-go/.gitignore b/asset-transfer-basic/application-go/.gitignore new file mode 100755 index 00000000..e9fec12f --- /dev/null +++ b/asset-transfer-basic/application-go/.gitignore @@ -0,0 +1,4 @@ +wallet +!wallet/.gitkeep + +keystore diff --git a/asset-transfer-basic/application-go/assetTransfer.go b/asset-transfer-basic/application-go/assetTransfer.go new file mode 100644 index 00000000..8bfa5f04 --- /dev/null +++ b/asset-transfer-basic/application-go/assetTransfer.go @@ -0,0 +1,146 @@ +/* +Copyright 2020 IBM All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package main + +import ( + "errors" + "fmt" + "io/ioutil" + "os" + "path/filepath" + + "github.com/hyperledger/fabric-sdk-go/pkg/core/config" + "github.com/hyperledger/fabric-sdk-go/pkg/gateway" +) + +func main() { + fmt.Println("============ application-golang starts ============") + + os.Setenv("DISCOVERY_AS_LOCALHOST", "true") + wallet, err := gateway.NewFileSystemWallet("wallet") + if err != nil { + fmt.Printf("failed to create wallet: %v\n", err) + os.Exit(1) + } + + if !wallet.Exists("appUser") { + err = populateWallet(wallet) + if err != nil { + fmt.Printf("failed to populate wallet contents: %v\n", err) + os.Exit(1) + } + } + + ccpPath := filepath.Join( + "..", + "..", + "test-network", + "organizations", + "peerOrganizations", + "org1.example.com", + "connection-org1.yaml", + ) + + gw, err := gateway.Connect( + gateway.WithConfig(config.FromFile(filepath.Clean(ccpPath))), + gateway.WithIdentity(wallet, "appUser"), + ) + if err != nil { + fmt.Printf("failed to connect to gateway: %v\n", err) + os.Exit(1) + } + defer gw.Close() + + network, err := gw.GetNetwork("mychannel") + if err != nil { + fmt.Printf("failed to get network: %v\n", err) + os.Exit(1) + } + + contract := network.GetContract("basic") + + result, err := contract.EvaluateTransaction("GetAllAssets") + if err != nil { + fmt.Printf("failed to evaluate transaction: %v\n", err) + os.Exit(1) + } + fmt.Println(string(result)) + + result, err = contract.SubmitTransaction("CreateAsset", "asset13", "yellow", "Tom", "5", "1300") + if err != nil { + fmt.Printf("failed to submit transaction: %v\n", err) + os.Exit(1) + } + fmt.Println(string(result)) + + result, err = contract.EvaluateTransaction("ReadAsset", "asset4") + if err != nil { + fmt.Printf("failed to evaluate transaction: %v\n", err) + os.Exit(1) + } + fmt.Println(string(result)) + + _, err = contract.SubmitTransaction("TransferAsset", "asset1", "Tom") + if err != nil { + fmt.Printf("Failed to submit transaction: %v\n", err) + os.Exit(1) + } + + result, err = contract.EvaluateTransaction("ReadAsset", "asset1") + if err != nil { + fmt.Printf("failed to evaluate transaction: %v\n", err) + os.Exit(1) + } + fmt.Println(string(result)) + fmt.Println("============ application-golang ends ============") +} + +func populateWallet(wallet *gateway.Wallet) error { + fmt.Println("============ populate wallet starts ============") + credPath := filepath.Join( + "..", + "..", + "test-network", + "organizations", + "peerOrganizations", + "org1.example.com", + "users", + "User1@org1.example.com", + "msp", + ) + + certPath := filepath.Join(credPath, "signcerts", "cert.pem") + // read the certificate pem + cert, err := ioutil.ReadFile(filepath.Clean(certPath)) + if err != nil { + return err + } + + keyDir := filepath.Join(credPath, "keystore") + // there's a single file in this dir containing the private key + files, err := ioutil.ReadDir(keyDir) + if err != nil { + return err + } + if len(files) != 1 { + return errors.New("keystore folder should have contain one file") + } + keyPath := filepath.Join(keyDir, files[0].Name()) + key, err := ioutil.ReadFile(filepath.Clean(keyPath)) + if err != nil { + return err + } + + identity := gateway.NewX509Identity("Org1MSP", string(cert), string(key)) + + err = wallet.Put("appUser", identity) + if err != nil { + return err + } + fmt.Println("============ populate wallet ends ============") + return nil +} diff --git a/asset-transfer-basic/application-go/go.mod b/asset-transfer-basic/application-go/go.mod new file mode 100644 index 00000000..345e094c --- /dev/null +++ b/asset-transfer-basic/application-go/go.mod @@ -0,0 +1,5 @@ +module asset-transfer-basic + +go 1.14 + +require github.com/hyperledger/fabric-sdk-go v1.0.0-beta2 diff --git a/asset-transfer-basic/application-go/go.sum b/asset-transfer-basic/application-go/go.sum new file mode 100644 index 00000000..d5ad7d7c --- /dev/null +++ b/asset-transfer-basic/application-go/go.sum @@ -0,0 +1,127 @@ +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/Knetic/govaluate v3.0.0+incompatible h1:7o6+MAPhYTCF0+fdvoz1xDedhRb4f6s9Tn1Tt7/WTEg= +github.com/Knetic/govaluate v3.0.0+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= +github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g= +github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973 h1:xJ4a3vCFaGF/jqvzLMYoU8P317H5OQ+Via4RmuPwCS0= +github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cloudflare/cfssl v0.0.0-20180223231731-4e2dcbde5004 h1:lkAMpLVBDaj17e85keuznYcH5rqI438v41pKcBl4ZxQ= +github.com/cloudflare/cfssl v0.0.0-20180223231731-4e2dcbde5004/go.mod h1:yMWuSON2oQp+43nFtAV/uvKQIFpSPerB57DCt9t8sSA= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/go-kit/kit v0.8.0 h1:Wz+5lgoB0kkuqLEc6NVmwRknTKP6dTGbSqvhZtBI/j0= +github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= +github.com/go-logfmt/logfmt v0.4.0 h1:MP4Eh7ZCb31lleYCFuwm0oe4/YGak+5l1vA2NOE80nA= +github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= +github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/gogo/protobuf v1.1.1 h1:72R+M5VuhED/KujmZVcIquuo8mBgX4oVda//DQb3PXo= +github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0 h1:28o5sBqPkBsMGnC6b4MvE2TzSr5/AT4c/1fLqVGIwlk= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/google/certificate-transparency-go v0.0.0-20180222191210-5ab67e519c93 h1:qdfmdGwtm13OVx+AxguOWUTbgmXGn2TbdUHipo3chMg= +github.com/google/certificate-transparency-go v0.0.0-20180222191210-5ab67e519c93/go.mod h1:QeJfpSbVSfYc7RgB3gJFj9cbuQMMchQxrWXz8Ruopmg= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/hashicorp/hcl v0.0.0-20180404174102-ef8a98b0bbce h1:xdsDDbiBDQTKASoGEZ+pEmF1OnWuu8AQ9I8iNbHNeno= +github.com/hashicorp/hcl v0.0.0-20180404174102-ef8a98b0bbce/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/hyperledger/fabric-lib-go v1.0.0 h1:UL1w7c9LvHZUSkIvHTDGklxFv2kTeva1QI2emOVc324= +github.com/hyperledger/fabric-lib-go v1.0.0/go.mod h1:H362nMlunurmHwkYqR5uHL2UDWbQdbfz74n8kbCFsqc= +github.com/hyperledger/fabric-protos-go v0.0.0-20191121202242-f5500d5e3e85 h1:bNgEcCg5NVRWs/T+VUEfhgh5Olx/N4VB+0+ybW+oSuA= +github.com/hyperledger/fabric-protos-go v0.0.0-20191121202242-f5500d5e3e85/go.mod h1:xVYTjK4DtZRBxZ2D9aE4y6AbLaPwue2o/criQyQbVD0= +github.com/hyperledger/fabric-sdk-go v1.0.0-beta1.0.20200526155846-219a09aadc0f h1:eAkJx0+8PBbfP6xZxVRD2agk9W7oDbqllxO+ERgnKJk= +github.com/hyperledger/fabric-sdk-go v1.0.0-beta1.0.20200526155846-219a09aadc0f/go.mod h1:/s224b8NLvOJOCIqBvWd9O6u7GE33iuIOT6OfcTE1OE= +github.com/hyperledger/fabric-sdk-go v1.0.0-beta2 h1:FBYygns0Qga+mQ4PXycyTU5m4N9KAZM+Ttf7agiV7M8= +github.com/hyperledger/fabric-sdk-go v1.0.0-beta2/go.mod h1:/s224b8NLvOJOCIqBvWd9O6u7GE33iuIOT6OfcTE1OE= +github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY= +github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/magiconair/properties v1.7.6 h1:U+1DqNen04MdEPgFiIwdOUiqZ8qPa37xgogX/sd3+54= +github.com/magiconair/properties v1.7.6/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= +github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU= +github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= +github.com/miekg/pkcs11 v0.0.0-20190329070431-55f3fac3af27/go.mod h1:WCBAbTOdfhHhz7YXujeZMF7owC4tPb1naKFsgfUISjo= +github.com/mitchellh/mapstructure v0.0.0-20180220230111-00c29f56e238 h1:+MZW2uvHgN8kYvksEN3f7eFL2wpzk0GxmlFsMybWc7E= +github.com/mitchellh/mapstructure v0.0.0-20180220230111-00c29f56e238/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/gomega v1.4.2/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/pelletier/go-toml v1.1.0 h1:cmiOvKzEunMsAxyhXSzpL5Q1CRKpVv0KQsnAIcSEVYM= +github.com/pelletier/go-toml v1.1.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= +github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v0.8.0 h1:1921Yw9Gc3iSc4VQh3PIoOqgPCZS7G/4xQNVUp8Mda8= +github.com/prometheus/client_golang v0.8.0/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= +github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910 h1:idejC8f05m9MGOsuEi1ATq9shN03HrxNkD/luQvxCv8= +github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= +github.com/prometheus/common v0.0.0-20180518154759-7600349dcfe1 h1:osmNoEW2SCW3L7EX0km2LYM8HKpNWRiouxjE3XHkyGc= +github.com/prometheus/common v0.0.0-20180518154759-7600349dcfe1/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro= +github.com/prometheus/procfs v0.0.0-20180705121852-ae68e2d4c00f h1:c9M4CCa6g8WURSsbrl3lb/w/G1Z5xZpYvhhjdcVDOkE= +github.com/prometheus/procfs v0.0.0-20180705121852-ae68e2d4c00f/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/spf13/afero v1.1.0 h1:bopulORc2JeYaxfHLvJa5NzxviA9PoWhpiiJkru7Ji4= +github.com/spf13/afero v1.1.0/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= +github.com/spf13/cast v1.2.0 h1:HHl1DSRbEQN2i8tJmtS6ViPyHx35+p51amrdsiTCrkg= +github.com/spf13/cast v1.2.0/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg= +github.com/spf13/jwalterweatherman v0.0.0-20180109140146-7c0cea34c8ec h1:2ZXvIUGghLpdTVHR1UfvfrzoVlZaE/yOWC5LueIHZig= +github.com/spf13/jwalterweatherman v0.0.0-20180109140146-7c0cea34c8ec/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= +github.com/spf13/pflag v1.0.1 h1:aCvUg6QPl3ibpQUxyLkrEkCHtPqYJL4x9AuhqVqFis4= +github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/spf13/viper v1.0.2 h1:Ncr3ZIuJn322w2k1qmzXDnkLAdQMlJqBa9kfAH+irso= +github.com/spf13/viper v1.0.2/go.mod h1:A8kyI5cUJhb8N+3pkfONlcEcZbueH6nhAm0Fq7SrnBM= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a h1:oWX7TPOiFAMXLq8o0ikBYfCJVlRHBcsciT5bXOrH628= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190327125643-d831d65fe17d h1:XB2jc5XQ9uhizGTS2vWcN01bc4dI6z3C4KY5MQm8SS8= +google.golang.org/genproto v0.0.0-20190327125643-d831d65fe17d/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.23.0 h1:AzbTB6ux+okLTzP8Ru1Xs41C303zdcfEht7MQnYJt5A= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/asset-transfer-private-data/chaincode-go/private_asset_queries.go b/asset-transfer-private-data/chaincode-go/chaincode/asset_queries.go similarity index 97% rename from asset-transfer-private-data/chaincode-go/private_asset_queries.go rename to asset-transfer-private-data/chaincode-go/chaincode/asset_queries.go index ea834a82..8672e31d 100644 --- a/asset-transfer-private-data/chaincode-go/private_asset_queries.go +++ b/asset-transfer-private-data/chaincode-go/chaincode/asset_queries.go @@ -4,7 +4,7 @@ Copyright IBM Corp. All Rights Reserved. SPDX-License-Identifier: Apache-2.0 */ -package main +package chaincode import ( "encoding/json" @@ -20,7 +20,7 @@ func (s *SmartContract) ReadAsset(ctx contractapi.TransactionContextInterface, a log.Printf("ReadAsset: collection %v, ID %v", assetCollection, assetID) assetJSON, err := ctx.GetStub().GetPrivateData(assetCollection, assetID) //get the asset from chaincode state if err != nil { - return nil, fmt.Errorf("failed to read from asset %v", err) + return nil, fmt.Errorf("failed to read asset: %v", err) } //No Asset found, return empty response @@ -44,7 +44,7 @@ func (s *SmartContract) ReadAssetPrivateDetails(ctx contractapi.TransactionConte log.Printf("ReadAssetPrivateDetails: collection %v, ID %v", collection, assetID) assetDetailsJSON, err := ctx.GetStub().GetPrivateData(collection, assetID) // Get the asset from chaincode state if err != nil { - return nil, fmt.Errorf("failed to read from asset details %v", err) + return nil, fmt.Errorf("failed to read asset details: %v", err) } if assetDetailsJSON == nil { log.Printf("AssetPrivateDetails for %v does not exist in collection %v", assetID, collection) @@ -147,7 +147,6 @@ func (s *SmartContract) QueryAssetByOwner(ctx contractapi.TransactionContextInte return queryResults, nil } - // QueryAssets uses a query string to perform a query for assets. // Query string matching state database syntax is passed in and executed as is. // Supports ad hoc queries that can be defined at runtime by the client. diff --git a/asset-transfer-private-data/chaincode-go/private_asset_transfer.go b/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer.go similarity index 98% rename from asset-transfer-private-data/chaincode-go/private_asset_transfer.go rename to asset-transfer-private-data/chaincode-go/chaincode/asset_transfer.go index c3e51dd0..7010e62c 100644 --- a/asset-transfer-private-data/chaincode-go/private_asset_transfer.go +++ b/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer.go @@ -4,7 +4,7 @@ Copyright IBM Corp. All Rights Reserved. SPDX-License-Identifier: Apache-2.0 */ -package main +package chaincode import ( "bytes" @@ -19,6 +19,11 @@ import ( const assetCollection = "assetCollection" const transferAgreementObjectType = "transferAgreement" +// SmartContract of this fabric sample +type SmartContract struct { + contractapi.Contract +} + // Asset describes main asset details that are visible to all organizations type Asset struct { Type string `json:"objectType"` //Type is used to distinguish the various types of objects in state database @@ -40,11 +45,6 @@ type TransferAgreement struct { BuyerID string `json:"buyerID"` } -// SmartContract of this fabric sample -type SmartContract struct { - contractapi.Contract -} - // CreateAsset creates a new asset by placing the main asset details in the assetCollection // that can be read by both organizations. The appraisal value is stored in the owners org specific collection. func (s *SmartContract) CreateAsset(ctx contractapi.TransactionContextInterface) error { @@ -273,9 +273,11 @@ func (s *SmartContract) TransferAsset(ctx contractapi.TransactionContextInterfac // Read asset from the private data collection asset, err := s.ReadAsset(ctx, assetTransferInput.ID) if err != nil { - return fmt.Errorf("failed to get asset: %v", err) + return fmt.Errorf("error reading asset: %v", err) + } + if asset == nil { + return fmt.Errorf("%v does not exist", assetTransferInput.ID) } - // Verify that the client is submitting request to peer in their organization err = verifyClientOrgMatchesPeerOrg(ctx) if err != nil { @@ -561,17 +563,3 @@ func verifyClientOrgMatchesPeerOrg(ctx contractapi.TransactionContextInterface) return nil } - -func main() { - - chaincode, err := contractapi.NewChaincode(new(SmartContract)) - - if err != nil { - log.Panicf("error creating the chaincode: %v", err) - return - } - - if err := chaincode.Start(); err != nil { - log.Panicf("error starting the chaincode: %v", err) - } -} diff --git a/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer_test.go b/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer_test.go new file mode 100644 index 00000000..f3de987e --- /dev/null +++ b/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer_test.go @@ -0,0 +1,493 @@ +package chaincode_test + +import ( + "encoding/json" + "fmt" + "os" + "testing" + + "github.com/hyperledger/fabric-chaincode-go/pkg/cid" + "github.com/hyperledger/fabric-chaincode-go/shim" + "github.com/hyperledger/fabric-contract-api-go/contractapi" + + "github.com/hyperledger/fabric-samples/asset-transfer-private-data/chaincode-go/chaincode" + "github.com/hyperledger/fabric-samples/asset-transfer-private-data/chaincode-go/chaincode/mocks" + "github.com/stretchr/testify/require" +) + +/* +These unit tests use mocks to simulate chaincode-api & fabric interactions +The mocks are generated using counterfeiter directives in the comments (starting with "go:generate counterfeiter") +All files in mocks/* are generated by running following, in the directory with your directive: + `go generate` +*/ + +//go:generate counterfeiter -o mocks/transaction.go -fake-name TransactionContext . transactionContext +type transactionContext interface { + contractapi.TransactionContextInterface +} + +//go:generate counterfeiter -o mocks/chaincodestub.go -fake-name ChaincodeStub . chaincodeStub +type chaincodeStub interface { + shim.ChaincodeStubInterface +} + +//go:generate counterfeiter -o mocks/statequeryiterator.go -fake-name StateQueryIterator . stateQueryIterator +type stateQueryIterator interface { + shim.StateQueryIteratorInterface +} + +//go:generate counterfeiter -o mocks/clientIdentity.go -fake-name ClientIdentity . clientIdentity +type clientIdentity interface { + cid.ClientIdentity +} + +const assetCollectionName = "assetCollection" +const transferAgreementObjectType = "transferAgreement" +const myOrg1Msp = "Org1Testmsp" +const myOrg1Clientid = "myOrg1Userid" +const myOrg1PrivCollection = "Org1TestmspPrivateCollection" +const myOrg2Msp = "Org2Testmsp" +const myOrg2Clientid = "myOrg2Userid" +const myOrg2PrivCollection = "Org2TestmspPrivateCollection" + +type assetTransientInput struct { + Type string `json:"objectType"` + ID string `json:"assetID"` + Color string `json:"color"` + Size int `json:"size"` + AppraisedValue int `json:"appraisedValue"` +} + +type assetTransferTransientInput struct { + ID string `json:"assetID"` + BuyerMSP string `json:"buyerMSP"` +} + +func TestCreateAssetBadInput(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + + // No transient map + err := assetTransferCC.CreateAsset(transactionContext) + require.EqualError(t, err, "asset not found in the transient map input") + + // transient map with incomplete asset data + assetPropMap := map[string][]byte{ + "asset_properties": []byte("ill formatted property"), + } + chaincodeStub.GetTransientReturns(assetPropMap, nil) + err = assetTransferCC.CreateAsset(transactionContext) + require.Error(t, err, "Expected error: transient map with incomplete asset data") + require.Contains(t, err.Error(), "failed to unmarshal JSON") + + testAsset := &assetTransientInput{ + Type: "testfulasset", + } + setReturnAssetPropsInTransientMap(t, chaincodeStub, testAsset) + err = assetTransferCC.CreateAsset(transactionContext) + require.EqualError(t, err, "assetID field must be a non-empty string") + + testAsset = &assetTransientInput{ + ID: "id1", + Color: "gray", + } + setReturnAssetPropsInTransientMap(t, chaincodeStub, testAsset) + err = assetTransferCC.CreateAsset(transactionContext) + require.EqualError(t, err, "objectType field must be a non-empty string") + + // case when asset exists, GetPrivateData returns a valid data from ledger + testAsset = &assetTransientInput{ + ID: "id1", + Type: "testfulasset", + Color: "gray", + Size: 7, + AppraisedValue: 500, + } + setReturnAssetPropsInTransientMap(t, chaincodeStub, testAsset) + chaincodeStub.GetPrivateDataReturns([]byte{}, nil) + err = assetTransferCC.CreateAsset(transactionContext) + require.EqualError(t, err, "this asset already exists: id1") +} + +func TestCreateAssetSuccessful(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + testAsset := &assetTransientInput{ + ID: "id1", + Type: "testfulasset", + Color: "gray", + Size: 7, + AppraisedValue: 500, + } + setReturnAssetPropsInTransientMap(t, chaincodeStub, testAsset) + err := assetTransferCC.CreateAsset(transactionContext) + require.NoError(t, err) + //Validate PutPrivateData calls + calledCollection, calledId, _ := chaincodeStub.PutPrivateDataArgsForCall(0) + require.Equal(t, assetCollectionName, calledCollection) + require.Equal(t, "id1", calledId) + + expectedPrivateDetails := &chaincode.AssetPrivateDetails{ + ID: "id1", + AppraisedValue: 500, + } + assetBytes, err := json.Marshal(expectedPrivateDetails) + calledCollection, calledId, calledAssetBytes := chaincodeStub.PutPrivateDataArgsForCall(1) + require.Equal(t, myOrg1PrivCollection, calledCollection) + require.Equal(t, "id1", calledId) + require.Equal(t, assetBytes, calledAssetBytes) +} + +func TestReadAsset(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + + assetBytes, err := assetTransferCC.ReadAsset(transactionContext, "id1") + require.NoError(t, err) + require.Nil(t, assetBytes) + + chaincodeStub.GetPrivateDataReturns(nil, fmt.Errorf("unable to retrieve asset")) + assetBytes, err = assetTransferCC.ReadAsset(transactionContext, "id1") + require.EqualError(t, err, "failed to read asset: unable to retrieve asset") + + testAsset := &chaincode.Asset{ + ID: "id1", + Type: "testfulasset", + Color: "gray", + Size: 7, + Owner: myOrg1Clientid, + } + setReturnPrivateDataInStub(t, chaincodeStub, testAsset) + assetRead, err := assetTransferCC.ReadAsset(transactionContext, "id1") + require.NoError(t, err) + require.Equal(t, testAsset, assetRead) +} + +//todo +// ReadAssetPrivateDetails +// AgreeToTransfer + +func TestTransferAsset(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + assetNewOwner := &assetTransferTransientInput{ + ID: "id1", + BuyerMSP: myOrg2Msp, + } + setReturnAssetOwnerInTransientMap(t, chaincodeStub, assetNewOwner) + origAsset := chaincode.Asset{ + ID: "id1", + Type: "testfulasset", + Color: "gray", + Size: 7, + Owner: myOrg1Clientid, + } + setReturnPrivateDataInStub(t, chaincodeStub, &origAsset) + //to ensure we pass data hash verification + chaincodeStub.GetPrivateDataHashReturns([]byte("datahash"), nil) + //to ensure that ReadTransferAgreement call returns org2 client ID + chaincodeStub.GetPrivateDataReturnsOnCall(1, []byte(myOrg2Clientid), nil) + chaincodeStub.CreateCompositeKeyReturns(transferAgreementObjectType+"id1", nil) + + err := assetTransferCC.TransferAsset(transactionContext) + require.NoError(t, err) + //Validate PutPrivateData calls + expectedNewAsset := origAsset + expectedNewAsset.Owner = myOrg2Clientid + expectedNewAssetBytes, err := json.Marshal(expectedNewAsset) + require.NoError(t, err) + calledCollection, calledId, calledWithAssetBytes := chaincodeStub.PutPrivateDataArgsForCall(0) + require.Equal(t, assetCollectionName, calledCollection) + require.Equal(t, "id1", calledId) + require.Equal(t, expectedNewAssetBytes, calledWithAssetBytes) + calledCollection, calledId = chaincodeStub.DelPrivateDataArgsForCall(0) + require.Equal(t, myOrg1PrivCollection, calledCollection) + require.Equal(t, "id1", calledId) + + calledCollection, calledId = chaincodeStub.DelPrivateDataArgsForCall(1) + require.Equal(t, assetCollectionName, calledCollection) + require.Equal(t, transferAgreementObjectType+"id1", calledId) + +} + +func TestTransferAssetByNonOwner(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + assetNewOwner := &assetTransferTransientInput{ + ID: "id1", + BuyerMSP: myOrg1Msp, + } + setReturnAssetOwnerInTransientMap(t, chaincodeStub, assetNewOwner) + //Try to transfer asset owned by Org2 + org2Asset := chaincode.Asset{ + ID: "id1", + Type: "testfulasset", + Color: "gray", + Size: 7, + Owner: myOrg2Clientid, + } + setReturnPrivateDataInStub(t, chaincodeStub, &org2Asset) + err := assetTransferCC.TransferAsset(transactionContext) + require.EqualError(t, err, "failed transfer verification: error: submitting client identity does not own asset") +} + +func TestTransferAssetWithoutAnAgreement(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + assetNewOwner := &assetTransferTransientInput{ + ID: "id1", + BuyerMSP: myOrg1Msp, + } + setReturnAssetOwnerInTransientMap(t, chaincodeStub, assetNewOwner) + orgAsset := chaincode.Asset{ + ID: "id1", + Type: "testfulasset", + Color: "gray", + Size: 7, + Owner: myOrg1Clientid, + } + setReturnPrivateDataInStub(t, chaincodeStub, &orgAsset) + //to ensure we pass data hash verification + chaincodeStub.GetPrivateDataHashReturns([]byte("datahash"), nil) + chaincodeStub.CreateCompositeKeyReturns(transferAgreementObjectType+"id1", nil) + //ReadTransferAgreement call returns no buyer client ID + chaincodeStub.GetPrivateDataReturnsOnCall(1, []byte{}, nil) + + err := assetTransferCC.TransferAsset(transactionContext) + require.EqualError(t, err, "BuyerID not found in TransferAgreement for id1") +} + +func TestTransferAssetBadInput(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + + assetNewOwner := &assetTransferTransientInput{ + ID: "id1", + BuyerMSP: "", + } + setReturnAssetOwnerInTransientMap(t, chaincodeStub, assetNewOwner) + setReturnPrivateDataInStub(t, chaincodeStub, &chaincode.Asset{}) + err := assetTransferCC.TransferAsset(transactionContext) + require.EqualError(t, err, "buyerMSP field must be a non-empty string") + + assetNewOwner = &assetTransferTransientInput{ + ID: "id1", + BuyerMSP: myOrg2Msp, + } + setReturnAssetOwnerInTransientMap(t, chaincodeStub, assetNewOwner) + //asset does not exist + setReturnPrivateDataInStub(t, chaincodeStub, nil) + err = assetTransferCC.TransferAsset(transactionContext) + require.EqualError(t, err, "id1 does not exist") +} + +func TestTransferAssetNonMatchingAppraisalValue(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + assetNewOwner := &assetTransferTransientInput{ + ID: "id1", + BuyerMSP: myOrg2Msp, + } + setReturnAssetOwnerInTransientMap(t, chaincodeStub, assetNewOwner) + + orgAsset := chaincode.Asset{ + ID: "id1", + Type: "testfulasset", + Color: "gray", + Size: 7, + Owner: myOrg1Clientid, + } + setReturnPrivateDataInStub(t, chaincodeStub, &orgAsset) + chaincodeStub.CreateCompositeKeyReturns(transferAgreementObjectType+"id1", nil) + //data hash different in each collection + chaincodeStub.GetPrivateDataHashReturnsOnCall(0, []byte("datahash1"), nil) + chaincodeStub.GetPrivateDataHashReturnsOnCall(1, []byte("datahash2"), nil) + + err := assetTransferCC.TransferAsset(transactionContext) + require.Error(t, err, "Expected failed hash verification") + require.Contains(t, err.Error(), "failed transfer verification: hash for appraised value") +} + +func prepMocksAsOrg1() (*mocks.TransactionContext, *mocks.ChaincodeStub) { + return prepMocks(myOrg1Msp, myOrg1Clientid) +} +func prepMocksAsOrg2() (*mocks.TransactionContext, *mocks.ChaincodeStub) { + return prepMocks(myOrg2Msp, myOrg2Clientid) +} +func prepMocks(orgMSP, clientId string) (*mocks.TransactionContext, *mocks.ChaincodeStub) { + chaincodeStub := &mocks.ChaincodeStub{} + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + clientIdentity := &mocks.ClientIdentity{} + clientIdentity.GetMSPIDReturns(orgMSP, nil) + clientIdentity.GetIDReturns(clientId, nil) + //set matching msp ID using peer shim env variable + os.Setenv("CORE_PEER_LOCALMSPID", orgMSP) + transactionContext.GetClientIdentityReturns(clientIdentity) + return transactionContext, chaincodeStub +} + +func setReturnAssetOwnerInTransientMap(t *testing.T, chaincodeStub *mocks.ChaincodeStub, assetOwner *assetTransferTransientInput) []byte { + assetOwnerBytes := []byte{} + if assetOwner != nil { + var err error + assetOwnerBytes, err = json.Marshal(assetOwner) + require.NoError(t, err) + } + assetPropMap := map[string][]byte{ + "asset_owner": assetOwnerBytes, + } + chaincodeStub.GetTransientReturns(assetPropMap, nil) + return assetOwnerBytes +} + +func setReturnAssetPropsInTransientMap(t *testing.T, chaincodeStub *mocks.ChaincodeStub, testAsset *assetTransientInput) []byte { + assetBytes := []byte{} + if testAsset != nil { + var err error + assetBytes, err = json.Marshal(testAsset) + require.NoError(t, err) + } + assetPropMap := map[string][]byte{ + "asset_properties": assetBytes, + } + chaincodeStub.GetTransientReturns(assetPropMap, nil) + return assetBytes +} + +func setReturnPrivateDataInStub(t *testing.T, chaincodeStub *mocks.ChaincodeStub, testAsset *chaincode.Asset) []byte { + assetBytes := []byte{} + if testAsset != nil { + var err error + assetBytes, err = json.Marshal(testAsset) + require.NoError(t, err) + } + chaincodeStub.GetPrivateDataReturns(assetBytes, nil) + return assetBytes +} + +/* +func TestReadAsset(t *testing.T) { + chaincodeStub := &mocks.ChaincodeStub{} + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + expectedAsset := &chaincode.Asset{ID: "asset1"} + bytes, err := json.Marshal(expectedAsset) + require.NoError(t, err) + + chaincodeStub.GetStateReturns(bytes, nil) + assetTransferCC := chaincode.SmartContract{} + asset, err := assetTransferCC.ReadAsset(transactionContext, "") + require.NoError(t, err) + require.Equal(t, expectedAsset, asset) + + chaincodeStub.GetStateReturns(nil, fmt.Errorf("unable to retrieve asset")) + _, err = assetTransferCC.ReadAsset(transactionContext, "") + require.EqualError(t, err, "failed to read from world state: unable to retrieve asset") + + chaincodeStub.GetStateReturns(nil, nil) + asset, err = assetTransferCC.ReadAsset(transactionContext, "asset1") + require.EqualError(t, err, "the asset asset1 does not exist") + require.Nil(t, asset) +} + +func TestUpdateAsset(t *testing.T) { + chaincodeStub := &mocks.ChaincodeStub{} + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + expectedAsset := &chaincode.Asset{ID: "asset1"} + bytes, err := json.Marshal(expectedAsset) + require.NoError(t, err) + + chaincodeStub.GetStateReturns(bytes, nil) + assetTransferCC := chaincode.SmartContract{} + err = assetTransferCC.UpdateAsset(transactionContext, "", "", 0, "", 0) + require.NoError(t, err) + + chaincodeStub.GetStateReturns(nil, nil) + err = assetTransferCC.UpdateAsset(transactionContext, "asset1", "", 0, "", 0) + require.EqualError(t, err, "the asset asset1 does not exist") + + chaincodeStub.GetStateReturns(nil, fmt.Errorf("unable to retrieve asset")) + err = assetTransferCC.UpdateAsset(transactionContext, "asset1", "", 0, "", 0) + require.EqualError(t, err, "failed to read from world state: unable to retrieve asset") +} + +func TestDeleteAsset(t *testing.T) { + chaincodeStub := &mocks.ChaincodeStub{} + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + asset := &chaincode.Asset{ID: "asset1"} + bytes, err := json.Marshal(asset) + require.NoError(t, err) + + chaincodeStub.GetStateReturns(bytes, nil) + chaincodeStub.DelStateReturns(nil) + assetTransferCC := chaincode.SmartContract{} + err = assetTransferCC.DeleteAsset(transactionContext, "") + require.NoError(t, err) + + chaincodeStub.GetStateReturns(nil, nil) + err = assetTransferCC.DeleteAsset(transactionContext, "asset1") + require.EqualError(t, err, "the asset asset1 does not exist") + + chaincodeStub.GetStateReturns(nil, fmt.Errorf("unable to retrieve asset")) + err = assetTransferCC.DeleteAsset(transactionContext, "") + require.EqualError(t, err, "failed to read from world state: unable to retrieve asset") +} + +func TestTransferAsset(t *testing.T) { + chaincodeStub := &mocks.ChaincodeStub{} + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + asset := &chaincode.Asset{ID: "asset1"} + bytes, err := json.Marshal(asset) + require.NoError(t, err) + + chaincodeStub.GetStateReturns(bytes, nil) + assetTransferCC := chaincode.SmartContract{} + err = assetTransferCC.TransferAsset(transactionContext, "", "") + require.NoError(t, err) + + chaincodeStub.GetStateReturns(nil, fmt.Errorf("unable to retrieve asset")) + err = assetTransferCC.TransferAsset(transactionContext, "", "") + require.EqualError(t, err, "failed to read from world state: unable to retrieve asset") +} + +func TestGetAllAssets(t *testing.T) { + asset := &chaincode.Asset{ID: "asset1"} + bytes, err := json.Marshal(asset) + require.NoError(t, err) + + iterator := &mocks.StateQueryIterator{} + iterator.HasNextReturnsOnCall(0, true) + iterator.HasNextReturnsOnCall(1, false) + iterator.NextReturns(&queryresult.KV{Value: bytes}, nil) + + chaincodeStub := &mocks.ChaincodeStub{} + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + chaincodeStub.GetStateByRangeReturns(iterator, nil) + assetTransferCC := &chaincode.SmartContract{} + assets, err := assetTransferCC.GetAllAssets(transactionContext) + require.NoError(t, err) + require.Equal(t, []*chaincode.Asset{asset}, assets) + + iterator.HasNextReturns(true) + iterator.NextReturns(nil, fmt.Errorf("failed retrieving next item")) + assets, err = assetTransferCC.GetAllAssets(transactionContext) + require.EqualError(t, err, "failed retrieving next item") + require.Nil(t, assets) + + chaincodeStub.GetStateByRangeReturns(nil, fmt.Errorf("failed retrieving all assets")) + assets, err = assetTransferCC.GetAllAssets(transactionContext) + require.EqualError(t, err, "failed retrieving all assets") + require.Nil(t, assets) +}*/ diff --git a/asset-transfer-private-data/chaincode-go/chaincode/mocks/chaincodestub.go b/asset-transfer-private-data/chaincode-go/chaincode/mocks/chaincodestub.go new file mode 100644 index 00000000..eea9056c --- /dev/null +++ b/asset-transfer-private-data/chaincode-go/chaincode/mocks/chaincodestub.go @@ -0,0 +1,2878 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mocks + +import ( + "sync" + + "github.com/hyperledger/fabric-chaincode-go/shim" + "github.com/hyperledger/fabric-protos-go/peer" + "google.golang.org/protobuf/types/known/timestamppb" +) + +type ChaincodeStub struct { + CreateCompositeKeyStub func(string, []string) (string, error) + createCompositeKeyMutex sync.RWMutex + createCompositeKeyArgsForCall []struct { + arg1 string + arg2 []string + } + createCompositeKeyReturns struct { + result1 string + result2 error + } + createCompositeKeyReturnsOnCall map[int]struct { + result1 string + result2 error + } + DelPrivateDataStub func(string, string) error + delPrivateDataMutex sync.RWMutex + delPrivateDataArgsForCall []struct { + arg1 string + arg2 string + } + delPrivateDataReturns struct { + result1 error + } + delPrivateDataReturnsOnCall map[int]struct { + result1 error + } + DelStateStub func(string) error + delStateMutex sync.RWMutex + delStateArgsForCall []struct { + arg1 string + } + delStateReturns struct { + result1 error + } + delStateReturnsOnCall map[int]struct { + result1 error + } + GetArgsStub func() [][]byte + getArgsMutex sync.RWMutex + getArgsArgsForCall []struct { + } + getArgsReturns struct { + result1 [][]byte + } + getArgsReturnsOnCall map[int]struct { + result1 [][]byte + } + GetArgsSliceStub func() ([]byte, error) + getArgsSliceMutex sync.RWMutex + getArgsSliceArgsForCall []struct { + } + getArgsSliceReturns struct { + result1 []byte + result2 error + } + getArgsSliceReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetBindingStub func() ([]byte, error) + getBindingMutex sync.RWMutex + getBindingArgsForCall []struct { + } + getBindingReturns struct { + result1 []byte + result2 error + } + getBindingReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetChannelIDStub func() string + getChannelIDMutex sync.RWMutex + getChannelIDArgsForCall []struct { + } + getChannelIDReturns struct { + result1 string + } + getChannelIDReturnsOnCall map[int]struct { + result1 string + } + GetCreatorStub func() ([]byte, error) + getCreatorMutex sync.RWMutex + getCreatorArgsForCall []struct { + } + getCreatorReturns struct { + result1 []byte + result2 error + } + getCreatorReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetDecorationsStub func() map[string][]byte + getDecorationsMutex sync.RWMutex + getDecorationsArgsForCall []struct { + } + getDecorationsReturns struct { + result1 map[string][]byte + } + getDecorationsReturnsOnCall map[int]struct { + result1 map[string][]byte + } + GetFunctionAndParametersStub func() (string, []string) + getFunctionAndParametersMutex sync.RWMutex + getFunctionAndParametersArgsForCall []struct { + } + getFunctionAndParametersReturns struct { + result1 string + result2 []string + } + getFunctionAndParametersReturnsOnCall map[int]struct { + result1 string + result2 []string + } + GetHistoryForKeyStub func(string) (shim.HistoryQueryIteratorInterface, error) + getHistoryForKeyMutex sync.RWMutex + getHistoryForKeyArgsForCall []struct { + arg1 string + } + getHistoryForKeyReturns struct { + result1 shim.HistoryQueryIteratorInterface + result2 error + } + getHistoryForKeyReturnsOnCall map[int]struct { + result1 shim.HistoryQueryIteratorInterface + result2 error + } + GetPrivateDataStub func(string, string) ([]byte, error) + getPrivateDataMutex sync.RWMutex + getPrivateDataArgsForCall []struct { + arg1 string + arg2 string + } + getPrivateDataReturns struct { + result1 []byte + result2 error + } + getPrivateDataReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetPrivateDataByPartialCompositeKeyStub func(string, string, []string) (shim.StateQueryIteratorInterface, error) + getPrivateDataByPartialCompositeKeyMutex sync.RWMutex + getPrivateDataByPartialCompositeKeyArgsForCall []struct { + arg1 string + arg2 string + arg3 []string + } + getPrivateDataByPartialCompositeKeyReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getPrivateDataByPartialCompositeKeyReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetPrivateDataByRangeStub func(string, string, string) (shim.StateQueryIteratorInterface, error) + getPrivateDataByRangeMutex sync.RWMutex + getPrivateDataByRangeArgsForCall []struct { + arg1 string + arg2 string + arg3 string + } + getPrivateDataByRangeReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getPrivateDataByRangeReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetPrivateDataHashStub func(string, string) ([]byte, error) + getPrivateDataHashMutex sync.RWMutex + getPrivateDataHashArgsForCall []struct { + arg1 string + arg2 string + } + getPrivateDataHashReturns struct { + result1 []byte + result2 error + } + getPrivateDataHashReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetPrivateDataQueryResultStub func(string, string) (shim.StateQueryIteratorInterface, error) + getPrivateDataQueryResultMutex sync.RWMutex + getPrivateDataQueryResultArgsForCall []struct { + arg1 string + arg2 string + } + getPrivateDataQueryResultReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getPrivateDataQueryResultReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetPrivateDataValidationParameterStub func(string, string) ([]byte, error) + getPrivateDataValidationParameterMutex sync.RWMutex + getPrivateDataValidationParameterArgsForCall []struct { + arg1 string + arg2 string + } + getPrivateDataValidationParameterReturns struct { + result1 []byte + result2 error + } + getPrivateDataValidationParameterReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetQueryResultStub func(string) (shim.StateQueryIteratorInterface, error) + getQueryResultMutex sync.RWMutex + getQueryResultArgsForCall []struct { + arg1 string + } + getQueryResultReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getQueryResultReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetQueryResultWithPaginationStub func(string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) + getQueryResultWithPaginationMutex sync.RWMutex + getQueryResultWithPaginationArgsForCall []struct { + arg1 string + arg2 int32 + arg3 string + } + getQueryResultWithPaginationReturns struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + getQueryResultWithPaginationReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + GetSignedProposalStub func() (*peer.SignedProposal, error) + getSignedProposalMutex sync.RWMutex + getSignedProposalArgsForCall []struct { + } + getSignedProposalReturns struct { + result1 *peer.SignedProposal + result2 error + } + getSignedProposalReturnsOnCall map[int]struct { + result1 *peer.SignedProposal + result2 error + } + GetStateStub func(string) ([]byte, error) + getStateMutex sync.RWMutex + getStateArgsForCall []struct { + arg1 string + } + getStateReturns struct { + result1 []byte + result2 error + } + getStateReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetStateByPartialCompositeKeyStub func(string, []string) (shim.StateQueryIteratorInterface, error) + getStateByPartialCompositeKeyMutex sync.RWMutex + getStateByPartialCompositeKeyArgsForCall []struct { + arg1 string + arg2 []string + } + getStateByPartialCompositeKeyReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getStateByPartialCompositeKeyReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetStateByPartialCompositeKeyWithPaginationStub func(string, []string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) + getStateByPartialCompositeKeyWithPaginationMutex sync.RWMutex + getStateByPartialCompositeKeyWithPaginationArgsForCall []struct { + arg1 string + arg2 []string + arg3 int32 + arg4 string + } + getStateByPartialCompositeKeyWithPaginationReturns struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + getStateByPartialCompositeKeyWithPaginationReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + GetStateByRangeStub func(string, string) (shim.StateQueryIteratorInterface, error) + getStateByRangeMutex sync.RWMutex + getStateByRangeArgsForCall []struct { + arg1 string + arg2 string + } + getStateByRangeReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getStateByRangeReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetStateByRangeWithPaginationStub func(string, string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) + getStateByRangeWithPaginationMutex sync.RWMutex + getStateByRangeWithPaginationArgsForCall []struct { + arg1 string + arg2 string + arg3 int32 + arg4 string + } + getStateByRangeWithPaginationReturns struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + getStateByRangeWithPaginationReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + GetStateValidationParameterStub func(string) ([]byte, error) + getStateValidationParameterMutex sync.RWMutex + getStateValidationParameterArgsForCall []struct { + arg1 string + } + getStateValidationParameterReturns struct { + result1 []byte + result2 error + } + getStateValidationParameterReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetStringArgsStub func() []string + getStringArgsMutex sync.RWMutex + getStringArgsArgsForCall []struct { + } + getStringArgsReturns struct { + result1 []string + } + getStringArgsReturnsOnCall map[int]struct { + result1 []string + } + GetTransientStub func() (map[string][]byte, error) + getTransientMutex sync.RWMutex + getTransientArgsForCall []struct { + } + getTransientReturns struct { + result1 map[string][]byte + result2 error + } + getTransientReturnsOnCall map[int]struct { + result1 map[string][]byte + result2 error + } + GetTxIDStub func() string + getTxIDMutex sync.RWMutex + getTxIDArgsForCall []struct { + } + getTxIDReturns struct { + result1 string + } + getTxIDReturnsOnCall map[int]struct { + result1 string + } + GetTxTimestampStub func() (*timestamppb.Timestamp, error) + getTxTimestampMutex sync.RWMutex + getTxTimestampArgsForCall []struct { + } + getTxTimestampReturns struct { + result1 *timestamppb.Timestamp + result2 error + } + getTxTimestampReturnsOnCall map[int]struct { + result1 *timestamppb.Timestamp + result2 error + } + InvokeChaincodeStub func(string, [][]byte, string) peer.Response + invokeChaincodeMutex sync.RWMutex + invokeChaincodeArgsForCall []struct { + arg1 string + arg2 [][]byte + arg3 string + } + invokeChaincodeReturns struct { + result1 peer.Response + } + invokeChaincodeReturnsOnCall map[int]struct { + result1 peer.Response + } + PutPrivateDataStub func(string, string, []byte) error + putPrivateDataMutex sync.RWMutex + putPrivateDataArgsForCall []struct { + arg1 string + arg2 string + arg3 []byte + } + putPrivateDataReturns struct { + result1 error + } + putPrivateDataReturnsOnCall map[int]struct { + result1 error + } + PutStateStub func(string, []byte) error + putStateMutex sync.RWMutex + putStateArgsForCall []struct { + arg1 string + arg2 []byte + } + putStateReturns struct { + result1 error + } + putStateReturnsOnCall map[int]struct { + result1 error + } + SetEventStub func(string, []byte) error + setEventMutex sync.RWMutex + setEventArgsForCall []struct { + arg1 string + arg2 []byte + } + setEventReturns struct { + result1 error + } + setEventReturnsOnCall map[int]struct { + result1 error + } + SetPrivateDataValidationParameterStub func(string, string, []byte) error + setPrivateDataValidationParameterMutex sync.RWMutex + setPrivateDataValidationParameterArgsForCall []struct { + arg1 string + arg2 string + arg3 []byte + } + setPrivateDataValidationParameterReturns struct { + result1 error + } + setPrivateDataValidationParameterReturnsOnCall map[int]struct { + result1 error + } + SetStateValidationParameterStub func(string, []byte) error + setStateValidationParameterMutex sync.RWMutex + setStateValidationParameterArgsForCall []struct { + arg1 string + arg2 []byte + } + setStateValidationParameterReturns struct { + result1 error + } + setStateValidationParameterReturnsOnCall map[int]struct { + result1 error + } + SplitCompositeKeyStub func(string) (string, []string, error) + splitCompositeKeyMutex sync.RWMutex + splitCompositeKeyArgsForCall []struct { + arg1 string + } + splitCompositeKeyReturns struct { + result1 string + result2 []string + result3 error + } + splitCompositeKeyReturnsOnCall map[int]struct { + result1 string + result2 []string + result3 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *ChaincodeStub) CreateCompositeKey(arg1 string, arg2 []string) (string, error) { + var arg2Copy []string + if arg2 != nil { + arg2Copy = make([]string, len(arg2)) + copy(arg2Copy, arg2) + } + fake.createCompositeKeyMutex.Lock() + ret, specificReturn := fake.createCompositeKeyReturnsOnCall[len(fake.createCompositeKeyArgsForCall)] + fake.createCompositeKeyArgsForCall = append(fake.createCompositeKeyArgsForCall, struct { + arg1 string + arg2 []string + }{arg1, arg2Copy}) + fake.recordInvocation("CreateCompositeKey", []interface{}{arg1, arg2Copy}) + fake.createCompositeKeyMutex.Unlock() + if fake.CreateCompositeKeyStub != nil { + return fake.CreateCompositeKeyStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.createCompositeKeyReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) CreateCompositeKeyCallCount() int { + fake.createCompositeKeyMutex.RLock() + defer fake.createCompositeKeyMutex.RUnlock() + return len(fake.createCompositeKeyArgsForCall) +} + +func (fake *ChaincodeStub) CreateCompositeKeyCalls(stub func(string, []string) (string, error)) { + fake.createCompositeKeyMutex.Lock() + defer fake.createCompositeKeyMutex.Unlock() + fake.CreateCompositeKeyStub = stub +} + +func (fake *ChaincodeStub) CreateCompositeKeyArgsForCall(i int) (string, []string) { + fake.createCompositeKeyMutex.RLock() + defer fake.createCompositeKeyMutex.RUnlock() + argsForCall := fake.createCompositeKeyArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) CreateCompositeKeyReturns(result1 string, result2 error) { + fake.createCompositeKeyMutex.Lock() + defer fake.createCompositeKeyMutex.Unlock() + fake.CreateCompositeKeyStub = nil + fake.createCompositeKeyReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) CreateCompositeKeyReturnsOnCall(i int, result1 string, result2 error) { + fake.createCompositeKeyMutex.Lock() + defer fake.createCompositeKeyMutex.Unlock() + fake.CreateCompositeKeyStub = nil + if fake.createCompositeKeyReturnsOnCall == nil { + fake.createCompositeKeyReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.createCompositeKeyReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) DelPrivateData(arg1 string, arg2 string) error { + fake.delPrivateDataMutex.Lock() + ret, specificReturn := fake.delPrivateDataReturnsOnCall[len(fake.delPrivateDataArgsForCall)] + fake.delPrivateDataArgsForCall = append(fake.delPrivateDataArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("DelPrivateData", []interface{}{arg1, arg2}) + fake.delPrivateDataMutex.Unlock() + if fake.DelPrivateDataStub != nil { + return fake.DelPrivateDataStub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.delPrivateDataReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) DelPrivateDataCallCount() int { + fake.delPrivateDataMutex.RLock() + defer fake.delPrivateDataMutex.RUnlock() + return len(fake.delPrivateDataArgsForCall) +} + +func (fake *ChaincodeStub) DelPrivateDataCalls(stub func(string, string) error) { + fake.delPrivateDataMutex.Lock() + defer fake.delPrivateDataMutex.Unlock() + fake.DelPrivateDataStub = stub +} + +func (fake *ChaincodeStub) DelPrivateDataArgsForCall(i int) (string, string) { + fake.delPrivateDataMutex.RLock() + defer fake.delPrivateDataMutex.RUnlock() + argsForCall := fake.delPrivateDataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) DelPrivateDataReturns(result1 error) { + fake.delPrivateDataMutex.Lock() + defer fake.delPrivateDataMutex.Unlock() + fake.DelPrivateDataStub = nil + fake.delPrivateDataReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) DelPrivateDataReturnsOnCall(i int, result1 error) { + fake.delPrivateDataMutex.Lock() + defer fake.delPrivateDataMutex.Unlock() + fake.DelPrivateDataStub = nil + if fake.delPrivateDataReturnsOnCall == nil { + fake.delPrivateDataReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.delPrivateDataReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) DelState(arg1 string) error { + fake.delStateMutex.Lock() + ret, specificReturn := fake.delStateReturnsOnCall[len(fake.delStateArgsForCall)] + fake.delStateArgsForCall = append(fake.delStateArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("DelState", []interface{}{arg1}) + fake.delStateMutex.Unlock() + if fake.DelStateStub != nil { + return fake.DelStateStub(arg1) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.delStateReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) DelStateCallCount() int { + fake.delStateMutex.RLock() + defer fake.delStateMutex.RUnlock() + return len(fake.delStateArgsForCall) +} + +func (fake *ChaincodeStub) DelStateCalls(stub func(string) error) { + fake.delStateMutex.Lock() + defer fake.delStateMutex.Unlock() + fake.DelStateStub = stub +} + +func (fake *ChaincodeStub) DelStateArgsForCall(i int) string { + fake.delStateMutex.RLock() + defer fake.delStateMutex.RUnlock() + argsForCall := fake.delStateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) DelStateReturns(result1 error) { + fake.delStateMutex.Lock() + defer fake.delStateMutex.Unlock() + fake.DelStateStub = nil + fake.delStateReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) DelStateReturnsOnCall(i int, result1 error) { + fake.delStateMutex.Lock() + defer fake.delStateMutex.Unlock() + fake.DelStateStub = nil + if fake.delStateReturnsOnCall == nil { + fake.delStateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.delStateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) GetArgs() [][]byte { + fake.getArgsMutex.Lock() + ret, specificReturn := fake.getArgsReturnsOnCall[len(fake.getArgsArgsForCall)] + fake.getArgsArgsForCall = append(fake.getArgsArgsForCall, struct { + }{}) + fake.recordInvocation("GetArgs", []interface{}{}) + fake.getArgsMutex.Unlock() + if fake.GetArgsStub != nil { + return fake.GetArgsStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getArgsReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) GetArgsCallCount() int { + fake.getArgsMutex.RLock() + defer fake.getArgsMutex.RUnlock() + return len(fake.getArgsArgsForCall) +} + +func (fake *ChaincodeStub) GetArgsCalls(stub func() [][]byte) { + fake.getArgsMutex.Lock() + defer fake.getArgsMutex.Unlock() + fake.GetArgsStub = stub +} + +func (fake *ChaincodeStub) GetArgsReturns(result1 [][]byte) { + fake.getArgsMutex.Lock() + defer fake.getArgsMutex.Unlock() + fake.GetArgsStub = nil + fake.getArgsReturns = struct { + result1 [][]byte + }{result1} +} + +func (fake *ChaincodeStub) GetArgsReturnsOnCall(i int, result1 [][]byte) { + fake.getArgsMutex.Lock() + defer fake.getArgsMutex.Unlock() + fake.GetArgsStub = nil + if fake.getArgsReturnsOnCall == nil { + fake.getArgsReturnsOnCall = make(map[int]struct { + result1 [][]byte + }) + } + fake.getArgsReturnsOnCall[i] = struct { + result1 [][]byte + }{result1} +} + +func (fake *ChaincodeStub) GetArgsSlice() ([]byte, error) { + fake.getArgsSliceMutex.Lock() + ret, specificReturn := fake.getArgsSliceReturnsOnCall[len(fake.getArgsSliceArgsForCall)] + fake.getArgsSliceArgsForCall = append(fake.getArgsSliceArgsForCall, struct { + }{}) + fake.recordInvocation("GetArgsSlice", []interface{}{}) + fake.getArgsSliceMutex.Unlock() + if fake.GetArgsSliceStub != nil { + return fake.GetArgsSliceStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getArgsSliceReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetArgsSliceCallCount() int { + fake.getArgsSliceMutex.RLock() + defer fake.getArgsSliceMutex.RUnlock() + return len(fake.getArgsSliceArgsForCall) +} + +func (fake *ChaincodeStub) GetArgsSliceCalls(stub func() ([]byte, error)) { + fake.getArgsSliceMutex.Lock() + defer fake.getArgsSliceMutex.Unlock() + fake.GetArgsSliceStub = stub +} + +func (fake *ChaincodeStub) GetArgsSliceReturns(result1 []byte, result2 error) { + fake.getArgsSliceMutex.Lock() + defer fake.getArgsSliceMutex.Unlock() + fake.GetArgsSliceStub = nil + fake.getArgsSliceReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetArgsSliceReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getArgsSliceMutex.Lock() + defer fake.getArgsSliceMutex.Unlock() + fake.GetArgsSliceStub = nil + if fake.getArgsSliceReturnsOnCall == nil { + fake.getArgsSliceReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getArgsSliceReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetBinding() ([]byte, error) { + fake.getBindingMutex.Lock() + ret, specificReturn := fake.getBindingReturnsOnCall[len(fake.getBindingArgsForCall)] + fake.getBindingArgsForCall = append(fake.getBindingArgsForCall, struct { + }{}) + fake.recordInvocation("GetBinding", []interface{}{}) + fake.getBindingMutex.Unlock() + if fake.GetBindingStub != nil { + return fake.GetBindingStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getBindingReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetBindingCallCount() int { + fake.getBindingMutex.RLock() + defer fake.getBindingMutex.RUnlock() + return len(fake.getBindingArgsForCall) +} + +func (fake *ChaincodeStub) GetBindingCalls(stub func() ([]byte, error)) { + fake.getBindingMutex.Lock() + defer fake.getBindingMutex.Unlock() + fake.GetBindingStub = stub +} + +func (fake *ChaincodeStub) GetBindingReturns(result1 []byte, result2 error) { + fake.getBindingMutex.Lock() + defer fake.getBindingMutex.Unlock() + fake.GetBindingStub = nil + fake.getBindingReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetBindingReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getBindingMutex.Lock() + defer fake.getBindingMutex.Unlock() + fake.GetBindingStub = nil + if fake.getBindingReturnsOnCall == nil { + fake.getBindingReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getBindingReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetChannelID() string { + fake.getChannelIDMutex.Lock() + ret, specificReturn := fake.getChannelIDReturnsOnCall[len(fake.getChannelIDArgsForCall)] + fake.getChannelIDArgsForCall = append(fake.getChannelIDArgsForCall, struct { + }{}) + fake.recordInvocation("GetChannelID", []interface{}{}) + fake.getChannelIDMutex.Unlock() + if fake.GetChannelIDStub != nil { + return fake.GetChannelIDStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getChannelIDReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) GetChannelIDCallCount() int { + fake.getChannelIDMutex.RLock() + defer fake.getChannelIDMutex.RUnlock() + return len(fake.getChannelIDArgsForCall) +} + +func (fake *ChaincodeStub) GetChannelIDCalls(stub func() string) { + fake.getChannelIDMutex.Lock() + defer fake.getChannelIDMutex.Unlock() + fake.GetChannelIDStub = stub +} + +func (fake *ChaincodeStub) GetChannelIDReturns(result1 string) { + fake.getChannelIDMutex.Lock() + defer fake.getChannelIDMutex.Unlock() + fake.GetChannelIDStub = nil + fake.getChannelIDReturns = struct { + result1 string + }{result1} +} + +func (fake *ChaincodeStub) GetChannelIDReturnsOnCall(i int, result1 string) { + fake.getChannelIDMutex.Lock() + defer fake.getChannelIDMutex.Unlock() + fake.GetChannelIDStub = nil + if fake.getChannelIDReturnsOnCall == nil { + fake.getChannelIDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.getChannelIDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *ChaincodeStub) GetCreator() ([]byte, error) { + fake.getCreatorMutex.Lock() + ret, specificReturn := fake.getCreatorReturnsOnCall[len(fake.getCreatorArgsForCall)] + fake.getCreatorArgsForCall = append(fake.getCreatorArgsForCall, struct { + }{}) + fake.recordInvocation("GetCreator", []interface{}{}) + fake.getCreatorMutex.Unlock() + if fake.GetCreatorStub != nil { + return fake.GetCreatorStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getCreatorReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetCreatorCallCount() int { + fake.getCreatorMutex.RLock() + defer fake.getCreatorMutex.RUnlock() + return len(fake.getCreatorArgsForCall) +} + +func (fake *ChaincodeStub) GetCreatorCalls(stub func() ([]byte, error)) { + fake.getCreatorMutex.Lock() + defer fake.getCreatorMutex.Unlock() + fake.GetCreatorStub = stub +} + +func (fake *ChaincodeStub) GetCreatorReturns(result1 []byte, result2 error) { + fake.getCreatorMutex.Lock() + defer fake.getCreatorMutex.Unlock() + fake.GetCreatorStub = nil + fake.getCreatorReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetCreatorReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getCreatorMutex.Lock() + defer fake.getCreatorMutex.Unlock() + fake.GetCreatorStub = nil + if fake.getCreatorReturnsOnCall == nil { + fake.getCreatorReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getCreatorReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetDecorations() map[string][]byte { + fake.getDecorationsMutex.Lock() + ret, specificReturn := fake.getDecorationsReturnsOnCall[len(fake.getDecorationsArgsForCall)] + fake.getDecorationsArgsForCall = append(fake.getDecorationsArgsForCall, struct { + }{}) + fake.recordInvocation("GetDecorations", []interface{}{}) + fake.getDecorationsMutex.Unlock() + if fake.GetDecorationsStub != nil { + return fake.GetDecorationsStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getDecorationsReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) GetDecorationsCallCount() int { + fake.getDecorationsMutex.RLock() + defer fake.getDecorationsMutex.RUnlock() + return len(fake.getDecorationsArgsForCall) +} + +func (fake *ChaincodeStub) GetDecorationsCalls(stub func() map[string][]byte) { + fake.getDecorationsMutex.Lock() + defer fake.getDecorationsMutex.Unlock() + fake.GetDecorationsStub = stub +} + +func (fake *ChaincodeStub) GetDecorationsReturns(result1 map[string][]byte) { + fake.getDecorationsMutex.Lock() + defer fake.getDecorationsMutex.Unlock() + fake.GetDecorationsStub = nil + fake.getDecorationsReturns = struct { + result1 map[string][]byte + }{result1} +} + +func (fake *ChaincodeStub) GetDecorationsReturnsOnCall(i int, result1 map[string][]byte) { + fake.getDecorationsMutex.Lock() + defer fake.getDecorationsMutex.Unlock() + fake.GetDecorationsStub = nil + if fake.getDecorationsReturnsOnCall == nil { + fake.getDecorationsReturnsOnCall = make(map[int]struct { + result1 map[string][]byte + }) + } + fake.getDecorationsReturnsOnCall[i] = struct { + result1 map[string][]byte + }{result1} +} + +func (fake *ChaincodeStub) GetFunctionAndParameters() (string, []string) { + fake.getFunctionAndParametersMutex.Lock() + ret, specificReturn := fake.getFunctionAndParametersReturnsOnCall[len(fake.getFunctionAndParametersArgsForCall)] + fake.getFunctionAndParametersArgsForCall = append(fake.getFunctionAndParametersArgsForCall, struct { + }{}) + fake.recordInvocation("GetFunctionAndParameters", []interface{}{}) + fake.getFunctionAndParametersMutex.Unlock() + if fake.GetFunctionAndParametersStub != nil { + return fake.GetFunctionAndParametersStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getFunctionAndParametersReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetFunctionAndParametersCallCount() int { + fake.getFunctionAndParametersMutex.RLock() + defer fake.getFunctionAndParametersMutex.RUnlock() + return len(fake.getFunctionAndParametersArgsForCall) +} + +func (fake *ChaincodeStub) GetFunctionAndParametersCalls(stub func() (string, []string)) { + fake.getFunctionAndParametersMutex.Lock() + defer fake.getFunctionAndParametersMutex.Unlock() + fake.GetFunctionAndParametersStub = stub +} + +func (fake *ChaincodeStub) GetFunctionAndParametersReturns(result1 string, result2 []string) { + fake.getFunctionAndParametersMutex.Lock() + defer fake.getFunctionAndParametersMutex.Unlock() + fake.GetFunctionAndParametersStub = nil + fake.getFunctionAndParametersReturns = struct { + result1 string + result2 []string + }{result1, result2} +} + +func (fake *ChaincodeStub) GetFunctionAndParametersReturnsOnCall(i int, result1 string, result2 []string) { + fake.getFunctionAndParametersMutex.Lock() + defer fake.getFunctionAndParametersMutex.Unlock() + fake.GetFunctionAndParametersStub = nil + if fake.getFunctionAndParametersReturnsOnCall == nil { + fake.getFunctionAndParametersReturnsOnCall = make(map[int]struct { + result1 string + result2 []string + }) + } + fake.getFunctionAndParametersReturnsOnCall[i] = struct { + result1 string + result2 []string + }{result1, result2} +} + +func (fake *ChaincodeStub) GetHistoryForKey(arg1 string) (shim.HistoryQueryIteratorInterface, error) { + fake.getHistoryForKeyMutex.Lock() + ret, specificReturn := fake.getHistoryForKeyReturnsOnCall[len(fake.getHistoryForKeyArgsForCall)] + fake.getHistoryForKeyArgsForCall = append(fake.getHistoryForKeyArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("GetHistoryForKey", []interface{}{arg1}) + fake.getHistoryForKeyMutex.Unlock() + if fake.GetHistoryForKeyStub != nil { + return fake.GetHistoryForKeyStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getHistoryForKeyReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetHistoryForKeyCallCount() int { + fake.getHistoryForKeyMutex.RLock() + defer fake.getHistoryForKeyMutex.RUnlock() + return len(fake.getHistoryForKeyArgsForCall) +} + +func (fake *ChaincodeStub) GetHistoryForKeyCalls(stub func(string) (shim.HistoryQueryIteratorInterface, error)) { + fake.getHistoryForKeyMutex.Lock() + defer fake.getHistoryForKeyMutex.Unlock() + fake.GetHistoryForKeyStub = stub +} + +func (fake *ChaincodeStub) GetHistoryForKeyArgsForCall(i int) string { + fake.getHistoryForKeyMutex.RLock() + defer fake.getHistoryForKeyMutex.RUnlock() + argsForCall := fake.getHistoryForKeyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) GetHistoryForKeyReturns(result1 shim.HistoryQueryIteratorInterface, result2 error) { + fake.getHistoryForKeyMutex.Lock() + defer fake.getHistoryForKeyMutex.Unlock() + fake.GetHistoryForKeyStub = nil + fake.getHistoryForKeyReturns = struct { + result1 shim.HistoryQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetHistoryForKeyReturnsOnCall(i int, result1 shim.HistoryQueryIteratorInterface, result2 error) { + fake.getHistoryForKeyMutex.Lock() + defer fake.getHistoryForKeyMutex.Unlock() + fake.GetHistoryForKeyStub = nil + if fake.getHistoryForKeyReturnsOnCall == nil { + fake.getHistoryForKeyReturnsOnCall = make(map[int]struct { + result1 shim.HistoryQueryIteratorInterface + result2 error + }) + } + fake.getHistoryForKeyReturnsOnCall[i] = struct { + result1 shim.HistoryQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateData(arg1 string, arg2 string) ([]byte, error) { + fake.getPrivateDataMutex.Lock() + ret, specificReturn := fake.getPrivateDataReturnsOnCall[len(fake.getPrivateDataArgsForCall)] + fake.getPrivateDataArgsForCall = append(fake.getPrivateDataArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetPrivateData", []interface{}{arg1, arg2}) + fake.getPrivateDataMutex.Unlock() + if fake.GetPrivateDataStub != nil { + return fake.GetPrivateDataStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataCallCount() int { + fake.getPrivateDataMutex.RLock() + defer fake.getPrivateDataMutex.RUnlock() + return len(fake.getPrivateDataArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataCalls(stub func(string, string) ([]byte, error)) { + fake.getPrivateDataMutex.Lock() + defer fake.getPrivateDataMutex.Unlock() + fake.GetPrivateDataStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataArgsForCall(i int) (string, string) { + fake.getPrivateDataMutex.RLock() + defer fake.getPrivateDataMutex.RUnlock() + argsForCall := fake.getPrivateDataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetPrivateDataReturns(result1 []byte, result2 error) { + fake.getPrivateDataMutex.Lock() + defer fake.getPrivateDataMutex.Unlock() + fake.GetPrivateDataStub = nil + fake.getPrivateDataReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getPrivateDataMutex.Lock() + defer fake.getPrivateDataMutex.Unlock() + fake.GetPrivateDataStub = nil + if fake.getPrivateDataReturnsOnCall == nil { + fake.getPrivateDataReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getPrivateDataReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKey(arg1 string, arg2 string, arg3 []string) (shim.StateQueryIteratorInterface, error) { + var arg3Copy []string + if arg3 != nil { + arg3Copy = make([]string, len(arg3)) + copy(arg3Copy, arg3) + } + fake.getPrivateDataByPartialCompositeKeyMutex.Lock() + ret, specificReturn := fake.getPrivateDataByPartialCompositeKeyReturnsOnCall[len(fake.getPrivateDataByPartialCompositeKeyArgsForCall)] + fake.getPrivateDataByPartialCompositeKeyArgsForCall = append(fake.getPrivateDataByPartialCompositeKeyArgsForCall, struct { + arg1 string + arg2 string + arg3 []string + }{arg1, arg2, arg3Copy}) + fake.recordInvocation("GetPrivateDataByPartialCompositeKey", []interface{}{arg1, arg2, arg3Copy}) + fake.getPrivateDataByPartialCompositeKeyMutex.Unlock() + if fake.GetPrivateDataByPartialCompositeKeyStub != nil { + return fake.GetPrivateDataByPartialCompositeKeyStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataByPartialCompositeKeyReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKeyCallCount() int { + fake.getPrivateDataByPartialCompositeKeyMutex.RLock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.RUnlock() + return len(fake.getPrivateDataByPartialCompositeKeyArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKeyCalls(stub func(string, string, []string) (shim.StateQueryIteratorInterface, error)) { + fake.getPrivateDataByPartialCompositeKeyMutex.Lock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.Unlock() + fake.GetPrivateDataByPartialCompositeKeyStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKeyArgsForCall(i int) (string, string, []string) { + fake.getPrivateDataByPartialCompositeKeyMutex.RLock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.RUnlock() + argsForCall := fake.getPrivateDataByPartialCompositeKeyArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKeyReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataByPartialCompositeKeyMutex.Lock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.Unlock() + fake.GetPrivateDataByPartialCompositeKeyStub = nil + fake.getPrivateDataByPartialCompositeKeyReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKeyReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataByPartialCompositeKeyMutex.Lock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.Unlock() + fake.GetPrivateDataByPartialCompositeKeyStub = nil + if fake.getPrivateDataByPartialCompositeKeyReturnsOnCall == nil { + fake.getPrivateDataByPartialCompositeKeyReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getPrivateDataByPartialCompositeKeyReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataByRange(arg1 string, arg2 string, arg3 string) (shim.StateQueryIteratorInterface, error) { + fake.getPrivateDataByRangeMutex.Lock() + ret, specificReturn := fake.getPrivateDataByRangeReturnsOnCall[len(fake.getPrivateDataByRangeArgsForCall)] + fake.getPrivateDataByRangeArgsForCall = append(fake.getPrivateDataByRangeArgsForCall, struct { + arg1 string + arg2 string + arg3 string + }{arg1, arg2, arg3}) + fake.recordInvocation("GetPrivateDataByRange", []interface{}{arg1, arg2, arg3}) + fake.getPrivateDataByRangeMutex.Unlock() + if fake.GetPrivateDataByRangeStub != nil { + return fake.GetPrivateDataByRangeStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataByRangeReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataByRangeCallCount() int { + fake.getPrivateDataByRangeMutex.RLock() + defer fake.getPrivateDataByRangeMutex.RUnlock() + return len(fake.getPrivateDataByRangeArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataByRangeCalls(stub func(string, string, string) (shim.StateQueryIteratorInterface, error)) { + fake.getPrivateDataByRangeMutex.Lock() + defer fake.getPrivateDataByRangeMutex.Unlock() + fake.GetPrivateDataByRangeStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataByRangeArgsForCall(i int) (string, string, string) { + fake.getPrivateDataByRangeMutex.RLock() + defer fake.getPrivateDataByRangeMutex.RUnlock() + argsForCall := fake.getPrivateDataByRangeArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) GetPrivateDataByRangeReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataByRangeMutex.Lock() + defer fake.getPrivateDataByRangeMutex.Unlock() + fake.GetPrivateDataByRangeStub = nil + fake.getPrivateDataByRangeReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataByRangeReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataByRangeMutex.Lock() + defer fake.getPrivateDataByRangeMutex.Unlock() + fake.GetPrivateDataByRangeStub = nil + if fake.getPrivateDataByRangeReturnsOnCall == nil { + fake.getPrivateDataByRangeReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getPrivateDataByRangeReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataHash(arg1 string, arg2 string) ([]byte, error) { + fake.getPrivateDataHashMutex.Lock() + ret, specificReturn := fake.getPrivateDataHashReturnsOnCall[len(fake.getPrivateDataHashArgsForCall)] + fake.getPrivateDataHashArgsForCall = append(fake.getPrivateDataHashArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetPrivateDataHash", []interface{}{arg1, arg2}) + fake.getPrivateDataHashMutex.Unlock() + if fake.GetPrivateDataHashStub != nil { + return fake.GetPrivateDataHashStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataHashReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataHashCallCount() int { + fake.getPrivateDataHashMutex.RLock() + defer fake.getPrivateDataHashMutex.RUnlock() + return len(fake.getPrivateDataHashArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataHashCalls(stub func(string, string) ([]byte, error)) { + fake.getPrivateDataHashMutex.Lock() + defer fake.getPrivateDataHashMutex.Unlock() + fake.GetPrivateDataHashStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataHashArgsForCall(i int) (string, string) { + fake.getPrivateDataHashMutex.RLock() + defer fake.getPrivateDataHashMutex.RUnlock() + argsForCall := fake.getPrivateDataHashArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetPrivateDataHashReturns(result1 []byte, result2 error) { + fake.getPrivateDataHashMutex.Lock() + defer fake.getPrivateDataHashMutex.Unlock() + fake.GetPrivateDataHashStub = nil + fake.getPrivateDataHashReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataHashReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getPrivateDataHashMutex.Lock() + defer fake.getPrivateDataHashMutex.Unlock() + fake.GetPrivateDataHashStub = nil + if fake.getPrivateDataHashReturnsOnCall == nil { + fake.getPrivateDataHashReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getPrivateDataHashReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResult(arg1 string, arg2 string) (shim.StateQueryIteratorInterface, error) { + fake.getPrivateDataQueryResultMutex.Lock() + ret, specificReturn := fake.getPrivateDataQueryResultReturnsOnCall[len(fake.getPrivateDataQueryResultArgsForCall)] + fake.getPrivateDataQueryResultArgsForCall = append(fake.getPrivateDataQueryResultArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetPrivateDataQueryResult", []interface{}{arg1, arg2}) + fake.getPrivateDataQueryResultMutex.Unlock() + if fake.GetPrivateDataQueryResultStub != nil { + return fake.GetPrivateDataQueryResultStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataQueryResultReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResultCallCount() int { + fake.getPrivateDataQueryResultMutex.RLock() + defer fake.getPrivateDataQueryResultMutex.RUnlock() + return len(fake.getPrivateDataQueryResultArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResultCalls(stub func(string, string) (shim.StateQueryIteratorInterface, error)) { + fake.getPrivateDataQueryResultMutex.Lock() + defer fake.getPrivateDataQueryResultMutex.Unlock() + fake.GetPrivateDataQueryResultStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResultArgsForCall(i int) (string, string) { + fake.getPrivateDataQueryResultMutex.RLock() + defer fake.getPrivateDataQueryResultMutex.RUnlock() + argsForCall := fake.getPrivateDataQueryResultArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResultReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataQueryResultMutex.Lock() + defer fake.getPrivateDataQueryResultMutex.Unlock() + fake.GetPrivateDataQueryResultStub = nil + fake.getPrivateDataQueryResultReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResultReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataQueryResultMutex.Lock() + defer fake.getPrivateDataQueryResultMutex.Unlock() + fake.GetPrivateDataQueryResultStub = nil + if fake.getPrivateDataQueryResultReturnsOnCall == nil { + fake.getPrivateDataQueryResultReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getPrivateDataQueryResultReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameter(arg1 string, arg2 string) ([]byte, error) { + fake.getPrivateDataValidationParameterMutex.Lock() + ret, specificReturn := fake.getPrivateDataValidationParameterReturnsOnCall[len(fake.getPrivateDataValidationParameterArgsForCall)] + fake.getPrivateDataValidationParameterArgsForCall = append(fake.getPrivateDataValidationParameterArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetPrivateDataValidationParameter", []interface{}{arg1, arg2}) + fake.getPrivateDataValidationParameterMutex.Unlock() + if fake.GetPrivateDataValidationParameterStub != nil { + return fake.GetPrivateDataValidationParameterStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataValidationParameterReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameterCallCount() int { + fake.getPrivateDataValidationParameterMutex.RLock() + defer fake.getPrivateDataValidationParameterMutex.RUnlock() + return len(fake.getPrivateDataValidationParameterArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameterCalls(stub func(string, string) ([]byte, error)) { + fake.getPrivateDataValidationParameterMutex.Lock() + defer fake.getPrivateDataValidationParameterMutex.Unlock() + fake.GetPrivateDataValidationParameterStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameterArgsForCall(i int) (string, string) { + fake.getPrivateDataValidationParameterMutex.RLock() + defer fake.getPrivateDataValidationParameterMutex.RUnlock() + argsForCall := fake.getPrivateDataValidationParameterArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameterReturns(result1 []byte, result2 error) { + fake.getPrivateDataValidationParameterMutex.Lock() + defer fake.getPrivateDataValidationParameterMutex.Unlock() + fake.GetPrivateDataValidationParameterStub = nil + fake.getPrivateDataValidationParameterReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameterReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getPrivateDataValidationParameterMutex.Lock() + defer fake.getPrivateDataValidationParameterMutex.Unlock() + fake.GetPrivateDataValidationParameterStub = nil + if fake.getPrivateDataValidationParameterReturnsOnCall == nil { + fake.getPrivateDataValidationParameterReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getPrivateDataValidationParameterReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetQueryResult(arg1 string) (shim.StateQueryIteratorInterface, error) { + fake.getQueryResultMutex.Lock() + ret, specificReturn := fake.getQueryResultReturnsOnCall[len(fake.getQueryResultArgsForCall)] + fake.getQueryResultArgsForCall = append(fake.getQueryResultArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("GetQueryResult", []interface{}{arg1}) + fake.getQueryResultMutex.Unlock() + if fake.GetQueryResultStub != nil { + return fake.GetQueryResultStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getQueryResultReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetQueryResultCallCount() int { + fake.getQueryResultMutex.RLock() + defer fake.getQueryResultMutex.RUnlock() + return len(fake.getQueryResultArgsForCall) +} + +func (fake *ChaincodeStub) GetQueryResultCalls(stub func(string) (shim.StateQueryIteratorInterface, error)) { + fake.getQueryResultMutex.Lock() + defer fake.getQueryResultMutex.Unlock() + fake.GetQueryResultStub = stub +} + +func (fake *ChaincodeStub) GetQueryResultArgsForCall(i int) string { + fake.getQueryResultMutex.RLock() + defer fake.getQueryResultMutex.RUnlock() + argsForCall := fake.getQueryResultArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) GetQueryResultReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getQueryResultMutex.Lock() + defer fake.getQueryResultMutex.Unlock() + fake.GetQueryResultStub = nil + fake.getQueryResultReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetQueryResultReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getQueryResultMutex.Lock() + defer fake.getQueryResultMutex.Unlock() + fake.GetQueryResultStub = nil + if fake.getQueryResultReturnsOnCall == nil { + fake.getQueryResultReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getQueryResultReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetQueryResultWithPagination(arg1 string, arg2 int32, arg3 string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) { + fake.getQueryResultWithPaginationMutex.Lock() + ret, specificReturn := fake.getQueryResultWithPaginationReturnsOnCall[len(fake.getQueryResultWithPaginationArgsForCall)] + fake.getQueryResultWithPaginationArgsForCall = append(fake.getQueryResultWithPaginationArgsForCall, struct { + arg1 string + arg2 int32 + arg3 string + }{arg1, arg2, arg3}) + fake.recordInvocation("GetQueryResultWithPagination", []interface{}{arg1, arg2, arg3}) + fake.getQueryResultWithPaginationMutex.Unlock() + if fake.GetQueryResultWithPaginationStub != nil { + return fake.GetQueryResultWithPaginationStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + fakeReturns := fake.getQueryResultWithPaginationReturns + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *ChaincodeStub) GetQueryResultWithPaginationCallCount() int { + fake.getQueryResultWithPaginationMutex.RLock() + defer fake.getQueryResultWithPaginationMutex.RUnlock() + return len(fake.getQueryResultWithPaginationArgsForCall) +} + +func (fake *ChaincodeStub) GetQueryResultWithPaginationCalls(stub func(string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error)) { + fake.getQueryResultWithPaginationMutex.Lock() + defer fake.getQueryResultWithPaginationMutex.Unlock() + fake.GetQueryResultWithPaginationStub = stub +} + +func (fake *ChaincodeStub) GetQueryResultWithPaginationArgsForCall(i int) (string, int32, string) { + fake.getQueryResultWithPaginationMutex.RLock() + defer fake.getQueryResultWithPaginationMutex.RUnlock() + argsForCall := fake.getQueryResultWithPaginationArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) GetQueryResultWithPaginationReturns(result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getQueryResultWithPaginationMutex.Lock() + defer fake.getQueryResultWithPaginationMutex.Unlock() + fake.GetQueryResultWithPaginationStub = nil + fake.getQueryResultWithPaginationReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetQueryResultWithPaginationReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getQueryResultWithPaginationMutex.Lock() + defer fake.getQueryResultWithPaginationMutex.Unlock() + fake.GetQueryResultWithPaginationStub = nil + if fake.getQueryResultWithPaginationReturnsOnCall == nil { + fake.getQueryResultWithPaginationReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }) + } + fake.getQueryResultWithPaginationReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetSignedProposal() (*peer.SignedProposal, error) { + fake.getSignedProposalMutex.Lock() + ret, specificReturn := fake.getSignedProposalReturnsOnCall[len(fake.getSignedProposalArgsForCall)] + fake.getSignedProposalArgsForCall = append(fake.getSignedProposalArgsForCall, struct { + }{}) + fake.recordInvocation("GetSignedProposal", []interface{}{}) + fake.getSignedProposalMutex.Unlock() + if fake.GetSignedProposalStub != nil { + return fake.GetSignedProposalStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getSignedProposalReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetSignedProposalCallCount() int { + fake.getSignedProposalMutex.RLock() + defer fake.getSignedProposalMutex.RUnlock() + return len(fake.getSignedProposalArgsForCall) +} + +func (fake *ChaincodeStub) GetSignedProposalCalls(stub func() (*peer.SignedProposal, error)) { + fake.getSignedProposalMutex.Lock() + defer fake.getSignedProposalMutex.Unlock() + fake.GetSignedProposalStub = stub +} + +func (fake *ChaincodeStub) GetSignedProposalReturns(result1 *peer.SignedProposal, result2 error) { + fake.getSignedProposalMutex.Lock() + defer fake.getSignedProposalMutex.Unlock() + fake.GetSignedProposalStub = nil + fake.getSignedProposalReturns = struct { + result1 *peer.SignedProposal + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetSignedProposalReturnsOnCall(i int, result1 *peer.SignedProposal, result2 error) { + fake.getSignedProposalMutex.Lock() + defer fake.getSignedProposalMutex.Unlock() + fake.GetSignedProposalStub = nil + if fake.getSignedProposalReturnsOnCall == nil { + fake.getSignedProposalReturnsOnCall = make(map[int]struct { + result1 *peer.SignedProposal + result2 error + }) + } + fake.getSignedProposalReturnsOnCall[i] = struct { + result1 *peer.SignedProposal + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetState(arg1 string) ([]byte, error) { + fake.getStateMutex.Lock() + ret, specificReturn := fake.getStateReturnsOnCall[len(fake.getStateArgsForCall)] + fake.getStateArgsForCall = append(fake.getStateArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("GetState", []interface{}{arg1}) + fake.getStateMutex.Unlock() + if fake.GetStateStub != nil { + return fake.GetStateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetStateCallCount() int { + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + return len(fake.getStateArgsForCall) +} + +func (fake *ChaincodeStub) GetStateCalls(stub func(string) ([]byte, error)) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = stub +} + +func (fake *ChaincodeStub) GetStateArgsForCall(i int) string { + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + argsForCall := fake.getStateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) GetStateReturns(result1 []byte, result2 error) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = nil + fake.getStateReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = nil + if fake.getStateReturnsOnCall == nil { + fake.getStateReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getStateReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKey(arg1 string, arg2 []string) (shim.StateQueryIteratorInterface, error) { + var arg2Copy []string + if arg2 != nil { + arg2Copy = make([]string, len(arg2)) + copy(arg2Copy, arg2) + } + fake.getStateByPartialCompositeKeyMutex.Lock() + ret, specificReturn := fake.getStateByPartialCompositeKeyReturnsOnCall[len(fake.getStateByPartialCompositeKeyArgsForCall)] + fake.getStateByPartialCompositeKeyArgsForCall = append(fake.getStateByPartialCompositeKeyArgsForCall, struct { + arg1 string + arg2 []string + }{arg1, arg2Copy}) + fake.recordInvocation("GetStateByPartialCompositeKey", []interface{}{arg1, arg2Copy}) + fake.getStateByPartialCompositeKeyMutex.Unlock() + if fake.GetStateByPartialCompositeKeyStub != nil { + return fake.GetStateByPartialCompositeKeyStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateByPartialCompositeKeyReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyCallCount() int { + fake.getStateByPartialCompositeKeyMutex.RLock() + defer fake.getStateByPartialCompositeKeyMutex.RUnlock() + return len(fake.getStateByPartialCompositeKeyArgsForCall) +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyCalls(stub func(string, []string) (shim.StateQueryIteratorInterface, error)) { + fake.getStateByPartialCompositeKeyMutex.Lock() + defer fake.getStateByPartialCompositeKeyMutex.Unlock() + fake.GetStateByPartialCompositeKeyStub = stub +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyArgsForCall(i int) (string, []string) { + fake.getStateByPartialCompositeKeyMutex.RLock() + defer fake.getStateByPartialCompositeKeyMutex.RUnlock() + argsForCall := fake.getStateByPartialCompositeKeyArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getStateByPartialCompositeKeyMutex.Lock() + defer fake.getStateByPartialCompositeKeyMutex.Unlock() + fake.GetStateByPartialCompositeKeyStub = nil + fake.getStateByPartialCompositeKeyReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getStateByPartialCompositeKeyMutex.Lock() + defer fake.getStateByPartialCompositeKeyMutex.Unlock() + fake.GetStateByPartialCompositeKeyStub = nil + if fake.getStateByPartialCompositeKeyReturnsOnCall == nil { + fake.getStateByPartialCompositeKeyReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getStateByPartialCompositeKeyReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPagination(arg1 string, arg2 []string, arg3 int32, arg4 string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) { + var arg2Copy []string + if arg2 != nil { + arg2Copy = make([]string, len(arg2)) + copy(arg2Copy, arg2) + } + fake.getStateByPartialCompositeKeyWithPaginationMutex.Lock() + ret, specificReturn := fake.getStateByPartialCompositeKeyWithPaginationReturnsOnCall[len(fake.getStateByPartialCompositeKeyWithPaginationArgsForCall)] + fake.getStateByPartialCompositeKeyWithPaginationArgsForCall = append(fake.getStateByPartialCompositeKeyWithPaginationArgsForCall, struct { + arg1 string + arg2 []string + arg3 int32 + arg4 string + }{arg1, arg2Copy, arg3, arg4}) + fake.recordInvocation("GetStateByPartialCompositeKeyWithPagination", []interface{}{arg1, arg2Copy, arg3, arg4}) + fake.getStateByPartialCompositeKeyWithPaginationMutex.Unlock() + if fake.GetStateByPartialCompositeKeyWithPaginationStub != nil { + return fake.GetStateByPartialCompositeKeyWithPaginationStub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + fakeReturns := fake.getStateByPartialCompositeKeyWithPaginationReturns + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPaginationCallCount() int { + fake.getStateByPartialCompositeKeyWithPaginationMutex.RLock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.RUnlock() + return len(fake.getStateByPartialCompositeKeyWithPaginationArgsForCall) +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPaginationCalls(stub func(string, []string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error)) { + fake.getStateByPartialCompositeKeyWithPaginationMutex.Lock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.Unlock() + fake.GetStateByPartialCompositeKeyWithPaginationStub = stub +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPaginationArgsForCall(i int) (string, []string, int32, string) { + fake.getStateByPartialCompositeKeyWithPaginationMutex.RLock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.RUnlock() + argsForCall := fake.getStateByPartialCompositeKeyWithPaginationArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPaginationReturns(result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getStateByPartialCompositeKeyWithPaginationMutex.Lock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.Unlock() + fake.GetStateByPartialCompositeKeyWithPaginationStub = nil + fake.getStateByPartialCompositeKeyWithPaginationReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPaginationReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getStateByPartialCompositeKeyWithPaginationMutex.Lock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.Unlock() + fake.GetStateByPartialCompositeKeyWithPaginationStub = nil + if fake.getStateByPartialCompositeKeyWithPaginationReturnsOnCall == nil { + fake.getStateByPartialCompositeKeyWithPaginationReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }) + } + fake.getStateByPartialCompositeKeyWithPaginationReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetStateByRange(arg1 string, arg2 string) (shim.StateQueryIteratorInterface, error) { + fake.getStateByRangeMutex.Lock() + ret, specificReturn := fake.getStateByRangeReturnsOnCall[len(fake.getStateByRangeArgsForCall)] + fake.getStateByRangeArgsForCall = append(fake.getStateByRangeArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetStateByRange", []interface{}{arg1, arg2}) + fake.getStateByRangeMutex.Unlock() + if fake.GetStateByRangeStub != nil { + return fake.GetStateByRangeStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateByRangeReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetStateByRangeCallCount() int { + fake.getStateByRangeMutex.RLock() + defer fake.getStateByRangeMutex.RUnlock() + return len(fake.getStateByRangeArgsForCall) +} + +func (fake *ChaincodeStub) GetStateByRangeCalls(stub func(string, string) (shim.StateQueryIteratorInterface, error)) { + fake.getStateByRangeMutex.Lock() + defer fake.getStateByRangeMutex.Unlock() + fake.GetStateByRangeStub = stub +} + +func (fake *ChaincodeStub) GetStateByRangeArgsForCall(i int) (string, string) { + fake.getStateByRangeMutex.RLock() + defer fake.getStateByRangeMutex.RUnlock() + argsForCall := fake.getStateByRangeArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetStateByRangeReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getStateByRangeMutex.Lock() + defer fake.getStateByRangeMutex.Unlock() + fake.GetStateByRangeStub = nil + fake.getStateByRangeReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateByRangeReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getStateByRangeMutex.Lock() + defer fake.getStateByRangeMutex.Unlock() + fake.GetStateByRangeStub = nil + if fake.getStateByRangeReturnsOnCall == nil { + fake.getStateByRangeReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getStateByRangeReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateByRangeWithPagination(arg1 string, arg2 string, arg3 int32, arg4 string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) { + fake.getStateByRangeWithPaginationMutex.Lock() + ret, specificReturn := fake.getStateByRangeWithPaginationReturnsOnCall[len(fake.getStateByRangeWithPaginationArgsForCall)] + fake.getStateByRangeWithPaginationArgsForCall = append(fake.getStateByRangeWithPaginationArgsForCall, struct { + arg1 string + arg2 string + arg3 int32 + arg4 string + }{arg1, arg2, arg3, arg4}) + fake.recordInvocation("GetStateByRangeWithPagination", []interface{}{arg1, arg2, arg3, arg4}) + fake.getStateByRangeWithPaginationMutex.Unlock() + if fake.GetStateByRangeWithPaginationStub != nil { + return fake.GetStateByRangeWithPaginationStub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + fakeReturns := fake.getStateByRangeWithPaginationReturns + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *ChaincodeStub) GetStateByRangeWithPaginationCallCount() int { + fake.getStateByRangeWithPaginationMutex.RLock() + defer fake.getStateByRangeWithPaginationMutex.RUnlock() + return len(fake.getStateByRangeWithPaginationArgsForCall) +} + +func (fake *ChaincodeStub) GetStateByRangeWithPaginationCalls(stub func(string, string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error)) { + fake.getStateByRangeWithPaginationMutex.Lock() + defer fake.getStateByRangeWithPaginationMutex.Unlock() + fake.GetStateByRangeWithPaginationStub = stub +} + +func (fake *ChaincodeStub) GetStateByRangeWithPaginationArgsForCall(i int) (string, string, int32, string) { + fake.getStateByRangeWithPaginationMutex.RLock() + defer fake.getStateByRangeWithPaginationMutex.RUnlock() + argsForCall := fake.getStateByRangeWithPaginationArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *ChaincodeStub) GetStateByRangeWithPaginationReturns(result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getStateByRangeWithPaginationMutex.Lock() + defer fake.getStateByRangeWithPaginationMutex.Unlock() + fake.GetStateByRangeWithPaginationStub = nil + fake.getStateByRangeWithPaginationReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetStateByRangeWithPaginationReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getStateByRangeWithPaginationMutex.Lock() + defer fake.getStateByRangeWithPaginationMutex.Unlock() + fake.GetStateByRangeWithPaginationStub = nil + if fake.getStateByRangeWithPaginationReturnsOnCall == nil { + fake.getStateByRangeWithPaginationReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }) + } + fake.getStateByRangeWithPaginationReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetStateValidationParameter(arg1 string) ([]byte, error) { + fake.getStateValidationParameterMutex.Lock() + ret, specificReturn := fake.getStateValidationParameterReturnsOnCall[len(fake.getStateValidationParameterArgsForCall)] + fake.getStateValidationParameterArgsForCall = append(fake.getStateValidationParameterArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("GetStateValidationParameter", []interface{}{arg1}) + fake.getStateValidationParameterMutex.Unlock() + if fake.GetStateValidationParameterStub != nil { + return fake.GetStateValidationParameterStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateValidationParameterReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetStateValidationParameterCallCount() int { + fake.getStateValidationParameterMutex.RLock() + defer fake.getStateValidationParameterMutex.RUnlock() + return len(fake.getStateValidationParameterArgsForCall) +} + +func (fake *ChaincodeStub) GetStateValidationParameterCalls(stub func(string) ([]byte, error)) { + fake.getStateValidationParameterMutex.Lock() + defer fake.getStateValidationParameterMutex.Unlock() + fake.GetStateValidationParameterStub = stub +} + +func (fake *ChaincodeStub) GetStateValidationParameterArgsForCall(i int) string { + fake.getStateValidationParameterMutex.RLock() + defer fake.getStateValidationParameterMutex.RUnlock() + argsForCall := fake.getStateValidationParameterArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) GetStateValidationParameterReturns(result1 []byte, result2 error) { + fake.getStateValidationParameterMutex.Lock() + defer fake.getStateValidationParameterMutex.Unlock() + fake.GetStateValidationParameterStub = nil + fake.getStateValidationParameterReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateValidationParameterReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getStateValidationParameterMutex.Lock() + defer fake.getStateValidationParameterMutex.Unlock() + fake.GetStateValidationParameterStub = nil + if fake.getStateValidationParameterReturnsOnCall == nil { + fake.getStateValidationParameterReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getStateValidationParameterReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStringArgs() []string { + fake.getStringArgsMutex.Lock() + ret, specificReturn := fake.getStringArgsReturnsOnCall[len(fake.getStringArgsArgsForCall)] + fake.getStringArgsArgsForCall = append(fake.getStringArgsArgsForCall, struct { + }{}) + fake.recordInvocation("GetStringArgs", []interface{}{}) + fake.getStringArgsMutex.Unlock() + if fake.GetStringArgsStub != nil { + return fake.GetStringArgsStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getStringArgsReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) GetStringArgsCallCount() int { + fake.getStringArgsMutex.RLock() + defer fake.getStringArgsMutex.RUnlock() + return len(fake.getStringArgsArgsForCall) +} + +func (fake *ChaincodeStub) GetStringArgsCalls(stub func() []string) { + fake.getStringArgsMutex.Lock() + defer fake.getStringArgsMutex.Unlock() + fake.GetStringArgsStub = stub +} + +func (fake *ChaincodeStub) GetStringArgsReturns(result1 []string) { + fake.getStringArgsMutex.Lock() + defer fake.getStringArgsMutex.Unlock() + fake.GetStringArgsStub = nil + fake.getStringArgsReturns = struct { + result1 []string + }{result1} +} + +func (fake *ChaincodeStub) GetStringArgsReturnsOnCall(i int, result1 []string) { + fake.getStringArgsMutex.Lock() + defer fake.getStringArgsMutex.Unlock() + fake.GetStringArgsStub = nil + if fake.getStringArgsReturnsOnCall == nil { + fake.getStringArgsReturnsOnCall = make(map[int]struct { + result1 []string + }) + } + fake.getStringArgsReturnsOnCall[i] = struct { + result1 []string + }{result1} +} + +func (fake *ChaincodeStub) GetTransient() (map[string][]byte, error) { + fake.getTransientMutex.Lock() + ret, specificReturn := fake.getTransientReturnsOnCall[len(fake.getTransientArgsForCall)] + fake.getTransientArgsForCall = append(fake.getTransientArgsForCall, struct { + }{}) + fake.recordInvocation("GetTransient", []interface{}{}) + fake.getTransientMutex.Unlock() + if fake.GetTransientStub != nil { + return fake.GetTransientStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getTransientReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetTransientCallCount() int { + fake.getTransientMutex.RLock() + defer fake.getTransientMutex.RUnlock() + return len(fake.getTransientArgsForCall) +} + +func (fake *ChaincodeStub) GetTransientCalls(stub func() (map[string][]byte, error)) { + fake.getTransientMutex.Lock() + defer fake.getTransientMutex.Unlock() + fake.GetTransientStub = stub +} + +func (fake *ChaincodeStub) GetTransientReturns(result1 map[string][]byte, result2 error) { + fake.getTransientMutex.Lock() + defer fake.getTransientMutex.Unlock() + fake.GetTransientStub = nil + fake.getTransientReturns = struct { + result1 map[string][]byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetTransientReturnsOnCall(i int, result1 map[string][]byte, result2 error) { + fake.getTransientMutex.Lock() + defer fake.getTransientMutex.Unlock() + fake.GetTransientStub = nil + if fake.getTransientReturnsOnCall == nil { + fake.getTransientReturnsOnCall = make(map[int]struct { + result1 map[string][]byte + result2 error + }) + } + fake.getTransientReturnsOnCall[i] = struct { + result1 map[string][]byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetTxID() string { + fake.getTxIDMutex.Lock() + ret, specificReturn := fake.getTxIDReturnsOnCall[len(fake.getTxIDArgsForCall)] + fake.getTxIDArgsForCall = append(fake.getTxIDArgsForCall, struct { + }{}) + fake.recordInvocation("GetTxID", []interface{}{}) + fake.getTxIDMutex.Unlock() + if fake.GetTxIDStub != nil { + return fake.GetTxIDStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getTxIDReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) GetTxIDCallCount() int { + fake.getTxIDMutex.RLock() + defer fake.getTxIDMutex.RUnlock() + return len(fake.getTxIDArgsForCall) +} + +func (fake *ChaincodeStub) GetTxIDCalls(stub func() string) { + fake.getTxIDMutex.Lock() + defer fake.getTxIDMutex.Unlock() + fake.GetTxIDStub = stub +} + +func (fake *ChaincodeStub) GetTxIDReturns(result1 string) { + fake.getTxIDMutex.Lock() + defer fake.getTxIDMutex.Unlock() + fake.GetTxIDStub = nil + fake.getTxIDReturns = struct { + result1 string + }{result1} +} + +func (fake *ChaincodeStub) GetTxIDReturnsOnCall(i int, result1 string) { + fake.getTxIDMutex.Lock() + defer fake.getTxIDMutex.Unlock() + fake.GetTxIDStub = nil + if fake.getTxIDReturnsOnCall == nil { + fake.getTxIDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.getTxIDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *ChaincodeStub) GetTxTimestamp() (*timestamppb.Timestamp, error) { + fake.getTxTimestampMutex.Lock() + ret, specificReturn := fake.getTxTimestampReturnsOnCall[len(fake.getTxTimestampArgsForCall)] + fake.getTxTimestampArgsForCall = append(fake.getTxTimestampArgsForCall, struct { + }{}) + fake.recordInvocation("GetTxTimestamp", []interface{}{}) + fake.getTxTimestampMutex.Unlock() + if fake.GetTxTimestampStub != nil { + return fake.GetTxTimestampStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getTxTimestampReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetTxTimestampCallCount() int { + fake.getTxTimestampMutex.RLock() + defer fake.getTxTimestampMutex.RUnlock() + return len(fake.getTxTimestampArgsForCall) +} + +func (fake *ChaincodeStub) GetTxTimestampCalls(stub func() (*timestamppb.Timestamp, error)) { + fake.getTxTimestampMutex.Lock() + defer fake.getTxTimestampMutex.Unlock() + fake.GetTxTimestampStub = stub +} + +func (fake *ChaincodeStub) GetTxTimestampReturns(result1 *timestamppb.Timestamp, result2 error) { + fake.getTxTimestampMutex.Lock() + defer fake.getTxTimestampMutex.Unlock() + fake.GetTxTimestampStub = nil + fake.getTxTimestampReturns = struct { + result1 *timestamppb.Timestamp + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetTxTimestampReturnsOnCall(i int, result1 *timestamppb.Timestamp, result2 error) { + fake.getTxTimestampMutex.Lock() + defer fake.getTxTimestampMutex.Unlock() + fake.GetTxTimestampStub = nil + if fake.getTxTimestampReturnsOnCall == nil { + fake.getTxTimestampReturnsOnCall = make(map[int]struct { + result1 *timestamppb.Timestamp + result2 error + }) + } + fake.getTxTimestampReturnsOnCall[i] = struct { + result1 *timestamppb.Timestamp + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) InvokeChaincode(arg1 string, arg2 [][]byte, arg3 string) peer.Response { + var arg2Copy [][]byte + if arg2 != nil { + arg2Copy = make([][]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.invokeChaincodeMutex.Lock() + ret, specificReturn := fake.invokeChaincodeReturnsOnCall[len(fake.invokeChaincodeArgsForCall)] + fake.invokeChaincodeArgsForCall = append(fake.invokeChaincodeArgsForCall, struct { + arg1 string + arg2 [][]byte + arg3 string + }{arg1, arg2Copy, arg3}) + fake.recordInvocation("InvokeChaincode", []interface{}{arg1, arg2Copy, arg3}) + fake.invokeChaincodeMutex.Unlock() + if fake.InvokeChaincodeStub != nil { + return fake.InvokeChaincodeStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.invokeChaincodeReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) InvokeChaincodeCallCount() int { + fake.invokeChaincodeMutex.RLock() + defer fake.invokeChaincodeMutex.RUnlock() + return len(fake.invokeChaincodeArgsForCall) +} + +func (fake *ChaincodeStub) InvokeChaincodeCalls(stub func(string, [][]byte, string) peer.Response) { + fake.invokeChaincodeMutex.Lock() + defer fake.invokeChaincodeMutex.Unlock() + fake.InvokeChaincodeStub = stub +} + +func (fake *ChaincodeStub) InvokeChaincodeArgsForCall(i int) (string, [][]byte, string) { + fake.invokeChaincodeMutex.RLock() + defer fake.invokeChaincodeMutex.RUnlock() + argsForCall := fake.invokeChaincodeArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) InvokeChaincodeReturns(result1 peer.Response) { + fake.invokeChaincodeMutex.Lock() + defer fake.invokeChaincodeMutex.Unlock() + fake.InvokeChaincodeStub = nil + fake.invokeChaincodeReturns = struct { + result1 peer.Response + }{result1} +} + +func (fake *ChaincodeStub) InvokeChaincodeReturnsOnCall(i int, result1 peer.Response) { + fake.invokeChaincodeMutex.Lock() + defer fake.invokeChaincodeMutex.Unlock() + fake.InvokeChaincodeStub = nil + if fake.invokeChaincodeReturnsOnCall == nil { + fake.invokeChaincodeReturnsOnCall = make(map[int]struct { + result1 peer.Response + }) + } + fake.invokeChaincodeReturnsOnCall[i] = struct { + result1 peer.Response + }{result1} +} + +func (fake *ChaincodeStub) PutPrivateData(arg1 string, arg2 string, arg3 []byte) error { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.putPrivateDataMutex.Lock() + ret, specificReturn := fake.putPrivateDataReturnsOnCall[len(fake.putPrivateDataArgsForCall)] + fake.putPrivateDataArgsForCall = append(fake.putPrivateDataArgsForCall, struct { + arg1 string + arg2 string + arg3 []byte + }{arg1, arg2, arg3Copy}) + fake.recordInvocation("PutPrivateData", []interface{}{arg1, arg2, arg3Copy}) + fake.putPrivateDataMutex.Unlock() + if fake.PutPrivateDataStub != nil { + return fake.PutPrivateDataStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.putPrivateDataReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) PutPrivateDataCallCount() int { + fake.putPrivateDataMutex.RLock() + defer fake.putPrivateDataMutex.RUnlock() + return len(fake.putPrivateDataArgsForCall) +} + +func (fake *ChaincodeStub) PutPrivateDataCalls(stub func(string, string, []byte) error) { + fake.putPrivateDataMutex.Lock() + defer fake.putPrivateDataMutex.Unlock() + fake.PutPrivateDataStub = stub +} + +func (fake *ChaincodeStub) PutPrivateDataArgsForCall(i int) (string, string, []byte) { + fake.putPrivateDataMutex.RLock() + defer fake.putPrivateDataMutex.RUnlock() + argsForCall := fake.putPrivateDataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) PutPrivateDataReturns(result1 error) { + fake.putPrivateDataMutex.Lock() + defer fake.putPrivateDataMutex.Unlock() + fake.PutPrivateDataStub = nil + fake.putPrivateDataReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) PutPrivateDataReturnsOnCall(i int, result1 error) { + fake.putPrivateDataMutex.Lock() + defer fake.putPrivateDataMutex.Unlock() + fake.PutPrivateDataStub = nil + if fake.putPrivateDataReturnsOnCall == nil { + fake.putPrivateDataReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.putPrivateDataReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) PutState(arg1 string, arg2 []byte) error { + var arg2Copy []byte + if arg2 != nil { + arg2Copy = make([]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.putStateMutex.Lock() + ret, specificReturn := fake.putStateReturnsOnCall[len(fake.putStateArgsForCall)] + fake.putStateArgsForCall = append(fake.putStateArgsForCall, struct { + arg1 string + arg2 []byte + }{arg1, arg2Copy}) + fake.recordInvocation("PutState", []interface{}{arg1, arg2Copy}) + fake.putStateMutex.Unlock() + if fake.PutStateStub != nil { + return fake.PutStateStub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.putStateReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) PutStateCallCount() int { + fake.putStateMutex.RLock() + defer fake.putStateMutex.RUnlock() + return len(fake.putStateArgsForCall) +} + +func (fake *ChaincodeStub) PutStateCalls(stub func(string, []byte) error) { + fake.putStateMutex.Lock() + defer fake.putStateMutex.Unlock() + fake.PutStateStub = stub +} + +func (fake *ChaincodeStub) PutStateArgsForCall(i int) (string, []byte) { + fake.putStateMutex.RLock() + defer fake.putStateMutex.RUnlock() + argsForCall := fake.putStateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) PutStateReturns(result1 error) { + fake.putStateMutex.Lock() + defer fake.putStateMutex.Unlock() + fake.PutStateStub = nil + fake.putStateReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) PutStateReturnsOnCall(i int, result1 error) { + fake.putStateMutex.Lock() + defer fake.putStateMutex.Unlock() + fake.PutStateStub = nil + if fake.putStateReturnsOnCall == nil { + fake.putStateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.putStateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetEvent(arg1 string, arg2 []byte) error { + var arg2Copy []byte + if arg2 != nil { + arg2Copy = make([]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.setEventMutex.Lock() + ret, specificReturn := fake.setEventReturnsOnCall[len(fake.setEventArgsForCall)] + fake.setEventArgsForCall = append(fake.setEventArgsForCall, struct { + arg1 string + arg2 []byte + }{arg1, arg2Copy}) + fake.recordInvocation("SetEvent", []interface{}{arg1, arg2Copy}) + fake.setEventMutex.Unlock() + if fake.SetEventStub != nil { + return fake.SetEventStub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.setEventReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) SetEventCallCount() int { + fake.setEventMutex.RLock() + defer fake.setEventMutex.RUnlock() + return len(fake.setEventArgsForCall) +} + +func (fake *ChaincodeStub) SetEventCalls(stub func(string, []byte) error) { + fake.setEventMutex.Lock() + defer fake.setEventMutex.Unlock() + fake.SetEventStub = stub +} + +func (fake *ChaincodeStub) SetEventArgsForCall(i int) (string, []byte) { + fake.setEventMutex.RLock() + defer fake.setEventMutex.RUnlock() + argsForCall := fake.setEventArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) SetEventReturns(result1 error) { + fake.setEventMutex.Lock() + defer fake.setEventMutex.Unlock() + fake.SetEventStub = nil + fake.setEventReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetEventReturnsOnCall(i int, result1 error) { + fake.setEventMutex.Lock() + defer fake.setEventMutex.Unlock() + fake.SetEventStub = nil + if fake.setEventReturnsOnCall == nil { + fake.setEventReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setEventReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameter(arg1 string, arg2 string, arg3 []byte) error { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.setPrivateDataValidationParameterMutex.Lock() + ret, specificReturn := fake.setPrivateDataValidationParameterReturnsOnCall[len(fake.setPrivateDataValidationParameterArgsForCall)] + fake.setPrivateDataValidationParameterArgsForCall = append(fake.setPrivateDataValidationParameterArgsForCall, struct { + arg1 string + arg2 string + arg3 []byte + }{arg1, arg2, arg3Copy}) + fake.recordInvocation("SetPrivateDataValidationParameter", []interface{}{arg1, arg2, arg3Copy}) + fake.setPrivateDataValidationParameterMutex.Unlock() + if fake.SetPrivateDataValidationParameterStub != nil { + return fake.SetPrivateDataValidationParameterStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.setPrivateDataValidationParameterReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameterCallCount() int { + fake.setPrivateDataValidationParameterMutex.RLock() + defer fake.setPrivateDataValidationParameterMutex.RUnlock() + return len(fake.setPrivateDataValidationParameterArgsForCall) +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameterCalls(stub func(string, string, []byte) error) { + fake.setPrivateDataValidationParameterMutex.Lock() + defer fake.setPrivateDataValidationParameterMutex.Unlock() + fake.SetPrivateDataValidationParameterStub = stub +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameterArgsForCall(i int) (string, string, []byte) { + fake.setPrivateDataValidationParameterMutex.RLock() + defer fake.setPrivateDataValidationParameterMutex.RUnlock() + argsForCall := fake.setPrivateDataValidationParameterArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameterReturns(result1 error) { + fake.setPrivateDataValidationParameterMutex.Lock() + defer fake.setPrivateDataValidationParameterMutex.Unlock() + fake.SetPrivateDataValidationParameterStub = nil + fake.setPrivateDataValidationParameterReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameterReturnsOnCall(i int, result1 error) { + fake.setPrivateDataValidationParameterMutex.Lock() + defer fake.setPrivateDataValidationParameterMutex.Unlock() + fake.SetPrivateDataValidationParameterStub = nil + if fake.setPrivateDataValidationParameterReturnsOnCall == nil { + fake.setPrivateDataValidationParameterReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setPrivateDataValidationParameterReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetStateValidationParameter(arg1 string, arg2 []byte) error { + var arg2Copy []byte + if arg2 != nil { + arg2Copy = make([]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.setStateValidationParameterMutex.Lock() + ret, specificReturn := fake.setStateValidationParameterReturnsOnCall[len(fake.setStateValidationParameterArgsForCall)] + fake.setStateValidationParameterArgsForCall = append(fake.setStateValidationParameterArgsForCall, struct { + arg1 string + arg2 []byte + }{arg1, arg2Copy}) + fake.recordInvocation("SetStateValidationParameter", []interface{}{arg1, arg2Copy}) + fake.setStateValidationParameterMutex.Unlock() + if fake.SetStateValidationParameterStub != nil { + return fake.SetStateValidationParameterStub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.setStateValidationParameterReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) SetStateValidationParameterCallCount() int { + fake.setStateValidationParameterMutex.RLock() + defer fake.setStateValidationParameterMutex.RUnlock() + return len(fake.setStateValidationParameterArgsForCall) +} + +func (fake *ChaincodeStub) SetStateValidationParameterCalls(stub func(string, []byte) error) { + fake.setStateValidationParameterMutex.Lock() + defer fake.setStateValidationParameterMutex.Unlock() + fake.SetStateValidationParameterStub = stub +} + +func (fake *ChaincodeStub) SetStateValidationParameterArgsForCall(i int) (string, []byte) { + fake.setStateValidationParameterMutex.RLock() + defer fake.setStateValidationParameterMutex.RUnlock() + argsForCall := fake.setStateValidationParameterArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) SetStateValidationParameterReturns(result1 error) { + fake.setStateValidationParameterMutex.Lock() + defer fake.setStateValidationParameterMutex.Unlock() + fake.SetStateValidationParameterStub = nil + fake.setStateValidationParameterReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetStateValidationParameterReturnsOnCall(i int, result1 error) { + fake.setStateValidationParameterMutex.Lock() + defer fake.setStateValidationParameterMutex.Unlock() + fake.SetStateValidationParameterStub = nil + if fake.setStateValidationParameterReturnsOnCall == nil { + fake.setStateValidationParameterReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setStateValidationParameterReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SplitCompositeKey(arg1 string) (string, []string, error) { + fake.splitCompositeKeyMutex.Lock() + ret, specificReturn := fake.splitCompositeKeyReturnsOnCall[len(fake.splitCompositeKeyArgsForCall)] + fake.splitCompositeKeyArgsForCall = append(fake.splitCompositeKeyArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("SplitCompositeKey", []interface{}{arg1}) + fake.splitCompositeKeyMutex.Unlock() + if fake.SplitCompositeKeyStub != nil { + return fake.SplitCompositeKeyStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + fakeReturns := fake.splitCompositeKeyReturns + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *ChaincodeStub) SplitCompositeKeyCallCount() int { + fake.splitCompositeKeyMutex.RLock() + defer fake.splitCompositeKeyMutex.RUnlock() + return len(fake.splitCompositeKeyArgsForCall) +} + +func (fake *ChaincodeStub) SplitCompositeKeyCalls(stub func(string) (string, []string, error)) { + fake.splitCompositeKeyMutex.Lock() + defer fake.splitCompositeKeyMutex.Unlock() + fake.SplitCompositeKeyStub = stub +} + +func (fake *ChaincodeStub) SplitCompositeKeyArgsForCall(i int) string { + fake.splitCompositeKeyMutex.RLock() + defer fake.splitCompositeKeyMutex.RUnlock() + argsForCall := fake.splitCompositeKeyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) SplitCompositeKeyReturns(result1 string, result2 []string, result3 error) { + fake.splitCompositeKeyMutex.Lock() + defer fake.splitCompositeKeyMutex.Unlock() + fake.SplitCompositeKeyStub = nil + fake.splitCompositeKeyReturns = struct { + result1 string + result2 []string + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) SplitCompositeKeyReturnsOnCall(i int, result1 string, result2 []string, result3 error) { + fake.splitCompositeKeyMutex.Lock() + defer fake.splitCompositeKeyMutex.Unlock() + fake.SplitCompositeKeyStub = nil + if fake.splitCompositeKeyReturnsOnCall == nil { + fake.splitCompositeKeyReturnsOnCall = make(map[int]struct { + result1 string + result2 []string + result3 error + }) + } + fake.splitCompositeKeyReturnsOnCall[i] = struct { + result1 string + result2 []string + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.createCompositeKeyMutex.RLock() + defer fake.createCompositeKeyMutex.RUnlock() + fake.delPrivateDataMutex.RLock() + defer fake.delPrivateDataMutex.RUnlock() + fake.delStateMutex.RLock() + defer fake.delStateMutex.RUnlock() + fake.getArgsMutex.RLock() + defer fake.getArgsMutex.RUnlock() + fake.getArgsSliceMutex.RLock() + defer fake.getArgsSliceMutex.RUnlock() + fake.getBindingMutex.RLock() + defer fake.getBindingMutex.RUnlock() + fake.getChannelIDMutex.RLock() + defer fake.getChannelIDMutex.RUnlock() + fake.getCreatorMutex.RLock() + defer fake.getCreatorMutex.RUnlock() + fake.getDecorationsMutex.RLock() + defer fake.getDecorationsMutex.RUnlock() + fake.getFunctionAndParametersMutex.RLock() + defer fake.getFunctionAndParametersMutex.RUnlock() + fake.getHistoryForKeyMutex.RLock() + defer fake.getHistoryForKeyMutex.RUnlock() + fake.getPrivateDataMutex.RLock() + defer fake.getPrivateDataMutex.RUnlock() + fake.getPrivateDataByPartialCompositeKeyMutex.RLock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.RUnlock() + fake.getPrivateDataByRangeMutex.RLock() + defer fake.getPrivateDataByRangeMutex.RUnlock() + fake.getPrivateDataHashMutex.RLock() + defer fake.getPrivateDataHashMutex.RUnlock() + fake.getPrivateDataQueryResultMutex.RLock() + defer fake.getPrivateDataQueryResultMutex.RUnlock() + fake.getPrivateDataValidationParameterMutex.RLock() + defer fake.getPrivateDataValidationParameterMutex.RUnlock() + fake.getQueryResultMutex.RLock() + defer fake.getQueryResultMutex.RUnlock() + fake.getQueryResultWithPaginationMutex.RLock() + defer fake.getQueryResultWithPaginationMutex.RUnlock() + fake.getSignedProposalMutex.RLock() + defer fake.getSignedProposalMutex.RUnlock() + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + fake.getStateByPartialCompositeKeyMutex.RLock() + defer fake.getStateByPartialCompositeKeyMutex.RUnlock() + fake.getStateByPartialCompositeKeyWithPaginationMutex.RLock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.RUnlock() + fake.getStateByRangeMutex.RLock() + defer fake.getStateByRangeMutex.RUnlock() + fake.getStateByRangeWithPaginationMutex.RLock() + defer fake.getStateByRangeWithPaginationMutex.RUnlock() + fake.getStateValidationParameterMutex.RLock() + defer fake.getStateValidationParameterMutex.RUnlock() + fake.getStringArgsMutex.RLock() + defer fake.getStringArgsMutex.RUnlock() + fake.getTransientMutex.RLock() + defer fake.getTransientMutex.RUnlock() + fake.getTxIDMutex.RLock() + defer fake.getTxIDMutex.RUnlock() + fake.getTxTimestampMutex.RLock() + defer fake.getTxTimestampMutex.RUnlock() + fake.invokeChaincodeMutex.RLock() + defer fake.invokeChaincodeMutex.RUnlock() + fake.putPrivateDataMutex.RLock() + defer fake.putPrivateDataMutex.RUnlock() + fake.putStateMutex.RLock() + defer fake.putStateMutex.RUnlock() + fake.setEventMutex.RLock() + defer fake.setEventMutex.RUnlock() + fake.setPrivateDataValidationParameterMutex.RLock() + defer fake.setPrivateDataValidationParameterMutex.RUnlock() + fake.setStateValidationParameterMutex.RLock() + defer fake.setStateValidationParameterMutex.RUnlock() + fake.splitCompositeKeyMutex.RLock() + defer fake.splitCompositeKeyMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *ChaincodeStub) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} diff --git a/asset-transfer-private-data/chaincode-go/chaincode/mocks/clientIdentity.go b/asset-transfer-private-data/chaincode-go/chaincode/mocks/clientIdentity.go new file mode 100644 index 00000000..655dfd4f --- /dev/null +++ b/asset-transfer-private-data/chaincode-go/chaincode/mocks/clientIdentity.go @@ -0,0 +1,399 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mocks + +import ( + "crypto/x509" + "sync" +) + +type ClientIdentity struct { + AssertAttributeValueStub func(string, string) error + assertAttributeValueMutex sync.RWMutex + assertAttributeValueArgsForCall []struct { + arg1 string + arg2 string + } + assertAttributeValueReturns struct { + result1 error + } + assertAttributeValueReturnsOnCall map[int]struct { + result1 error + } + GetAttributeValueStub func(string) (string, bool, error) + getAttributeValueMutex sync.RWMutex + getAttributeValueArgsForCall []struct { + arg1 string + } + getAttributeValueReturns struct { + result1 string + result2 bool + result3 error + } + getAttributeValueReturnsOnCall map[int]struct { + result1 string + result2 bool + result3 error + } + GetIDStub func() (string, error) + getIDMutex sync.RWMutex + getIDArgsForCall []struct { + } + getIDReturns struct { + result1 string + result2 error + } + getIDReturnsOnCall map[int]struct { + result1 string + result2 error + } + GetMSPIDStub func() (string, error) + getMSPIDMutex sync.RWMutex + getMSPIDArgsForCall []struct { + } + getMSPIDReturns struct { + result1 string + result2 error + } + getMSPIDReturnsOnCall map[int]struct { + result1 string + result2 error + } + GetX509CertificateStub func() (*x509.Certificate, error) + getX509CertificateMutex sync.RWMutex + getX509CertificateArgsForCall []struct { + } + getX509CertificateReturns struct { + result1 *x509.Certificate + result2 error + } + getX509CertificateReturnsOnCall map[int]struct { + result1 *x509.Certificate + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *ClientIdentity) AssertAttributeValue(arg1 string, arg2 string) error { + fake.assertAttributeValueMutex.Lock() + ret, specificReturn := fake.assertAttributeValueReturnsOnCall[len(fake.assertAttributeValueArgsForCall)] + fake.assertAttributeValueArgsForCall = append(fake.assertAttributeValueArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("AssertAttributeValue", []interface{}{arg1, arg2}) + fake.assertAttributeValueMutex.Unlock() + if fake.AssertAttributeValueStub != nil { + return fake.AssertAttributeValueStub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.assertAttributeValueReturns + return fakeReturns.result1 +} + +func (fake *ClientIdentity) AssertAttributeValueCallCount() int { + fake.assertAttributeValueMutex.RLock() + defer fake.assertAttributeValueMutex.RUnlock() + return len(fake.assertAttributeValueArgsForCall) +} + +func (fake *ClientIdentity) AssertAttributeValueCalls(stub func(string, string) error) { + fake.assertAttributeValueMutex.Lock() + defer fake.assertAttributeValueMutex.Unlock() + fake.AssertAttributeValueStub = stub +} + +func (fake *ClientIdentity) AssertAttributeValueArgsForCall(i int) (string, string) { + fake.assertAttributeValueMutex.RLock() + defer fake.assertAttributeValueMutex.RUnlock() + argsForCall := fake.assertAttributeValueArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ClientIdentity) AssertAttributeValueReturns(result1 error) { + fake.assertAttributeValueMutex.Lock() + defer fake.assertAttributeValueMutex.Unlock() + fake.AssertAttributeValueStub = nil + fake.assertAttributeValueReturns = struct { + result1 error + }{result1} +} + +func (fake *ClientIdentity) AssertAttributeValueReturnsOnCall(i int, result1 error) { + fake.assertAttributeValueMutex.Lock() + defer fake.assertAttributeValueMutex.Unlock() + fake.AssertAttributeValueStub = nil + if fake.assertAttributeValueReturnsOnCall == nil { + fake.assertAttributeValueReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.assertAttributeValueReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ClientIdentity) GetAttributeValue(arg1 string) (string, bool, error) { + fake.getAttributeValueMutex.Lock() + ret, specificReturn := fake.getAttributeValueReturnsOnCall[len(fake.getAttributeValueArgsForCall)] + fake.getAttributeValueArgsForCall = append(fake.getAttributeValueArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("GetAttributeValue", []interface{}{arg1}) + fake.getAttributeValueMutex.Unlock() + if fake.GetAttributeValueStub != nil { + return fake.GetAttributeValueStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + fakeReturns := fake.getAttributeValueReturns + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *ClientIdentity) GetAttributeValueCallCount() int { + fake.getAttributeValueMutex.RLock() + defer fake.getAttributeValueMutex.RUnlock() + return len(fake.getAttributeValueArgsForCall) +} + +func (fake *ClientIdentity) GetAttributeValueCalls(stub func(string) (string, bool, error)) { + fake.getAttributeValueMutex.Lock() + defer fake.getAttributeValueMutex.Unlock() + fake.GetAttributeValueStub = stub +} + +func (fake *ClientIdentity) GetAttributeValueArgsForCall(i int) string { + fake.getAttributeValueMutex.RLock() + defer fake.getAttributeValueMutex.RUnlock() + argsForCall := fake.getAttributeValueArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ClientIdentity) GetAttributeValueReturns(result1 string, result2 bool, result3 error) { + fake.getAttributeValueMutex.Lock() + defer fake.getAttributeValueMutex.Unlock() + fake.GetAttributeValueStub = nil + fake.getAttributeValueReturns = struct { + result1 string + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *ClientIdentity) GetAttributeValueReturnsOnCall(i int, result1 string, result2 bool, result3 error) { + fake.getAttributeValueMutex.Lock() + defer fake.getAttributeValueMutex.Unlock() + fake.GetAttributeValueStub = nil + if fake.getAttributeValueReturnsOnCall == nil { + fake.getAttributeValueReturnsOnCall = make(map[int]struct { + result1 string + result2 bool + result3 error + }) + } + fake.getAttributeValueReturnsOnCall[i] = struct { + result1 string + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *ClientIdentity) GetID() (string, error) { + fake.getIDMutex.Lock() + ret, specificReturn := fake.getIDReturnsOnCall[len(fake.getIDArgsForCall)] + fake.getIDArgsForCall = append(fake.getIDArgsForCall, struct { + }{}) + fake.recordInvocation("GetID", []interface{}{}) + fake.getIDMutex.Unlock() + if fake.GetIDStub != nil { + return fake.GetIDStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getIDReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ClientIdentity) GetIDCallCount() int { + fake.getIDMutex.RLock() + defer fake.getIDMutex.RUnlock() + return len(fake.getIDArgsForCall) +} + +func (fake *ClientIdentity) GetIDCalls(stub func() (string, error)) { + fake.getIDMutex.Lock() + defer fake.getIDMutex.Unlock() + fake.GetIDStub = stub +} + +func (fake *ClientIdentity) GetIDReturns(result1 string, result2 error) { + fake.getIDMutex.Lock() + defer fake.getIDMutex.Unlock() + fake.GetIDStub = nil + fake.getIDReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *ClientIdentity) GetIDReturnsOnCall(i int, result1 string, result2 error) { + fake.getIDMutex.Lock() + defer fake.getIDMutex.Unlock() + fake.GetIDStub = nil + if fake.getIDReturnsOnCall == nil { + fake.getIDReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.getIDReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *ClientIdentity) GetMSPID() (string, error) { + fake.getMSPIDMutex.Lock() + ret, specificReturn := fake.getMSPIDReturnsOnCall[len(fake.getMSPIDArgsForCall)] + fake.getMSPIDArgsForCall = append(fake.getMSPIDArgsForCall, struct { + }{}) + fake.recordInvocation("GetMSPID", []interface{}{}) + fake.getMSPIDMutex.Unlock() + if fake.GetMSPIDStub != nil { + return fake.GetMSPIDStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getMSPIDReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ClientIdentity) GetMSPIDCallCount() int { + fake.getMSPIDMutex.RLock() + defer fake.getMSPIDMutex.RUnlock() + return len(fake.getMSPIDArgsForCall) +} + +func (fake *ClientIdentity) GetMSPIDCalls(stub func() (string, error)) { + fake.getMSPIDMutex.Lock() + defer fake.getMSPIDMutex.Unlock() + fake.GetMSPIDStub = stub +} + +func (fake *ClientIdentity) GetMSPIDReturns(result1 string, result2 error) { + fake.getMSPIDMutex.Lock() + defer fake.getMSPIDMutex.Unlock() + fake.GetMSPIDStub = nil + fake.getMSPIDReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *ClientIdentity) GetMSPIDReturnsOnCall(i int, result1 string, result2 error) { + fake.getMSPIDMutex.Lock() + defer fake.getMSPIDMutex.Unlock() + fake.GetMSPIDStub = nil + if fake.getMSPIDReturnsOnCall == nil { + fake.getMSPIDReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.getMSPIDReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *ClientIdentity) GetX509Certificate() (*x509.Certificate, error) { + fake.getX509CertificateMutex.Lock() + ret, specificReturn := fake.getX509CertificateReturnsOnCall[len(fake.getX509CertificateArgsForCall)] + fake.getX509CertificateArgsForCall = append(fake.getX509CertificateArgsForCall, struct { + }{}) + fake.recordInvocation("GetX509Certificate", []interface{}{}) + fake.getX509CertificateMutex.Unlock() + if fake.GetX509CertificateStub != nil { + return fake.GetX509CertificateStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getX509CertificateReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ClientIdentity) GetX509CertificateCallCount() int { + fake.getX509CertificateMutex.RLock() + defer fake.getX509CertificateMutex.RUnlock() + return len(fake.getX509CertificateArgsForCall) +} + +func (fake *ClientIdentity) GetX509CertificateCalls(stub func() (*x509.Certificate, error)) { + fake.getX509CertificateMutex.Lock() + defer fake.getX509CertificateMutex.Unlock() + fake.GetX509CertificateStub = stub +} + +func (fake *ClientIdentity) GetX509CertificateReturns(result1 *x509.Certificate, result2 error) { + fake.getX509CertificateMutex.Lock() + defer fake.getX509CertificateMutex.Unlock() + fake.GetX509CertificateStub = nil + fake.getX509CertificateReturns = struct { + result1 *x509.Certificate + result2 error + }{result1, result2} +} + +func (fake *ClientIdentity) GetX509CertificateReturnsOnCall(i int, result1 *x509.Certificate, result2 error) { + fake.getX509CertificateMutex.Lock() + defer fake.getX509CertificateMutex.Unlock() + fake.GetX509CertificateStub = nil + if fake.getX509CertificateReturnsOnCall == nil { + fake.getX509CertificateReturnsOnCall = make(map[int]struct { + result1 *x509.Certificate + result2 error + }) + } + fake.getX509CertificateReturnsOnCall[i] = struct { + result1 *x509.Certificate + result2 error + }{result1, result2} +} + +func (fake *ClientIdentity) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.assertAttributeValueMutex.RLock() + defer fake.assertAttributeValueMutex.RUnlock() + fake.getAttributeValueMutex.RLock() + defer fake.getAttributeValueMutex.RUnlock() + fake.getIDMutex.RLock() + defer fake.getIDMutex.RUnlock() + fake.getMSPIDMutex.RLock() + defer fake.getMSPIDMutex.RUnlock() + fake.getX509CertificateMutex.RLock() + defer fake.getX509CertificateMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *ClientIdentity) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} diff --git a/asset-transfer-private-data/chaincode-go/chaincode/mocks/statequeryiterator.go b/asset-transfer-private-data/chaincode-go/chaincode/mocks/statequeryiterator.go new file mode 100644 index 00000000..27e30349 --- /dev/null +++ b/asset-transfer-private-data/chaincode-go/chaincode/mocks/statequeryiterator.go @@ -0,0 +1,232 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mocks + +import ( + "sync" + + "github.com/hyperledger/fabric-protos-go/ledger/queryresult" +) + +type StateQueryIterator struct { + CloseStub func() error + closeMutex sync.RWMutex + closeArgsForCall []struct { + } + closeReturns struct { + result1 error + } + closeReturnsOnCall map[int]struct { + result1 error + } + HasNextStub func() bool + hasNextMutex sync.RWMutex + hasNextArgsForCall []struct { + } + hasNextReturns struct { + result1 bool + } + hasNextReturnsOnCall map[int]struct { + result1 bool + } + NextStub func() (*queryresult.KV, error) + nextMutex sync.RWMutex + nextArgsForCall []struct { + } + nextReturns struct { + result1 *queryresult.KV + result2 error + } + nextReturnsOnCall map[int]struct { + result1 *queryresult.KV + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *StateQueryIterator) Close() error { + fake.closeMutex.Lock() + ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] + fake.closeArgsForCall = append(fake.closeArgsForCall, struct { + }{}) + fake.recordInvocation("Close", []interface{}{}) + fake.closeMutex.Unlock() + if fake.CloseStub != nil { + return fake.CloseStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.closeReturns + return fakeReturns.result1 +} + +func (fake *StateQueryIterator) CloseCallCount() int { + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + return len(fake.closeArgsForCall) +} + +func (fake *StateQueryIterator) CloseCalls(stub func() error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = stub +} + +func (fake *StateQueryIterator) CloseReturns(result1 error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = nil + fake.closeReturns = struct { + result1 error + }{result1} +} + +func (fake *StateQueryIterator) CloseReturnsOnCall(i int, result1 error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = nil + if fake.closeReturnsOnCall == nil { + fake.closeReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.closeReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *StateQueryIterator) HasNext() bool { + fake.hasNextMutex.Lock() + ret, specificReturn := fake.hasNextReturnsOnCall[len(fake.hasNextArgsForCall)] + fake.hasNextArgsForCall = append(fake.hasNextArgsForCall, struct { + }{}) + fake.recordInvocation("HasNext", []interface{}{}) + fake.hasNextMutex.Unlock() + if fake.HasNextStub != nil { + return fake.HasNextStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.hasNextReturns + return fakeReturns.result1 +} + +func (fake *StateQueryIterator) HasNextCallCount() int { + fake.hasNextMutex.RLock() + defer fake.hasNextMutex.RUnlock() + return len(fake.hasNextArgsForCall) +} + +func (fake *StateQueryIterator) HasNextCalls(stub func() bool) { + fake.hasNextMutex.Lock() + defer fake.hasNextMutex.Unlock() + fake.HasNextStub = stub +} + +func (fake *StateQueryIterator) HasNextReturns(result1 bool) { + fake.hasNextMutex.Lock() + defer fake.hasNextMutex.Unlock() + fake.HasNextStub = nil + fake.hasNextReturns = struct { + result1 bool + }{result1} +} + +func (fake *StateQueryIterator) HasNextReturnsOnCall(i int, result1 bool) { + fake.hasNextMutex.Lock() + defer fake.hasNextMutex.Unlock() + fake.HasNextStub = nil + if fake.hasNextReturnsOnCall == nil { + fake.hasNextReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.hasNextReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *StateQueryIterator) Next() (*queryresult.KV, error) { + fake.nextMutex.Lock() + ret, specificReturn := fake.nextReturnsOnCall[len(fake.nextArgsForCall)] + fake.nextArgsForCall = append(fake.nextArgsForCall, struct { + }{}) + fake.recordInvocation("Next", []interface{}{}) + fake.nextMutex.Unlock() + if fake.NextStub != nil { + return fake.NextStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.nextReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *StateQueryIterator) NextCallCount() int { + fake.nextMutex.RLock() + defer fake.nextMutex.RUnlock() + return len(fake.nextArgsForCall) +} + +func (fake *StateQueryIterator) NextCalls(stub func() (*queryresult.KV, error)) { + fake.nextMutex.Lock() + defer fake.nextMutex.Unlock() + fake.NextStub = stub +} + +func (fake *StateQueryIterator) NextReturns(result1 *queryresult.KV, result2 error) { + fake.nextMutex.Lock() + defer fake.nextMutex.Unlock() + fake.NextStub = nil + fake.nextReturns = struct { + result1 *queryresult.KV + result2 error + }{result1, result2} +} + +func (fake *StateQueryIterator) NextReturnsOnCall(i int, result1 *queryresult.KV, result2 error) { + fake.nextMutex.Lock() + defer fake.nextMutex.Unlock() + fake.NextStub = nil + if fake.nextReturnsOnCall == nil { + fake.nextReturnsOnCall = make(map[int]struct { + result1 *queryresult.KV + result2 error + }) + } + fake.nextReturnsOnCall[i] = struct { + result1 *queryresult.KV + result2 error + }{result1, result2} +} + +func (fake *StateQueryIterator) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + fake.hasNextMutex.RLock() + defer fake.hasNextMutex.RUnlock() + fake.nextMutex.RLock() + defer fake.nextMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *StateQueryIterator) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} diff --git a/asset-transfer-private-data/chaincode-go/chaincode/mocks/transaction.go b/asset-transfer-private-data/chaincode-go/chaincode/mocks/transaction.go new file mode 100644 index 00000000..eea37db7 --- /dev/null +++ b/asset-transfer-private-data/chaincode-go/chaincode/mocks/transaction.go @@ -0,0 +1,164 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mocks + +import ( + "sync" + + "github.com/hyperledger/fabric-chaincode-go/pkg/cid" + "github.com/hyperledger/fabric-chaincode-go/shim" +) + +type TransactionContext struct { + GetClientIdentityStub func() cid.ClientIdentity + getClientIdentityMutex sync.RWMutex + getClientIdentityArgsForCall []struct { + } + getClientIdentityReturns struct { + result1 cid.ClientIdentity + } + getClientIdentityReturnsOnCall map[int]struct { + result1 cid.ClientIdentity + } + GetStubStub func() shim.ChaincodeStubInterface + getStubMutex sync.RWMutex + getStubArgsForCall []struct { + } + getStubReturns struct { + result1 shim.ChaincodeStubInterface + } + getStubReturnsOnCall map[int]struct { + result1 shim.ChaincodeStubInterface + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *TransactionContext) GetClientIdentity() cid.ClientIdentity { + fake.getClientIdentityMutex.Lock() + ret, specificReturn := fake.getClientIdentityReturnsOnCall[len(fake.getClientIdentityArgsForCall)] + fake.getClientIdentityArgsForCall = append(fake.getClientIdentityArgsForCall, struct { + }{}) + fake.recordInvocation("GetClientIdentity", []interface{}{}) + fake.getClientIdentityMutex.Unlock() + if fake.GetClientIdentityStub != nil { + return fake.GetClientIdentityStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getClientIdentityReturns + return fakeReturns.result1 +} + +func (fake *TransactionContext) GetClientIdentityCallCount() int { + fake.getClientIdentityMutex.RLock() + defer fake.getClientIdentityMutex.RUnlock() + return len(fake.getClientIdentityArgsForCall) +} + +func (fake *TransactionContext) GetClientIdentityCalls(stub func() cid.ClientIdentity) { + fake.getClientIdentityMutex.Lock() + defer fake.getClientIdentityMutex.Unlock() + fake.GetClientIdentityStub = stub +} + +func (fake *TransactionContext) GetClientIdentityReturns(result1 cid.ClientIdentity) { + fake.getClientIdentityMutex.Lock() + defer fake.getClientIdentityMutex.Unlock() + fake.GetClientIdentityStub = nil + fake.getClientIdentityReturns = struct { + result1 cid.ClientIdentity + }{result1} +} + +func (fake *TransactionContext) GetClientIdentityReturnsOnCall(i int, result1 cid.ClientIdentity) { + fake.getClientIdentityMutex.Lock() + defer fake.getClientIdentityMutex.Unlock() + fake.GetClientIdentityStub = nil + if fake.getClientIdentityReturnsOnCall == nil { + fake.getClientIdentityReturnsOnCall = make(map[int]struct { + result1 cid.ClientIdentity + }) + } + fake.getClientIdentityReturnsOnCall[i] = struct { + result1 cid.ClientIdentity + }{result1} +} + +func (fake *TransactionContext) GetStub() shim.ChaincodeStubInterface { + fake.getStubMutex.Lock() + ret, specificReturn := fake.getStubReturnsOnCall[len(fake.getStubArgsForCall)] + fake.getStubArgsForCall = append(fake.getStubArgsForCall, struct { + }{}) + fake.recordInvocation("GetStub", []interface{}{}) + fake.getStubMutex.Unlock() + if fake.GetStubStub != nil { + return fake.GetStubStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getStubReturns + return fakeReturns.result1 +} + +func (fake *TransactionContext) GetStubCallCount() int { + fake.getStubMutex.RLock() + defer fake.getStubMutex.RUnlock() + return len(fake.getStubArgsForCall) +} + +func (fake *TransactionContext) GetStubCalls(stub func() shim.ChaincodeStubInterface) { + fake.getStubMutex.Lock() + defer fake.getStubMutex.Unlock() + fake.GetStubStub = stub +} + +func (fake *TransactionContext) GetStubReturns(result1 shim.ChaincodeStubInterface) { + fake.getStubMutex.Lock() + defer fake.getStubMutex.Unlock() + fake.GetStubStub = nil + fake.getStubReturns = struct { + result1 shim.ChaincodeStubInterface + }{result1} +} + +func (fake *TransactionContext) GetStubReturnsOnCall(i int, result1 shim.ChaincodeStubInterface) { + fake.getStubMutex.Lock() + defer fake.getStubMutex.Unlock() + fake.GetStubStub = nil + if fake.getStubReturnsOnCall == nil { + fake.getStubReturnsOnCall = make(map[int]struct { + result1 shim.ChaincodeStubInterface + }) + } + fake.getStubReturnsOnCall[i] = struct { + result1 shim.ChaincodeStubInterface + }{result1} +} + +func (fake *TransactionContext) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.getClientIdentityMutex.RLock() + defer fake.getClientIdentityMutex.RUnlock() + fake.getStubMutex.RLock() + defer fake.getStubMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *TransactionContext) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} diff --git a/asset-transfer-private-data/chaincode-go/go.mod b/asset-transfer-private-data/chaincode-go/go.mod index 332f10af..a4725c4c 100644 --- a/asset-transfer-private-data/chaincode-go/go.mod +++ b/asset-transfer-private-data/chaincode-go/go.mod @@ -1,4 +1,4 @@ -module github.com/hyperledger/fabric-samples/asset-transfer-private-data/chaincode-go/go +module github.com/hyperledger/fabric-samples/asset-transfer-private-data/chaincode-go go 1.14 @@ -11,14 +11,15 @@ require ( github.com/golang/protobuf v1.4.2 // indirect github.com/hyperledger/fabric-chaincode-go v0.0.0-20200511190512-bcfeb58dd83a github.com/hyperledger/fabric-contract-api-go v1.1.0 - github.com/hyperledger/fabric-protos-go v0.0.0-20200707132912-fee30f3ccd23 // indirect + github.com/hyperledger/fabric-protos-go v0.0.0-20200707132912-fee30f3ccd23 github.com/mailru/easyjson v0.7.1 // indirect github.com/rogpeppe/go-internal v1.6.0 // indirect + github.com/stretchr/testify v1.5.1 github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect golang.org/x/net v0.0.0-20200707034311-ab3426394381 // indirect golang.org/x/sys v0.0.0-20200720211630-cb9d2d5c5666 // indirect google.golang.org/genproto v0.0.0-20200721032028-5044d0edf986 // indirect google.golang.org/grpc v1.30.0 // indirect - google.golang.org/protobuf v1.25.0 // indirect + google.golang.org/protobuf v1.25.0 gopkg.in/yaml.v2 v2.3.0 // indirect ) diff --git a/asset-transfer-private-data/chaincode-go/main.go b/asset-transfer-private-data/chaincode-go/main.go new file mode 100644 index 00000000..6e0d671d --- /dev/null +++ b/asset-transfer-private-data/chaincode-go/main.go @@ -0,0 +1,23 @@ +/* +SPDX-License-Identifier: Apache-2.0 +*/ + +package main + +import ( + "log" + + "github.com/hyperledger/fabric-contract-api-go/contractapi" + "github.com/hyperledger/fabric-samples/asset-transfer-private-data/chaincode-go/chaincode" +) + +func main() { + assetChaincode, err := contractapi.NewChaincode(&chaincode.SmartContract{}) + if err != nil { + log.Panicf("Error creating asset-transfer-private-data chaincode: %v", err) + } + + if err := assetChaincode.Start(); err != nil { + log.Panicf("Error starting asset-transfer-private-data chaincode: %v", err) + } +} From a16d6c8ea88991ed795a0b3a1cfbe5d7695a7a49 Mon Sep 17 00:00:00 2001 From: Sijo Cherian Date: Mon, 10 Aug 2020 22:51:54 -0400 Subject: [PATCH 2/3] Added unit tests for query-asset chaincode functions Signed-off-by: Sijo Cherian --- .../chaincode/asset_queries_test.go | 185 +++++++++++ .../chaincode-go/chaincode/asset_transfer.go | 18 +- .../chaincode/asset_transfer_test.go | 291 ++++++++---------- 3 files changed, 319 insertions(+), 175 deletions(-) create mode 100644 asset-transfer-private-data/chaincode-go/chaincode/asset_queries_test.go diff --git a/asset-transfer-private-data/chaincode-go/chaincode/asset_queries_test.go b/asset-transfer-private-data/chaincode-go/chaincode/asset_queries_test.go new file mode 100644 index 00000000..3663c87a --- /dev/null +++ b/asset-transfer-private-data/chaincode-go/chaincode/asset_queries_test.go @@ -0,0 +1,185 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ +package chaincode_test + +import ( + "encoding/json" + "fmt" + "testing" + + "github.com/hyperledger/fabric-protos-go/ledger/queryresult" + + "github.com/hyperledger/fabric-samples/asset-transfer-private-data/chaincode-go/chaincode" + "github.com/hyperledger/fabric-samples/asset-transfer-private-data/chaincode-go/chaincode/mocks" + "github.com/stretchr/testify/require" +) + +/* +For details on generating the mocks, see comments in the file asset_transfer_test.go +*/ +func TestReadAsset(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + + assetBytes, err := assetTransferCC.ReadAsset(transactionContext, "id1") + require.NoError(t, err) + require.Nil(t, assetBytes) + + chaincodeStub.GetPrivateDataReturns(nil, fmt.Errorf("unable to retrieve asset")) + assetBytes, err = assetTransferCC.ReadAsset(transactionContext, "id1") + require.EqualError(t, err, "failed to read asset: unable to retrieve asset") + + testAsset := &chaincode.Asset{ + ID: "id1", + Type: "testfulasset", + Color: "gray", + Size: 7, + Owner: myOrg1Clientid, + } + setReturnPrivateDataInStub(t, chaincodeStub, testAsset) + assetRead, err := assetTransferCC.ReadAsset(transactionContext, "id1") + require.NoError(t, err) + require.Equal(t, testAsset, assetRead) +} + +func TestReadAssetPrivateDetails(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + + assetBytes, err := assetTransferCC.ReadAssetPrivateDetails(transactionContext, myOrg1PrivCollection, "id1") + require.NoError(t, err) + require.Nil(t, assetBytes) + + //read from the collection with no access + chaincodeStub.GetPrivateDataReturns(nil, fmt.Errorf("collection not found")) + assetBytes, err = assetTransferCC.ReadAssetPrivateDetails(transactionContext, myOrg2PrivCollection, "id1") + require.EqualError(t, err, "failed to read asset details: collection not found") + + returnPrivData := &chaincode.AssetPrivateDetails{ + ID: "id1", + AppraisedValue: 5, + } + setReturnAssetPrivateDetailsInStub(t, chaincodeStub, returnPrivData) + assetRead, err := assetTransferCC.ReadAssetPrivateDetails(transactionContext, myOrg1PrivCollection, "id1") + require.NoError(t, err) + require.Equal(t, returnPrivData, assetRead) +} + +func TestReadTransferAgreement(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + + //TransferAgreement does not exist + assetBytes, err := assetTransferCC.ReadTransferAgreement(transactionContext, "id1") + require.NoError(t, err) + require.Nil(t, assetBytes) + + chaincodeStub.GetPrivateDataReturns([]byte(myOrg2Clientid), nil) + expectedData := &chaincode.TransferAgreement{ + ID: "id1", + BuyerID: myOrg2Clientid, + } + dataRead, err := assetTransferCC.ReadTransferAgreement(transactionContext, "id1") + require.NoError(t, err) + require.Equal(t, expectedData, dataRead) +} + +func TestQueryAssetByOwner(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + + asset := &chaincode.Asset{Type: "valuableasset", ID: "asset1", Owner: "user1"} + asset1Bytes, err := json.Marshal(asset) + require.NoError(t, err) + + iterator := &mocks.StateQueryIterator{} + iterator.HasNextReturnsOnCall(0, true) + iterator.HasNextReturnsOnCall(1, false) + iterator.NextReturns(&queryresult.KV{Value: asset1Bytes}, nil) + chaincodeStub.GetPrivateDataQueryResultReturns(iterator, nil) + + assetTransferCC := &chaincode.SmartContract{} + assets, err := assetTransferCC.QueryAssetByOwner(transactionContext, "valuableasset", "user1") + require.NoError(t, err) + require.Equal(t, []*chaincode.Asset{asset}, assets) + + iterator.HasNextReturns(true) + iterator.NextReturns(nil, fmt.Errorf("failed retrieving next item")) + assets, err = assetTransferCC.QueryAssetByOwner(transactionContext, "valuableasset", "user1") + require.EqualError(t, err, "failed retrieving next item") + require.Nil(t, assets) + +} + +func TestQueryAssets(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + //Iterator with no records + iterator := &mocks.StateQueryIterator{} + iterator.HasNextReturns(false) + chaincodeStub.GetPrivateDataQueryResultReturns(iterator, nil) + + assetTransferCC := &chaincode.SmartContract{} + assets, err := assetTransferCC.QueryAssets(transactionContext, "querystr") + require.NoError(t, err) + require.Equal(t, []*chaincode.Asset{}, assets) + + iterator = &mocks.StateQueryIterator{} + chaincodeStub.GetPrivateDataQueryResultReturns(iterator, nil) + iterator.HasNextReturns(true) + iterator.NextReturns(nil, fmt.Errorf("failed retrieving next item")) + assets, err = assetTransferCC.QueryAssets(transactionContext, "querystr") + require.EqualError(t, err, "failed retrieving next item") + require.Nil(t, assets) + + asset := &chaincode.Asset{Type: "valuableasset", ID: "asset1", Owner: "user1"} + asset1Bytes, err := json.Marshal(asset) + require.NoError(t, err) + + iterator = &mocks.StateQueryIterator{} + chaincodeStub.GetPrivateDataQueryResultReturns(iterator, nil) + iterator.HasNextReturnsOnCall(0, true) + iterator.HasNextReturnsOnCall(1, false) + iterator.NextReturns(&queryresult.KV{Value: asset1Bytes}, nil) + + assets, err = assetTransferCC.QueryAssets(transactionContext, "querystr") + require.NoError(t, err) + require.Equal(t, []*chaincode.Asset{asset}, assets) +} + +func TestGetAssetByRange(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + //Iterator with no records + iterator := &mocks.StateQueryIterator{} + iterator.HasNextReturns(false) + chaincodeStub.GetPrivateDataByRangeReturns(iterator, nil) + + assetTransferCC := &chaincode.SmartContract{} + assets, err := assetTransferCC.GetAssetByRange(transactionContext, "st", "end") + require.NoError(t, err) + require.Equal(t, []*chaincode.Asset{}, assets) + + iterator = &mocks.StateQueryIterator{} + chaincodeStub.GetPrivateDataByRangeReturns(iterator, nil) + iterator.HasNextReturns(true) + iterator.NextReturns(nil, fmt.Errorf("failed retrieving next item")) + assets, err = assetTransferCC.GetAssetByRange(transactionContext, "st", "end") + require.EqualError(t, err, "failed retrieving next item") + require.Nil(t, assets) + + asset := &chaincode.Asset{Type: "valuableasset", ID: "asset1", Owner: "user1"} + asset1Bytes, err := json.Marshal(asset) + require.NoError(t, err) + + iterator = &mocks.StateQueryIterator{} + chaincodeStub.GetPrivateDataByRangeReturns(iterator, nil) + iterator.HasNextReturnsOnCall(0, true) + iterator.HasNextReturnsOnCall(1, false) + iterator.NextReturns(&queryresult.KV{Value: asset1Bytes}, nil) + + assets, err = assetTransferCC.GetAssetByRange(transactionContext, "st", "end") + require.NoError(t, err) + require.Equal(t, []*chaincode.Asset{asset}, assets) + +} diff --git a/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer.go b/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer.go index 7010e62c..aeb19b72 100644 --- a/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer.go +++ b/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer.go @@ -116,14 +116,14 @@ func (s *SmartContract) CreateAsset(ctx contractapi.TransactionContextInterface) } // Make submitting client the owner - asset := &Asset{ + asset := Asset{ Type: assetInput.Type, ID: assetInput.ID, Color: assetInput.Color, Size: assetInput.Size, Owner: clientID, } - assetJSONasBytes, err := json.Marshal(asset) + assetJSONasBytes, err := json.Marshal(&asset) if err != nil { return fmt.Errorf("failed to marshal asset into JSON: %v", err) } @@ -138,12 +138,12 @@ func (s *SmartContract) CreateAsset(ctx contractapi.TransactionContextInterface) } // Save asset details to collection visible to owning organization - assetPrivateDetails := &AssetPrivateDetails{ + assetPrivateDetails := AssetPrivateDetails{ ID: assetInput.ID, AppraisedValue: assetInput.AppraisedValue, } - assetPrivateDetailsAsBytes, err := json.Marshal(assetPrivateDetails) // marshal asset details to JSON + assetPrivateDetailsAsBytes, err := json.Marshal(&assetPrivateDetails) // marshal asset details to JSON if err != nil { return fmt.Errorf("failed to marshal into JSON: %v", err) } @@ -202,6 +202,14 @@ func (s *SmartContract) AgreeToTransfer(ctx contractapi.TransactionContextInterf return fmt.Errorf("appraisedValue field must be a positive integer") } + // Read asset from the private data collection + asset, err := s.ReadAsset(ctx, valueJSON.ID) + if err != nil { + return fmt.Errorf("error reading asset: %v", err) + } + if asset == nil { + return fmt.Errorf("%v does not exist", valueJSON.ID) + } // Verify that the client is submitting request to peer in their organization err = verifyClientOrgMatchesPeerOrg(ctx) if err != nil { @@ -488,7 +496,7 @@ func (s *SmartContract) DeleteTranferAgreement(ctx contractapi.TransactionContex } if len(assetDeleteInput.ID) == 0 { - return fmt.Errorf("ID field must be a non-empty string") + return fmt.Errorf("transient input ID field must be a non-empty string") } // Verify that the client is submitting request to peer in their organization diff --git a/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer_test.go b/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer_test.go index f3de987e..c6ec5ac5 100644 --- a/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer_test.go +++ b/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer_test.go @@ -1,8 +1,12 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ package chaincode_test import ( "encoding/json" - "fmt" "os" "testing" @@ -139,36 +143,102 @@ func TestCreateAssetSuccessful(t *testing.T) { require.Equal(t, assetBytes, calledAssetBytes) } -func TestReadAsset(t *testing.T) { +func TestAgreeToTransferBadInput(t *testing.T) { transactionContext, chaincodeStub := prepMocksAsOrg1() assetTransferCC := chaincode.SmartContract{} - assetBytes, err := assetTransferCC.ReadAsset(transactionContext, "id1") - require.NoError(t, err) - require.Nil(t, assetBytes) - - chaincodeStub.GetPrivateDataReturns(nil, fmt.Errorf("unable to retrieve asset")) - assetBytes, err = assetTransferCC.ReadAsset(transactionContext, "id1") - require.EqualError(t, err, "failed to read asset: unable to retrieve asset") - - testAsset := &chaincode.Asset{ + assetPrivDetail := &chaincode.AssetPrivateDetails{ + ID: "id1", + //no AppraisedValue + } + setReturnAssetPrivateDetailsInTransientMap(t, chaincodeStub, assetPrivDetail) + origAsset := chaincode.Asset{ ID: "id1", Type: "testfulasset", Color: "gray", Size: 7, Owner: myOrg1Clientid, } - setReturnPrivateDataInStub(t, chaincodeStub, testAsset) - assetRead, err := assetTransferCC.ReadAsset(transactionContext, "id1") - require.NoError(t, err) - require.Equal(t, testAsset, assetRead) + setReturnPrivateDataInStub(t, chaincodeStub, &origAsset) + + err := assetTransferCC.AgreeToTransfer(transactionContext) + require.EqualError(t, err, "appraisedValue field must be a positive integer") + + assetPrivDetail = &chaincode.AssetPrivateDetails{ + //no ID + AppraisedValue: 500, + } + setReturnAssetPrivateDetailsInTransientMap(t, chaincodeStub, assetPrivDetail) + err = assetTransferCC.AgreeToTransfer(transactionContext) + require.EqualError(t, err, "assetID field must be a non-empty string") + + assetPrivDetail = &chaincode.AssetPrivateDetails{ + ID: "id1", + AppraisedValue: 500, + } + setReturnAssetPrivateDetailsInTransientMap(t, chaincodeStub, assetPrivDetail) + //asset does not exist + setReturnPrivateDataInStub(t, chaincodeStub, nil) + err = assetTransferCC.AgreeToTransfer(transactionContext) + require.EqualError(t, err, "id1 does not exist") } -//todo -// ReadAssetPrivateDetails -// AgreeToTransfer +func TestAgreeToTransferSuccessful(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + assetPrivDetail := &chaincode.AssetPrivateDetails{ + ID: "id1", + AppraisedValue: 500, + } + setReturnAssetPrivateDetailsInTransientMap(t, chaincodeStub, assetPrivDetail) + origAsset := chaincode.Asset{ + ID: "id1", + Type: "testfulasset", + Color: "gray", + Size: 7, + Owner: myOrg1Clientid, + } + setReturnPrivateDataInStub(t, chaincodeStub, &origAsset) + chaincodeStub.CreateCompositeKeyReturns(transferAgreementObjectType+"id1", nil) + err := assetTransferCC.AgreeToTransfer(transactionContext) + require.NoError(t, err) -func TestTransferAsset(t *testing.T) { + expectedDataBytes, err := json.Marshal(assetPrivDetail) + calledCollection, calledId, calledWithDataBytes := chaincodeStub.PutPrivateDataArgsForCall(0) + require.Equal(t, myOrg1PrivCollection, calledCollection) + require.Equal(t, "id1", calledId) + require.Equal(t, expectedDataBytes, calledWithDataBytes) + + calledCollection, calledId, calledWithDataBytes = chaincodeStub.PutPrivateDataArgsForCall(1) + require.Equal(t, assetCollectionName, calledCollection) + require.Equal(t, transferAgreementObjectType+"id1", calledId) + require.Equal(t, []byte(myOrg1Clientid), calledWithDataBytes) +} +func TestTransferAssetBadInput(t *testing.T) { + transactionContext, chaincodeStub := prepMocksAsOrg1() + assetTransferCC := chaincode.SmartContract{} + + assetNewOwner := &assetTransferTransientInput{ + ID: "id1", + BuyerMSP: "", + } + setReturnAssetOwnerInTransientMap(t, chaincodeStub, assetNewOwner) + setReturnPrivateDataInStub(t, chaincodeStub, &chaincode.Asset{}) + err := assetTransferCC.TransferAsset(transactionContext) + require.EqualError(t, err, "buyerMSP field must be a non-empty string") + + assetNewOwner = &assetTransferTransientInput{ + ID: "id1", + BuyerMSP: myOrg2Msp, + } + setReturnAssetOwnerInTransientMap(t, chaincodeStub, assetNewOwner) + //asset does not exist + setReturnPrivateDataInStub(t, chaincodeStub, nil) + err = assetTransferCC.TransferAsset(transactionContext) + require.EqualError(t, err, "id1 does not exist") +} + +func TestTransferAssetSuccessful(t *testing.T) { transactionContext, chaincodeStub := prepMocksAsOrg1() assetTransferCC := chaincode.SmartContract{} assetNewOwner := &assetTransferTransientInput{ @@ -258,30 +328,6 @@ func TestTransferAssetWithoutAnAgreement(t *testing.T) { require.EqualError(t, err, "BuyerID not found in TransferAgreement for id1") } -func TestTransferAssetBadInput(t *testing.T) { - transactionContext, chaincodeStub := prepMocksAsOrg1() - assetTransferCC := chaincode.SmartContract{} - - assetNewOwner := &assetTransferTransientInput{ - ID: "id1", - BuyerMSP: "", - } - setReturnAssetOwnerInTransientMap(t, chaincodeStub, assetNewOwner) - setReturnPrivateDataInStub(t, chaincodeStub, &chaincode.Asset{}) - err := assetTransferCC.TransferAsset(transactionContext) - require.EqualError(t, err, "buyerMSP field must be a non-empty string") - - assetNewOwner = &assetTransferTransientInput{ - ID: "id1", - BuyerMSP: myOrg2Msp, - } - setReturnAssetOwnerInTransientMap(t, chaincodeStub, assetNewOwner) - //asset does not exist - setReturnPrivateDataInStub(t, chaincodeStub, nil) - err = assetTransferCC.TransferAsset(transactionContext) - require.EqualError(t, err, "id1 does not exist") -} - func TestTransferAssetNonMatchingAppraisalValue(t *testing.T) { transactionContext, chaincodeStub := prepMocksAsOrg1() assetTransferCC := chaincode.SmartContract{} @@ -329,6 +375,20 @@ func prepMocks(orgMSP, clientId string) (*mocks.TransactionContext, *mocks.Chain return transactionContext, chaincodeStub } +func setReturnAssetPrivateDetailsInTransientMap(t *testing.T, chaincodeStub *mocks.ChaincodeStub, assetPrivDetail *chaincode.AssetPrivateDetails) []byte { + assetOwnerBytes := []byte{} + if assetPrivDetail != nil { + var err error + assetOwnerBytes, err = json.Marshal(assetPrivDetail) + require.NoError(t, err) + } + assetPropMap := map[string][]byte{ + "asset_value": assetOwnerBytes, + } + chaincodeStub.GetTransientReturns(assetPropMap, nil) + return assetOwnerBytes +} + func setReturnAssetOwnerInTransientMap(t *testing.T, chaincodeStub *mocks.ChaincodeStub, assetOwner *assetTransferTransientInput) []byte { assetOwnerBytes := []byte{} if assetOwner != nil { @@ -358,136 +418,27 @@ func setReturnAssetPropsInTransientMap(t *testing.T, chaincodeStub *mocks.Chainc } func setReturnPrivateDataInStub(t *testing.T, chaincodeStub *mocks.ChaincodeStub, testAsset *chaincode.Asset) []byte { - assetBytes := []byte{} - if testAsset != nil { + if testAsset == nil { + chaincodeStub.GetPrivateDataReturns(nil, nil) + return nil + } else { var err error - assetBytes, err = json.Marshal(testAsset) + assetBytes, err := json.Marshal(testAsset) require.NoError(t, err) + chaincodeStub.GetPrivateDataReturns(assetBytes, nil) + return assetBytes } - chaincodeStub.GetPrivateDataReturns(assetBytes, nil) - return assetBytes } -/* -func TestReadAsset(t *testing.T) { - chaincodeStub := &mocks.ChaincodeStub{} - transactionContext := &mocks.TransactionContext{} - transactionContext.GetStubReturns(chaincodeStub) - - expectedAsset := &chaincode.Asset{ID: "asset1"} - bytes, err := json.Marshal(expectedAsset) - require.NoError(t, err) - - chaincodeStub.GetStateReturns(bytes, nil) - assetTransferCC := chaincode.SmartContract{} - asset, err := assetTransferCC.ReadAsset(transactionContext, "") - require.NoError(t, err) - require.Equal(t, expectedAsset, asset) - - chaincodeStub.GetStateReturns(nil, fmt.Errorf("unable to retrieve asset")) - _, err = assetTransferCC.ReadAsset(transactionContext, "") - require.EqualError(t, err, "failed to read from world state: unable to retrieve asset") - - chaincodeStub.GetStateReturns(nil, nil) - asset, err = assetTransferCC.ReadAsset(transactionContext, "asset1") - require.EqualError(t, err, "the asset asset1 does not exist") - require.Nil(t, asset) +func setReturnAssetPrivateDetailsInStub(t *testing.T, chaincodeStub *mocks.ChaincodeStub, testAsset *chaincode.AssetPrivateDetails) []byte { + if testAsset == nil { + chaincodeStub.GetPrivateDataReturns(nil, nil) + return nil + } else { + var err error + assetBytes, err := json.Marshal(testAsset) + require.NoError(t, err) + chaincodeStub.GetPrivateDataReturns(assetBytes, nil) + return assetBytes + } } - -func TestUpdateAsset(t *testing.T) { - chaincodeStub := &mocks.ChaincodeStub{} - transactionContext := &mocks.TransactionContext{} - transactionContext.GetStubReturns(chaincodeStub) - - expectedAsset := &chaincode.Asset{ID: "asset1"} - bytes, err := json.Marshal(expectedAsset) - require.NoError(t, err) - - chaincodeStub.GetStateReturns(bytes, nil) - assetTransferCC := chaincode.SmartContract{} - err = assetTransferCC.UpdateAsset(transactionContext, "", "", 0, "", 0) - require.NoError(t, err) - - chaincodeStub.GetStateReturns(nil, nil) - err = assetTransferCC.UpdateAsset(transactionContext, "asset1", "", 0, "", 0) - require.EqualError(t, err, "the asset asset1 does not exist") - - chaincodeStub.GetStateReturns(nil, fmt.Errorf("unable to retrieve asset")) - err = assetTransferCC.UpdateAsset(transactionContext, "asset1", "", 0, "", 0) - require.EqualError(t, err, "failed to read from world state: unable to retrieve asset") -} - -func TestDeleteAsset(t *testing.T) { - chaincodeStub := &mocks.ChaincodeStub{} - transactionContext := &mocks.TransactionContext{} - transactionContext.GetStubReturns(chaincodeStub) - - asset := &chaincode.Asset{ID: "asset1"} - bytes, err := json.Marshal(asset) - require.NoError(t, err) - - chaincodeStub.GetStateReturns(bytes, nil) - chaincodeStub.DelStateReturns(nil) - assetTransferCC := chaincode.SmartContract{} - err = assetTransferCC.DeleteAsset(transactionContext, "") - require.NoError(t, err) - - chaincodeStub.GetStateReturns(nil, nil) - err = assetTransferCC.DeleteAsset(transactionContext, "asset1") - require.EqualError(t, err, "the asset asset1 does not exist") - - chaincodeStub.GetStateReturns(nil, fmt.Errorf("unable to retrieve asset")) - err = assetTransferCC.DeleteAsset(transactionContext, "") - require.EqualError(t, err, "failed to read from world state: unable to retrieve asset") -} - -func TestTransferAsset(t *testing.T) { - chaincodeStub := &mocks.ChaincodeStub{} - transactionContext := &mocks.TransactionContext{} - transactionContext.GetStubReturns(chaincodeStub) - - asset := &chaincode.Asset{ID: "asset1"} - bytes, err := json.Marshal(asset) - require.NoError(t, err) - - chaincodeStub.GetStateReturns(bytes, nil) - assetTransferCC := chaincode.SmartContract{} - err = assetTransferCC.TransferAsset(transactionContext, "", "") - require.NoError(t, err) - - chaincodeStub.GetStateReturns(nil, fmt.Errorf("unable to retrieve asset")) - err = assetTransferCC.TransferAsset(transactionContext, "", "") - require.EqualError(t, err, "failed to read from world state: unable to retrieve asset") -} - -func TestGetAllAssets(t *testing.T) { - asset := &chaincode.Asset{ID: "asset1"} - bytes, err := json.Marshal(asset) - require.NoError(t, err) - - iterator := &mocks.StateQueryIterator{} - iterator.HasNextReturnsOnCall(0, true) - iterator.HasNextReturnsOnCall(1, false) - iterator.NextReturns(&queryresult.KV{Value: bytes}, nil) - - chaincodeStub := &mocks.ChaincodeStub{} - transactionContext := &mocks.TransactionContext{} - transactionContext.GetStubReturns(chaincodeStub) - - chaincodeStub.GetStateByRangeReturns(iterator, nil) - assetTransferCC := &chaincode.SmartContract{} - assets, err := assetTransferCC.GetAllAssets(transactionContext) - require.NoError(t, err) - require.Equal(t, []*chaincode.Asset{asset}, assets) - - iterator.HasNextReturns(true) - iterator.NextReturns(nil, fmt.Errorf("failed retrieving next item")) - assets, err = assetTransferCC.GetAllAssets(transactionContext) - require.EqualError(t, err, "failed retrieving next item") - require.Nil(t, assets) - - chaincodeStub.GetStateByRangeReturns(nil, fmt.Errorf("failed retrieving all assets")) - assets, err = assetTransferCC.GetAllAssets(transactionContext) - require.EqualError(t, err, "failed retrieving all assets") - require.Nil(t, assets) -}*/ From fe04cdcb65fc50d22fcb31b8a045e2ae12ee9e61 Mon Sep 17 00:00:00 2001 From: Sijo Cherian Date: Tue, 11 Aug 2020 16:06:00 -0400 Subject: [PATCH 3/3] Improved README Signed-off-by: Sijo Cherian --- .../chaincode-go/README.md | 37 ++++++++++--------- 1 file changed, 20 insertions(+), 17 deletions(-) diff --git a/asset-transfer-private-data/chaincode-go/README.md b/asset-transfer-private-data/chaincode-go/README.md index f2442a24..b6eebfef 100644 --- a/asset-transfer-private-data/chaincode-go/README.md +++ b/asset-transfer-private-data/chaincode-go/README.md @@ -38,7 +38,11 @@ You can use the test network script to deploy the private data smart contract to ./network.sh deployCC -ccn private -ccep "OR('Org1MSP.peer','Org2MSP.peer')" -cccg ../asset-transfer-private-data/chaincode-go/collections_config.json ``` -Note that we are using the `-ccep` flag to deploy the private data smart contract with a chaincode endorsement policy of `"OR('Org1MSP.peer','Org2MSP.peer')"`. This allows Org1 and Org2 to create an asset without receiving an endorsement from the other organization. The command also uses the `-cccg` flag to provide the path to the collection configuration file. +The above command deploys the go chaincode with short name `private`, and specifies the private data collection configuration from file `collections_config.json` using `-cccg` flag. +Note that we are using the `-ccep` flag to deploy the private data smart contract with a chaincode endorsement policy of `"OR('Org1MSP.peer','Org2MSP.peer')"`. This allows Org1 and Org2 to create an asset without receiving an endorsement from the other organization. + +Now you are ready to call the deployed smart contract. +Note that this sample workflow steps below, can also be executed via the application at `asset-transfer-private-data/application-javascript` folder, in fewer steps. To execute the workflow via CLI, read on. ## Register identities @@ -147,7 +151,7 @@ The query will return the value of the asset: ### Buyer from Org2 agrees to buy the asset -The buyer identity from Org2 is interested in buying the asset. Set the following environment variables to operate as the buyer: +The buyer identity from Org2 is interested in buying the asset. In a new terminal, set the following environment variables to operate as the buyer: ``` export CORE_PEER_LOCALMSPID="Org2MSP" @@ -156,20 +160,17 @@ export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org2.e export CORE_PEER_ADDRESS=localhost:9051 ``` -Now that we are operating as a member of Org2, we can demonstrate that the asset appraisal is not stored on the Org2 peer: +Now that we are operating as a member of Org2, we can demonstrate that the asset appraisal is not stored in Org2MSPPrivateCollection, on the Org2 peer: ``` peer chaincode query -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C mychannel -n private -c '{"function":"ReadAssetPrivateDetails","Args":["Org2MSPPrivateCollection","asset1"]}' ``` -The buyer only finds that asset1 does exist in the Org1 collection: -``` -Error: endorsement failure during invoke. response: status:500 message:"appraisal value for asset1 does not exist in private data collection" -``` +The empty response shows that, the asset1 private details, does not exist in buyer private collection. -Nor is a member of Org2 able to read the Org1 private data collection: +Nor can a member of Org2, able to read the Org1 private data collection: ``` peer chaincode query -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C mychannel -n private -c '{"function":"ReadAssetPrivateDetails","Args":["Org1MSPPrivateCollection","asset1"]}' ``` -By setting `"memberOnlyRead": true` in the collection configuration file, we specify that only members of Org1 can read data from the collection. A member who tries to read the collection would only get the following response. +By setting `"memberOnlyRead": true` in the collection configuration file, we specify that only members of Org1 can read data from the collection. A Org2 member who tries to read the collection would only get the following response. ``` Error: endorsement failure during query. response: status:500 message:"failed to read from asset details GET_STATE failed: transaction ID: 10d39a7d0b340455a19ca4198146702d68d884d41a0e60936f1599c1ddb9c99d: tx creator does not have read access permission on privatedata in chaincodeName:private collectionName: Org1MSPPrivateCollection" ``` @@ -189,9 +190,9 @@ The invoke will return the following value: {"assetID":"asset1","appraisedValue":100} ``` -## Transfer the asset to Org2 +## Org1 member transfers the asset to Org2 -Now that buyer has agreed to buy the asset for appraised value, the owner from Org1 can transfer the asset to Org2. Set the following environment variables to operate as Org1: +Now that buyer has agreed to buy the asset for appraised value, the owner from Org1 can transfer the asset to Org2. In the first terminal (with the following environment variables to operate as Org1): ``` export CORE_PEER_LOCALMSPID="Org1MSP" export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/org1.example.com/users/owner@org1.example.com/msp @@ -199,7 +200,12 @@ export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org1.e export CORE_PEER_ADDRESS=localhost:7051 ``` -To transfer the asset, the owner needs to pass the MSP ID of new asset owner. The transfer function will read the client ID of the interested buyer from the transfer agreement. +Now that buyer has agreed to buy the asset for appraised value, the owner from Org1 can read the data added by `AgreeToTransfer` to see buyer identity. +``` +peer chaincode query -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C mychannel -n private -c '{"function":"ReadTransferAgreement","Args":["asset1"]}' +``` + +The owner from Org1 can now transfer the asset to Org2. To transfer the asset, the owner needs to pass the MSP ID of new asset owner Org. The transfer function will read the client ID of the interested buyer user from the transfer agreement. ``` export ASSET_OWNER=$(echo -n "{\"assetID\":\"asset1\",\"buyerMSP\":\"Org2MSP\"}" | base64 | tr -d \\n) ``` @@ -209,7 +215,7 @@ The owner of the asset needs to initiate the transfer. ``` peer chaincode invoke -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C mychannel -n private -c '{"function":"TransferAsset","Args":[]}' --transient "{\"asset_owner\":\"$ASSET_OWNER\"}" --peerAddresses localhost:7051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt ``` -You can query `asset1` to see the results of the transfer. +You can ReadAsset `asset1` to see the results of the transfer. ``` peer chaincode query -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C mychannel -n private -c '{"function":"ReadAsset","Args":["asset1"]}' ``` @@ -229,10 +235,7 @@ You can also confirm that transfer removed the private details from the Org1 col ``` peer chaincode query -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C mychannel -n private -c '{"function":"ReadAssetPrivateDetails","Args":["Org1MSPPrivateCollection","asset1"]}' ``` -Your query will return the following result: -``` -Error: endorsement failure during query. response: status:500 message:"appraisal value for asset1 does not exist in private data collection" -``` +Your query will return empty result, since the asset private data is removed from the Org1 private data collection. ## Clean up