github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/core/chaincode/lifecycle/ledger_shim_test.go (about)

     1  /*
     2  Copyright hechain. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package lifecycle_test
     8  
     9  import (
    10  	"fmt"
    11  
    12  	. "github.com/onsi/ginkgo"
    13  	. "github.com/onsi/gomega"
    14  
    15  	"github.com/hechain20/hechain/core/chaincode/lifecycle"
    16  	"github.com/hechain20/hechain/core/chaincode/lifecycle/mock"
    17  	"github.com/hyperledger/fabric-protos-go/ledger/queryresult"
    18  )
    19  
    20  var _ = Describe("LedgerShims", func() {
    21  	var fakeStub *mock.ChaincodeStub
    22  
    23  	BeforeEach(func() {
    24  		fakeStub = &mock.ChaincodeStub{}
    25  	})
    26  
    27  	Describe("ChaincodePublicLedgerShim", func() {
    28  		var (
    29  			cls          *lifecycle.ChaincodePublicLedgerShim
    30  			fakeIterator *mock.StateIterator
    31  		)
    32  
    33  		BeforeEach(func() {
    34  			fakeIterator = &mock.StateIterator{}
    35  			fakeIterator.HasNextReturnsOnCall(0, true)
    36  			fakeIterator.HasNextReturnsOnCall(1, false)
    37  			fakeIterator.NextReturns(&queryresult.KV{
    38  				Key:   "fake-prefix-key",
    39  				Value: []byte("fake-value"),
    40  			}, nil)
    41  
    42  			fakeStub.GetStateByRangeReturns(fakeIterator, nil)
    43  
    44  			cls = &lifecycle.ChaincodePublicLedgerShim{
    45  				ChaincodeStubInterface: fakeStub,
    46  			}
    47  		})
    48  
    49  		Describe("GetStateRange", func() {
    50  			It("passes through to the stub", func() {
    51  				res, err := cls.GetStateRange("fake-prefix")
    52  				Expect(err).NotTo(HaveOccurred())
    53  				Expect(res).To(Equal(map[string][]byte{
    54  					"fake-prefix-key": []byte("fake-value"),
    55  				}))
    56  				Expect(fakeStub.GetStateByRangeCallCount()).To(Equal(1))
    57  				start, end := fakeStub.GetStateByRangeArgsForCall(0)
    58  				Expect(start).To(Equal("fake-prefix"))
    59  				Expect(end).To(Equal("fake-prefix\x7f"))
    60  			})
    61  
    62  			Context("when the iterator cannot be retrieved", func() {
    63  				BeforeEach(func() {
    64  					fakeStub.GetStateByRangeReturns(nil, fmt.Errorf("error-by-range"))
    65  				})
    66  
    67  				It("wraps and returns the error", func() {
    68  					_, err := cls.GetStateRange("fake-prefix")
    69  					Expect(err).To(MatchError("could not get state iterator: error-by-range"))
    70  				})
    71  			})
    72  
    73  			Context("when the iterator fails to iterate", func() {
    74  				BeforeEach(func() {
    75  					fakeIterator.NextReturns(nil, fmt.Errorf("fake-iterator-error"))
    76  				})
    77  
    78  				It("wraps and returns the error", func() {
    79  					_, err := cls.GetStateRange("fake-prefix")
    80  					Expect(err).To(MatchError("could not iterate over range: fake-iterator-error"))
    81  				})
    82  			})
    83  		})
    84  	})
    85  
    86  	Describe("ChaincodePrivateLedgerShim", func() {
    87  		var cls *lifecycle.ChaincodePrivateLedgerShim
    88  
    89  		BeforeEach(func() {
    90  			cls = &lifecycle.ChaincodePrivateLedgerShim{
    91  				Stub:       fakeStub,
    92  				Collection: "fake-collection",
    93  			}
    94  		})
    95  
    96  		Describe("GetStateRange", func() {
    97  			BeforeEach(func() {
    98  				fakeStub.GetPrivateDataByRangeReturns(&mock.StateIterator{}, nil)
    99  			})
   100  
   101  			It("passes through to the stub private function", func() {
   102  				res, err := cls.GetStateRange("fake-key")
   103  				Expect(err).NotTo(HaveOccurred())
   104  				Expect(res).To(BeEmpty())
   105  
   106  				Expect(fakeStub.GetPrivateDataByRangeCallCount()).To(Equal(1))
   107  				collection, start, end := fakeStub.GetPrivateDataByRangeArgsForCall(0)
   108  				Expect(collection).To(Equal("fake-collection"))
   109  				Expect(start).To(Equal("fake-key"))
   110  				Expect(end).To(Equal("fake-key\x7f"))
   111  			})
   112  
   113  			Context("when getting the state iterator fails", func() {
   114  				BeforeEach(func() {
   115  					fakeStub.GetPrivateDataByRangeReturns(nil, fmt.Errorf("fake-range-error"))
   116  				})
   117  
   118  				It("wraps and returns the error", func() {
   119  					_, err := cls.GetStateRange("fake-key")
   120  					Expect(err).To(MatchError("could not get state iterator: fake-range-error"))
   121  				})
   122  			})
   123  		})
   124  
   125  		Describe("GetState", func() {
   126  			BeforeEach(func() {
   127  				fakeStub.GetPrivateDataReturns([]byte("fake-value"), fmt.Errorf("fake-getstate-error"))
   128  			})
   129  
   130  			It("passes through to the stub private data implementation", func() {
   131  				res, err := cls.GetState("fake-key")
   132  				Expect(res).To(Equal([]byte("fake-value")))
   133  				Expect(err).To(MatchError(fmt.Errorf("fake-getstate-error")))
   134  				Expect(fakeStub.GetPrivateDataCallCount()).To(Equal(1))
   135  				collection, key := fakeStub.GetPrivateDataArgsForCall(0)
   136  				Expect(collection).To(Equal("fake-collection"))
   137  				Expect(key).To(Equal("fake-key"))
   138  			})
   139  		})
   140  
   141  		Describe("GetStateHash", func() {
   142  			BeforeEach(func() {
   143  				fakeStub.GetPrivateDataHashReturns([]byte("fake-hash"), fmt.Errorf("fake-error"))
   144  			})
   145  
   146  			It("passes through to the chaincode stub", func() {
   147  				res, err := cls.GetStateHash("fake-key")
   148  				Expect(res).To(Equal([]byte("fake-hash")))
   149  				Expect(err).To(MatchError("fake-error"))
   150  				Expect(fakeStub.GetPrivateDataHashCallCount()).To(Equal(1))
   151  				collection, key := fakeStub.GetPrivateDataHashArgsForCall(0)
   152  				Expect(collection).To(Equal("fake-collection"))
   153  				Expect(key).To(Equal("fake-key"))
   154  			})
   155  		})
   156  
   157  		Describe("PutState", func() {
   158  			BeforeEach(func() {
   159  				fakeStub.PutPrivateDataReturns(fmt.Errorf("fake-putstate-error"))
   160  			})
   161  
   162  			It("passes through to the stub private data implementation", func() {
   163  				err := cls.PutState("fake-key", []byte("fake-value"))
   164  				Expect(err).To(MatchError(fmt.Errorf("fake-putstate-error")))
   165  				Expect(fakeStub.PutPrivateDataCallCount()).To(Equal(1))
   166  				collection, key, value := fakeStub.PutPrivateDataArgsForCall(0)
   167  				Expect(collection).To(Equal("fake-collection"))
   168  				Expect(key).To(Equal("fake-key"))
   169  				Expect(value).To(Equal([]byte("fake-value")))
   170  			})
   171  		})
   172  
   173  		Describe("DelState", func() {
   174  			BeforeEach(func() {
   175  				fakeStub.DelPrivateDataReturns(fmt.Errorf("fake-delstate-error"))
   176  			})
   177  
   178  			It("passes through to the stub private data implementation", func() {
   179  				err := cls.DelState("fake-key")
   180  				Expect(err).To(MatchError(fmt.Errorf("fake-delstate-error")))
   181  				Expect(fakeStub.DelPrivateDataCallCount()).To(Equal(1))
   182  				collection, key := fakeStub.DelPrivateDataArgsForCall(0)
   183  				Expect(collection).To(Equal("fake-collection"))
   184  				Expect(key).To(Equal("fake-key"))
   185  			})
   186  		})
   187  	})
   188  
   189  	Describe("SimpleQueryExecutorShim", func() {
   190  		var (
   191  			sqes                    *lifecycle.SimpleQueryExecutorShim
   192  			fakeSimpleQueryExecutor *mock.SimpleQueryExecutor
   193  		)
   194  
   195  		BeforeEach(func() {
   196  			fakeSimpleQueryExecutor = &mock.SimpleQueryExecutor{}
   197  			sqes = &lifecycle.SimpleQueryExecutorShim{
   198  				Namespace:           "cc-namespace",
   199  				SimpleQueryExecutor: fakeSimpleQueryExecutor,
   200  			}
   201  		})
   202  
   203  		Describe("GetState", func() {
   204  			BeforeEach(func() {
   205  				fakeSimpleQueryExecutor.GetStateReturns([]byte("fake-state"), fmt.Errorf("fake-error"))
   206  			})
   207  
   208  			It("passes through to the query executor", func() {
   209  				res, err := sqes.GetState("fake-prefix")
   210  				Expect(res).To(Equal([]byte("fake-state")))
   211  				Expect(err).To(MatchError("fake-error"))
   212  			})
   213  		})
   214  
   215  		Describe("GetStateRange", func() {
   216  			var resItr *mock.ResultsIterator
   217  
   218  			BeforeEach(func() {
   219  				resItr = &mock.ResultsIterator{}
   220  				resItr.NextReturnsOnCall(0, &queryresult.KV{
   221  					Key:   "fake-key",
   222  					Value: []byte("key-value"),
   223  				}, nil)
   224  				fakeSimpleQueryExecutor.GetStateRangeScanIteratorReturns(resItr, nil)
   225  			})
   226  
   227  			It("passes through to the query executor", func() {
   228  				res, err := sqes.GetStateRange("fake-key")
   229  				Expect(err).NotTo(HaveOccurred())
   230  				Expect(res).To(Equal(map[string][]byte{
   231  					"fake-key": []byte("key-value"),
   232  				}))
   233  
   234  				Expect(fakeSimpleQueryExecutor.GetStateRangeScanIteratorCallCount()).To(Equal(1))
   235  				namespace, start, end := fakeSimpleQueryExecutor.GetStateRangeScanIteratorArgsForCall(0)
   236  				Expect(namespace).To(Equal("cc-namespace"))
   237  				Expect(start).To(Equal("fake-key"))
   238  				Expect(end).To(Equal("fake-key\x7f"))
   239  			})
   240  
   241  			Context("when the result iterator returns an error", func() {
   242  				BeforeEach(func() {
   243  					resItr.NextReturns(nil, fmt.Errorf("fake-error"))
   244  				})
   245  
   246  				It("returns the error", func() {
   247  					_, err := sqes.GetStateRange("fake-key")
   248  					Expect(err).To(MatchError("could not iterate over range: fake-error"))
   249  				})
   250  			})
   251  
   252  			Context("when getting the state iterator fails", func() {
   253  				BeforeEach(func() {
   254  					fakeSimpleQueryExecutor.GetStateRangeScanIteratorReturns(nil, fmt.Errorf("fake-range-error"))
   255  				})
   256  
   257  				It("wraps and returns the error", func() {
   258  					_, err := sqes.GetStateRange("fake-key")
   259  					Expect(err).To(MatchError("could not get state iterator: fake-range-error"))
   260  				})
   261  			})
   262  		})
   263  	})
   264  
   265  	Describe("PrivateQueryExecutorShim", func() {
   266  		var (
   267  			pqes                    *lifecycle.PrivateQueryExecutorShim
   268  			fakeSimpleQueryExecutor *mock.SimpleQueryExecutor
   269  		)
   270  
   271  		BeforeEach(func() {
   272  			fakeSimpleQueryExecutor = &mock.SimpleQueryExecutor{}
   273  			pqes = &lifecycle.PrivateQueryExecutorShim{
   274  				Namespace:  "cc-namespace",
   275  				Collection: "collection",
   276  				State:      fakeSimpleQueryExecutor,
   277  			}
   278  			fakeSimpleQueryExecutor.GetPrivateDataHashReturns([]byte("hash"), fmt.Errorf("fake-error"))
   279  		})
   280  
   281  		It("passes through to the underlying implementation", func() {
   282  			data, err := pqes.GetStateHash("key")
   283  			Expect(data).To(Equal([]byte("hash")))
   284  			Expect(err).To(MatchError("fake-error"))
   285  			Expect(fakeSimpleQueryExecutor.GetPrivateDataHashCallCount()).To(Equal(1))
   286  			namespace, collection, key := fakeSimpleQueryExecutor.GetPrivateDataHashArgsForCall(0)
   287  			Expect(namespace).To(Equal("cc-namespace"))
   288  			Expect(collection).To(Equal("collection"))
   289  			Expect(key).To(Equal("key"))
   290  		})
   291  	})
   292  })