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 })