github.com/tenywen/fabric@v1.0.0-beta.0.20170620030522-a5b1ed380643/core/ledger/kvledger/txmgmt/statedb/commontests/test_common.go (about) 1 /* 2 Copyright IBM Corp. 2016 All Rights Reserved. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package commontests 18 19 import ( 20 "strings" 21 "testing" 22 23 "github.com/hyperledger/fabric/common/ledger/testutil" 24 "github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/statedb" 25 "github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/version" 26 ) 27 28 // TestGetStateMultipleKeys tests read for given multiple keys 29 func TestGetStateMultipleKeys(t *testing.T, dbProvider statedb.VersionedDBProvider) { 30 db, err := dbProvider.GetDBHandle("testgetmultiplekeys") 31 testutil.AssertNoError(t, err, "") 32 33 // Test that savepoint is nil for a new state db 34 sp, err := db.GetLatestSavePoint() 35 testutil.AssertNoError(t, err, "Error upon GetLatestSavePoint()") 36 testutil.AssertNil(t, sp) 37 38 batch := statedb.NewUpdateBatch() 39 expectedValues := make([]*statedb.VersionedValue, 2) 40 vv1 := statedb.VersionedValue{Value: []byte("value1"), Version: version.NewHeight(1, 1)} 41 expectedValues[0] = &vv1 42 vv2 := statedb.VersionedValue{Value: []byte("value2"), Version: version.NewHeight(1, 2)} 43 expectedValues[1] = &vv2 44 vv3 := statedb.VersionedValue{Value: []byte("value3"), Version: version.NewHeight(1, 3)} 45 vv4 := statedb.VersionedValue{Value: []byte{}, Version: version.NewHeight(1, 4)} 46 batch.Put("ns1", "key1", vv1.Value, vv1.Version) 47 batch.Put("ns1", "key2", vv2.Value, vv2.Version) 48 batch.Put("ns2", "key3", vv3.Value, vv3.Version) 49 batch.Put("ns2", "key4", vv4.Value, vv4.Version) 50 savePoint := version.NewHeight(2, 5) 51 db.ApplyUpdates(batch, savePoint) 52 53 actualValues, _ := db.GetStateMultipleKeys("ns1", []string{"key1", "key2"}) 54 testutil.AssertEquals(t, actualValues, expectedValues) 55 } 56 57 // TestBasicRW tests basic read-write 58 func TestBasicRW(t *testing.T, dbProvider statedb.VersionedDBProvider) { 59 db, err := dbProvider.GetDBHandle("testbasicrw") 60 testutil.AssertNoError(t, err, "") 61 62 // Test that savepoint is nil for a new state db 63 sp, err := db.GetLatestSavePoint() 64 testutil.AssertNoError(t, err, "Error upon GetLatestSavePoint()") 65 testutil.AssertNil(t, sp) 66 67 // Test retrieval of non-existent key - returns nil rather than error 68 // For more details see https://github.com/hyperledger-archives/fabric/issues/936. 69 val, err := db.GetState("ns", "key1") 70 testutil.AssertNoError(t, err, "Should receive nil rather than error upon reading non existent key") 71 testutil.AssertNil(t, val) 72 73 batch := statedb.NewUpdateBatch() 74 vv1 := statedb.VersionedValue{Value: []byte("value1"), Version: version.NewHeight(1, 1)} 75 vv2 := statedb.VersionedValue{Value: []byte("value2"), Version: version.NewHeight(1, 2)} 76 vv3 := statedb.VersionedValue{Value: []byte("value3"), Version: version.NewHeight(1, 3)} 77 vv4 := statedb.VersionedValue{Value: []byte{}, Version: version.NewHeight(1, 4)} 78 batch.Put("ns1", "key1", vv1.Value, vv1.Version) 79 batch.Put("ns1", "key2", vv2.Value, vv2.Version) 80 batch.Put("ns2", "key3", vv3.Value, vv3.Version) 81 batch.Put("ns2", "key4", vv4.Value, vv4.Version) 82 savePoint := version.NewHeight(2, 5) 83 db.ApplyUpdates(batch, savePoint) 84 85 vv, _ := db.GetState("ns1", "key1") 86 testutil.AssertEquals(t, vv, &vv1) 87 88 vv, _ = db.GetState("ns2", "key4") 89 testutil.AssertEquals(t, vv, &vv4) 90 91 sp, err = db.GetLatestSavePoint() 92 testutil.AssertNoError(t, err, "") 93 testutil.AssertEquals(t, sp, savePoint) 94 } 95 96 // TestMultiDBBasicRW tests basic read-write on multiple dbs 97 func TestMultiDBBasicRW(t *testing.T, dbProvider statedb.VersionedDBProvider) { 98 db1, err := dbProvider.GetDBHandle("testmultidbbasicrw") 99 testutil.AssertNoError(t, err, "") 100 101 db2, err := dbProvider.GetDBHandle("testmultidbbasicrw2") 102 testutil.AssertNoError(t, err, "") 103 104 batch1 := statedb.NewUpdateBatch() 105 vv1 := statedb.VersionedValue{Value: []byte("value1_db1"), Version: version.NewHeight(1, 1)} 106 vv2 := statedb.VersionedValue{Value: []byte("value2_db1"), Version: version.NewHeight(1, 2)} 107 batch1.Put("ns1", "key1", vv1.Value, vv1.Version) 108 batch1.Put("ns1", "key2", vv2.Value, vv2.Version) 109 savePoint1 := version.NewHeight(1, 2) 110 db1.ApplyUpdates(batch1, savePoint1) 111 112 batch2 := statedb.NewUpdateBatch() 113 vv3 := statedb.VersionedValue{Value: []byte("value1_db2"), Version: version.NewHeight(1, 4)} 114 vv4 := statedb.VersionedValue{Value: []byte("value2_db2"), Version: version.NewHeight(1, 5)} 115 batch2.Put("ns1", "key1", vv3.Value, vv3.Version) 116 batch2.Put("ns1", "key2", vv4.Value, vv4.Version) 117 savePoint2 := version.NewHeight(1, 5) 118 db2.ApplyUpdates(batch2, savePoint2) 119 120 vv, _ := db1.GetState("ns1", "key1") 121 testutil.AssertEquals(t, vv, &vv1) 122 123 sp, err := db1.GetLatestSavePoint() 124 testutil.AssertNoError(t, err, "") 125 testutil.AssertEquals(t, sp, savePoint1) 126 127 vv, _ = db2.GetState("ns1", "key1") 128 testutil.AssertEquals(t, vv, &vv3) 129 130 sp, err = db2.GetLatestSavePoint() 131 testutil.AssertNoError(t, err, "") 132 testutil.AssertEquals(t, sp, savePoint2) 133 } 134 135 // TestDeletes tests deteles 136 func TestDeletes(t *testing.T, dbProvider statedb.VersionedDBProvider) { 137 db, err := dbProvider.GetDBHandle("testdeletes") 138 testutil.AssertNoError(t, err, "") 139 140 batch := statedb.NewUpdateBatch() 141 vv1 := statedb.VersionedValue{Value: []byte("value1"), Version: version.NewHeight(1, 1)} 142 vv2 := statedb.VersionedValue{Value: []byte("value2"), Version: version.NewHeight(1, 2)} 143 vv3 := statedb.VersionedValue{Value: []byte("value1"), Version: version.NewHeight(1, 3)} 144 vv4 := statedb.VersionedValue{Value: []byte("value2"), Version: version.NewHeight(1, 4)} 145 146 batch.Put("ns", "key1", vv1.Value, vv1.Version) 147 batch.Put("ns", "key2", vv2.Value, vv2.Version) 148 batch.Put("ns", "key3", vv2.Value, vv3.Version) 149 batch.Put("ns", "key4", vv2.Value, vv4.Version) 150 batch.Delete("ns", "key3", version.NewHeight(1, 5)) 151 savePoint := version.NewHeight(1, 5) 152 err = db.ApplyUpdates(batch, savePoint) 153 testutil.AssertNoError(t, err, "") 154 vv, _ := db.GetState("ns", "key2") 155 testutil.AssertEquals(t, vv, &vv2) 156 157 vv, err = db.GetState("ns", "key3") 158 testutil.AssertNoError(t, err, "") 159 testutil.AssertNil(t, vv) 160 161 batch = statedb.NewUpdateBatch() 162 batch.Delete("ns", "key2", version.NewHeight(1, 6)) 163 err = db.ApplyUpdates(batch, savePoint) 164 testutil.AssertNoError(t, err, "") 165 vv, err = db.GetState("ns", "key2") 166 testutil.AssertNoError(t, err, "") 167 testutil.AssertNil(t, vv) 168 } 169 170 // TestIterator tests the iterator 171 func TestIterator(t *testing.T, dbProvider statedb.VersionedDBProvider) { 172 db, err := dbProvider.GetDBHandle("testiterator") 173 testutil.AssertNoError(t, err, "") 174 db.Open() 175 defer db.Close() 176 batch := statedb.NewUpdateBatch() 177 batch.Put("ns1", "key1", []byte("value1"), version.NewHeight(1, 1)) 178 batch.Put("ns1", "key2", []byte("value2"), version.NewHeight(1, 2)) 179 batch.Put("ns1", "key3", []byte("value3"), version.NewHeight(1, 3)) 180 batch.Put("ns1", "key4", []byte("value4"), version.NewHeight(1, 4)) 181 batch.Put("ns2", "key5", []byte("value5"), version.NewHeight(1, 5)) 182 batch.Put("ns2", "key6", []byte("value6"), version.NewHeight(1, 6)) 183 batch.Put("ns3", "key7", []byte("value7"), version.NewHeight(1, 7)) 184 savePoint := version.NewHeight(2, 5) 185 db.ApplyUpdates(batch, savePoint) 186 187 itr1, _ := db.GetStateRangeScanIterator("ns1", "key1", "") 188 testItr(t, itr1, []string{"key1", "key2", "key3", "key4"}) 189 190 itr2, _ := db.GetStateRangeScanIterator("ns1", "key2", "key3") 191 testItr(t, itr2, []string{"key2"}) 192 193 itr3, _ := db.GetStateRangeScanIterator("ns1", "", "") 194 testItr(t, itr3, []string{"key1", "key2", "key3", "key4"}) 195 196 itr4, _ := db.GetStateRangeScanIterator("ns2", "", "") 197 testItr(t, itr4, []string{"key5", "key6"}) 198 } 199 200 func testItr(t *testing.T, itr statedb.ResultsIterator, expectedKeys []string) { 201 defer itr.Close() 202 for _, expectedKey := range expectedKeys { 203 queryResult, _ := itr.Next() 204 vkv := queryResult.(*statedb.VersionedKV) 205 key := vkv.Key 206 testutil.AssertEquals(t, key, expectedKey) 207 } 208 last, err := itr.Next() 209 testutil.AssertNoError(t, err, "") 210 testutil.AssertNil(t, last) 211 } 212 213 // TestQuery tests queries 214 func TestQuery(t *testing.T, dbProvider statedb.VersionedDBProvider) { 215 db, err := dbProvider.GetDBHandle("testquery") 216 testutil.AssertNoError(t, err, "") 217 db.Open() 218 defer db.Close() 219 batch := statedb.NewUpdateBatch() 220 jsonValue1 := "{\"asset_name\": \"marble1\",\"color\": \"blue\",\"size\": 1,\"owner\": \"tom\"}" 221 batch.Put("ns1", "key1", []byte(jsonValue1), version.NewHeight(1, 1)) 222 jsonValue2 := "{\"asset_name\": \"marble2\",\"color\": \"blue\",\"size\": 2,\"owner\": \"jerry\"}" 223 batch.Put("ns1", "key2", []byte(jsonValue2), version.NewHeight(1, 2)) 224 jsonValue3 := "{\"asset_name\": \"marble3\",\"color\": \"blue\",\"size\": 3,\"owner\": \"fred\"}" 225 batch.Put("ns1", "key3", []byte(jsonValue3), version.NewHeight(1, 3)) 226 jsonValue4 := "{\"asset_name\": \"marble4\",\"color\": \"blue\",\"size\": 4,\"owner\": \"martha\"}" 227 batch.Put("ns1", "key4", []byte(jsonValue4), version.NewHeight(1, 4)) 228 jsonValue5 := "{\"asset_name\": \"marble5\",\"color\": \"blue\",\"size\": 5,\"owner\": \"fred\"}" 229 batch.Put("ns1", "key5", []byte(jsonValue5), version.NewHeight(1, 5)) 230 jsonValue6 := "{\"asset_name\": \"marble6\",\"color\": \"blue\",\"size\": 6,\"owner\": \"elaine\"}" 231 batch.Put("ns1", "key6", []byte(jsonValue6), version.NewHeight(1, 6)) 232 jsonValue7 := "{\"asset_name\": \"marble7\",\"color\": \"blue\",\"size\": 7,\"owner\": \"fred\"}" 233 batch.Put("ns1", "key7", []byte(jsonValue7), version.NewHeight(1, 7)) 234 jsonValue8 := "{\"asset_name\": \"marble8\",\"color\": \"blue\",\"size\": 8,\"owner\": \"elaine\"}" 235 batch.Put("ns1", "key8", []byte(jsonValue8), version.NewHeight(1, 8)) 236 jsonValue9 := "{\"asset_name\": \"marble9\",\"color\": \"green\",\"size\": 9,\"owner\": \"fred\"}" 237 batch.Put("ns1", "key9", []byte(jsonValue9), version.NewHeight(1, 9)) 238 jsonValue10 := "{\"asset_name\": \"marble10\",\"color\": \"green\",\"size\": 10,\"owner\": \"mary\"}" 239 batch.Put("ns1", "key10", []byte(jsonValue10), version.NewHeight(1, 10)) 240 jsonValue11 := "{\"asset_name\": \"marble11\",\"color\": \"cyan\",\"size\": 1000007,\"owner\": \"joe\"}" 241 batch.Put("ns1", "key11", []byte(jsonValue11), version.NewHeight(1, 11)) 242 243 //add keys for a separate namespace 244 batch.Put("ns2", "key1", []byte(jsonValue1), version.NewHeight(1, 12)) 245 batch.Put("ns2", "key2", []byte(jsonValue2), version.NewHeight(1, 13)) 246 batch.Put("ns2", "key3", []byte(jsonValue3), version.NewHeight(1, 14)) 247 batch.Put("ns2", "key4", []byte(jsonValue4), version.NewHeight(1, 15)) 248 batch.Put("ns2", "key5", []byte(jsonValue5), version.NewHeight(1, 16)) 249 batch.Put("ns2", "key6", []byte(jsonValue6), version.NewHeight(1, 17)) 250 batch.Put("ns2", "key7", []byte(jsonValue7), version.NewHeight(1, 18)) 251 batch.Put("ns2", "key8", []byte(jsonValue8), version.NewHeight(1, 19)) 252 batch.Put("ns2", "key9", []byte(jsonValue9), version.NewHeight(1, 20)) 253 batch.Put("ns2", "key10", []byte(jsonValue10), version.NewHeight(1, 21)) 254 255 savePoint := version.NewHeight(2, 22) 256 db.ApplyUpdates(batch, savePoint) 257 258 // query for owner=jerry, use namespace "ns1" 259 itr, err := db.ExecuteQuery("ns1", "{\"selector\":{\"owner\":\"jerry\"}}") 260 testutil.AssertNoError(t, err, "") 261 262 // verify one jerry result 263 queryResult1, err := itr.Next() 264 testutil.AssertNoError(t, err, "") 265 testutil.AssertNotNil(t, queryResult1) 266 versionedQueryRecord := queryResult1.(*statedb.VersionedKV) 267 stringRecord := string(versionedQueryRecord.Value) 268 bFoundRecord := strings.Contains(stringRecord, "jerry") 269 testutil.AssertEquals(t, bFoundRecord, true) 270 271 // verify no more results 272 queryResult2, err := itr.Next() 273 testutil.AssertNoError(t, err, "") 274 testutil.AssertNil(t, queryResult2) 275 276 // query for owner=jerry, use namespace "ns2" 277 itr, err = db.ExecuteQuery("ns2", "{\"selector\":{\"owner\":\"jerry\"}}") 278 testutil.AssertNoError(t, err, "") 279 280 // verify one jerry result 281 queryResult1, err = itr.Next() 282 testutil.AssertNoError(t, err, "") 283 testutil.AssertNotNil(t, queryResult1) 284 versionedQueryRecord = queryResult1.(*statedb.VersionedKV) 285 stringRecord = string(versionedQueryRecord.Value) 286 bFoundRecord = strings.Contains(stringRecord, "jerry") 287 testutil.AssertEquals(t, bFoundRecord, true) 288 289 // verify no more results 290 queryResult2, err = itr.Next() 291 testutil.AssertNoError(t, err, "") 292 testutil.AssertNil(t, queryResult2) 293 294 // query for owner=jerry, use namespace "ns3" 295 itr, err = db.ExecuteQuery("ns3", "{\"selector\":{\"owner\":\"jerry\"}}") 296 testutil.AssertNoError(t, err, "") 297 298 // verify results - should be no records 299 queryResult1, err = itr.Next() 300 testutil.AssertNoError(t, err, "") 301 testutil.AssertNil(t, queryResult1) 302 303 // query using bad query string 304 itr, err = db.ExecuteQuery("ns1", "this is an invalid query string") 305 testutil.AssertError(t, err, "Should have received an error for invalid query string") 306 307 // query returns 0 records 308 itr, err = db.ExecuteQuery("ns1", "{\"selector\":{\"owner\":\"not_a_valid_name\"}}") 309 testutil.AssertNoError(t, err, "") 310 311 // verify no results 312 queryResult3, err := itr.Next() 313 testutil.AssertNoError(t, err, "") 314 testutil.AssertNil(t, queryResult3) 315 316 // query with fields, namespace "ns1" 317 itr, err = db.ExecuteQuery("ns1", "{\"selector\":{\"owner\":\"jerry\"},\"fields\": [\"owner\", \"asset_name\", \"color\", \"size\"]}") 318 testutil.AssertNoError(t, err, "") 319 320 // verify one jerry result 321 queryResult1, err = itr.Next() 322 testutil.AssertNoError(t, err, "") 323 testutil.AssertNotNil(t, queryResult1) 324 versionedQueryRecord = queryResult1.(*statedb.VersionedKV) 325 stringRecord = string(versionedQueryRecord.Value) 326 bFoundRecord = strings.Contains(stringRecord, "jerry") 327 testutil.AssertEquals(t, bFoundRecord, true) 328 329 // verify no more results 330 queryResult2, err = itr.Next() 331 testutil.AssertNoError(t, err, "") 332 testutil.AssertNil(t, queryResult2) 333 334 // query with fields, namespace "ns2" 335 itr, err = db.ExecuteQuery("ns2", "{\"selector\":{\"owner\":\"jerry\"},\"fields\": [\"owner\", \"asset_name\", \"color\", \"size\"]}") 336 testutil.AssertNoError(t, err, "") 337 338 // verify one jerry result 339 queryResult1, err = itr.Next() 340 testutil.AssertNoError(t, err, "") 341 testutil.AssertNotNil(t, queryResult1) 342 versionedQueryRecord = queryResult1.(*statedb.VersionedKV) 343 stringRecord = string(versionedQueryRecord.Value) 344 bFoundRecord = strings.Contains(stringRecord, "jerry") 345 testutil.AssertEquals(t, bFoundRecord, true) 346 347 // verify no more results 348 queryResult2, err = itr.Next() 349 testutil.AssertNoError(t, err, "") 350 testutil.AssertNil(t, queryResult2) 351 352 // query with fields, namespace "ns3" 353 itr, err = db.ExecuteQuery("ns3", "{\"selector\":{\"owner\":\"jerry\"},\"fields\": [\"owner\", \"asset_name\", \"color\", \"size\"]}") 354 testutil.AssertNoError(t, err, "") 355 356 // verify no results 357 queryResult1, err = itr.Next() 358 testutil.AssertNoError(t, err, "") 359 testutil.AssertNil(t, queryResult1) 360 361 // query with complex selector, namespace "ns1" 362 itr, err = db.ExecuteQuery("ns1", "{\"selector\":{\"$and\":[{\"size\":{\"$gt\": 5}},{\"size\":{\"$lt\":8}},{\"$not\":{\"size\":6}}]}}") 363 testutil.AssertNoError(t, err, "") 364 365 // verify one fred result 366 queryResult1, err = itr.Next() 367 testutil.AssertNoError(t, err, "") 368 testutil.AssertNotNil(t, queryResult1) 369 versionedQueryRecord = queryResult1.(*statedb.VersionedKV) 370 stringRecord = string(versionedQueryRecord.Value) 371 bFoundRecord = strings.Contains(stringRecord, "fred") 372 testutil.AssertEquals(t, bFoundRecord, true) 373 374 // verify no more results 375 queryResult2, err = itr.Next() 376 testutil.AssertNoError(t, err, "") 377 testutil.AssertNil(t, queryResult2) 378 379 // query with complex selector, namespace "ns2" 380 itr, err = db.ExecuteQuery("ns2", "{\"selector\":{\"$and\":[{\"size\":{\"$gt\": 5}},{\"size\":{\"$lt\":8}},{\"$not\":{\"size\":6}}]}}") 381 testutil.AssertNoError(t, err, "") 382 383 // verify one fred result 384 queryResult1, err = itr.Next() 385 testutil.AssertNoError(t, err, "") 386 testutil.AssertNotNil(t, queryResult1) 387 versionedQueryRecord = queryResult1.(*statedb.VersionedKV) 388 stringRecord = string(versionedQueryRecord.Value) 389 bFoundRecord = strings.Contains(stringRecord, "fred") 390 testutil.AssertEquals(t, bFoundRecord, true) 391 392 // verify no more results 393 queryResult2, err = itr.Next() 394 testutil.AssertNoError(t, err, "") 395 testutil.AssertNil(t, queryResult2) 396 397 // query with complex selector, namespace "ns3" 398 itr, err = db.ExecuteQuery("ns3", "{\"selector\":{\"$and\":[{\"size\":{\"$gt\": 5}},{\"size\":{\"$lt\":8}},{\"$not\":{\"size\":6}}]}}") 399 testutil.AssertNoError(t, err, "") 400 401 // verify no more results 402 queryResult1, err = itr.Next() 403 testutil.AssertNoError(t, err, "") 404 testutil.AssertNil(t, queryResult1) 405 406 // query with embedded implicit "AND" and explicit "OR", namespace "ns1" 407 itr, err = db.ExecuteQuery("ns1", "{\"selector\":{\"color\":\"green\",\"$or\":[{\"owner\":\"fred\"},{\"owner\":\"mary\"}]}}") 408 testutil.AssertNoError(t, err, "") 409 410 // verify one green result 411 queryResult1, err = itr.Next() 412 testutil.AssertNoError(t, err, "") 413 testutil.AssertNotNil(t, queryResult1) 414 versionedQueryRecord = queryResult1.(*statedb.VersionedKV) 415 stringRecord = string(versionedQueryRecord.Value) 416 bFoundRecord = strings.Contains(stringRecord, "green") 417 testutil.AssertEquals(t, bFoundRecord, true) 418 419 // verify another green result 420 queryResult2, err = itr.Next() 421 testutil.AssertNoError(t, err, "") 422 testutil.AssertNotNil(t, queryResult2) 423 versionedQueryRecord = queryResult2.(*statedb.VersionedKV) 424 stringRecord = string(versionedQueryRecord.Value) 425 bFoundRecord = strings.Contains(stringRecord, "green") 426 testutil.AssertEquals(t, bFoundRecord, true) 427 428 // verify no more results 429 queryResult3, err = itr.Next() 430 testutil.AssertNoError(t, err, "") 431 testutil.AssertNil(t, queryResult3) 432 433 // query with embedded implicit "AND" and explicit "OR", namespace "ns2" 434 itr, err = db.ExecuteQuery("ns2", "{\"selector\":{\"color\":\"green\",\"$or\":[{\"owner\":\"fred\"},{\"owner\":\"mary\"}]}}") 435 testutil.AssertNoError(t, err, "") 436 437 // verify one green result 438 queryResult1, err = itr.Next() 439 testutil.AssertNoError(t, err, "") 440 testutil.AssertNotNil(t, queryResult1) 441 versionedQueryRecord = queryResult1.(*statedb.VersionedKV) 442 stringRecord = string(versionedQueryRecord.Value) 443 bFoundRecord = strings.Contains(stringRecord, "green") 444 testutil.AssertEquals(t, bFoundRecord, true) 445 446 // verify another green result 447 queryResult2, err = itr.Next() 448 testutil.AssertNoError(t, err, "") 449 testutil.AssertNotNil(t, queryResult2) 450 versionedQueryRecord = queryResult2.(*statedb.VersionedKV) 451 stringRecord = string(versionedQueryRecord.Value) 452 bFoundRecord = strings.Contains(stringRecord, "green") 453 testutil.AssertEquals(t, bFoundRecord, true) 454 455 // verify no more results 456 queryResult3, err = itr.Next() 457 testutil.AssertNoError(t, err, "") 458 testutil.AssertNil(t, queryResult3) 459 460 // query with embedded implicit "AND" and explicit "OR", namespace "ns3" 461 itr, err = db.ExecuteQuery("ns3", "{\"selector\":{\"color\":\"green\",\"$or\":[{\"owner\":\"fred\"},{\"owner\":\"mary\"}]}}") 462 testutil.AssertNoError(t, err, "") 463 464 // verify no results 465 queryResult1, err = itr.Next() 466 testutil.AssertNoError(t, err, "") 467 testutil.AssertNil(t, queryResult1) 468 469 // query with integer with digit-count equals 7 and response received is also received 470 // with same digit-count and there is no float transformation 471 itr, err = db.ExecuteQuery("ns1", "{\"selector\":{\"$and\":[{\"size\":{\"$eq\": 1000007}}]}}") 472 testutil.AssertNoError(t, err, "") 473 474 // verify one jerry result 475 queryResult1, err = itr.Next() 476 testutil.AssertNoError(t, err, "") 477 testutil.AssertNotNil(t, queryResult1) 478 versionedQueryRecord = queryResult1.(*statedb.VersionedKV) 479 stringRecord = string(versionedQueryRecord.Value) 480 bFoundRecord = strings.Contains(stringRecord, "joe") 481 testutil.AssertEquals(t, bFoundRecord, true) 482 bFoundRecord = strings.Contains(stringRecord, "1000007") 483 testutil.AssertEquals(t, bFoundRecord, true) 484 485 // verify no more results 486 queryResult2, err = itr.Next() 487 testutil.AssertNoError(t, err, "") 488 testutil.AssertNil(t, queryResult2) 489 490 }