func testBlockIndexSelectiveIndexing(t *testing.T, indexItems []blkstorage.IndexableAttr) {
env := newTestEnv(t)
env.indexConfig.AttrsToIndex = indexItems
defer env.Cleanup()
blkfileMgrWrapper := newTestBlockfileWrapper(t, env)
defer blkfileMgrWrapper.close()
blocks := testutil.ConstructTestBlocks(t, 3)
// add test blocks
blkfileMgrWrapper.addBlocks(blocks)
blockfileMgr := blkfileMgrWrapper.blockfileMgr
// if index has been configured for an indexItem then the item should be indexed else not
// test 'retrieveBlockByHash'
block, err := blockfileMgr.retrieveBlockByHash(blocks[0].Header.Hash())
if testutil.Contains(indexItems, blkstorage.IndexableAttrBlockHash) {
testutil.AssertNoError(t, err, "Error while retrieving block by hash")
testutil.AssertEquals(t, block, blocks[0])
} else {
testutil.AssertSame(t, err, blkstorage.ErrAttrNotIndexed)
}
// test 'retrieveBlockByNumber'
block, err = blockfileMgr.retrieveBlockByNumber(1)
if testutil.Contains(indexItems, blkstorage.IndexableAttrBlockNum) {
testutil.AssertNoError(t, err, "Error while retrieving block by number")
testutil.AssertEquals(t, block, blocks[0])
} else {
testutil.AssertSame(t, err, blkstorage.ErrAttrNotIndexed)
}
// test 'retrieveTransactionByID'
txid, err := extractTxID(blocks[0].Data.Data[0])
testutil.AssertNoError(t, err, "")
tx, err := blockfileMgr.retrieveTransactionByID(txid)
if testutil.Contains(indexItems, blkstorage.IndexableAttrTxID) {
testutil.AssertNoError(t, err, "Error while retrieving tx by id")
txOrig, err := extractTransaction(blocks[0].Data.Data[0])
testutil.AssertNoError(t, err, "")
testutil.AssertEquals(t, tx, txOrig)
} else {
testutil.AssertSame(t, err, blkstorage.ErrAttrNotIndexed)
}
//test 'retrieveTrasnactionsByBlockNumTranNum
tx2, err := blockfileMgr.retrieveTransactionForBlockNumTranNum(1, 1)
if testutil.Contains(indexItems, blkstorage.IndexableAttrBlockNumTranNum) {
testutil.AssertNoError(t, err, "Error while retrieving tx by blockNum and tranNum")
txOrig2, err2 := extractTransaction(blocks[0].Data.Data[0])
testutil.AssertNoError(t, err2, "")
testutil.AssertEquals(t, tx2, txOrig2)
} else {
testutil.AssertSame(t, err, blkstorage.ErrAttrNotIndexed)
}
}
func TestDataNodesSort(t *testing.T) {
dataNodes := dataNodes{}
dataNode1 := newDataNode(newDataKey("chaincodeID1", "key1"), []byte("value1_1"))
dataNode2 := newDataNode(newDataKey("chaincodeID1", "key2"), []byte("value1_2"))
dataNode3 := newDataNode(newDataKey("chaincodeID2", "key1"), []byte("value2_1"))
dataNode4 := newDataNode(newDataKey("chaincodeID2", "key2"), []byte("value2_2"))
dataNodes = append(dataNodes, []*dataNode{dataNode2, dataNode4, dataNode3, dataNode1}...)
sort.Sort(dataNodes)
testutil.AssertSame(t, dataNodes[0], dataNode1)
testutil.AssertSame(t, dataNodes[1], dataNode2)
testutil.AssertSame(t, dataNodes[2], dataNode3)
testutil.AssertSame(t, dataNodes[3], dataNode4)
}
func testBlockIndexSync(t *testing.T, numBlocks int, numBlocksToIndex int, syncByRestart bool) {
env := newTestEnv(t)
defer env.Cleanup()
blkfileMgrWrapper := newTestBlockfileWrapper(t, env)
defer blkfileMgrWrapper.close()
blkfileMgr := blkfileMgrWrapper.blockfileMgr
origIndex := blkfileMgr.index
// construct blocks for testing
blocks := testutil.ConstructTestBlocks(t, numBlocks)
// add a few blocks
blkfileMgrWrapper.addBlocks(blocks[:numBlocksToIndex])
// Plug-in a noop index and add remaining blocks
blkfileMgr.index = &noopIndex{}
blkfileMgrWrapper.addBlocks(blocks[numBlocksToIndex:])
// Plug-in back the original index
blkfileMgr.index = origIndex
// The first set of blocks should be present in the orginal index
for i := 1; i <= numBlocksToIndex; i++ {
block, err := blkfileMgr.retrieveBlockByNumber(uint64(i))
testutil.AssertNoError(t, err, fmt.Sprintf("block [%d] should have been present in the index", i))
testutil.AssertEquals(t, block, blocks[i-1])
}
// The last set of blocks should not be present in the original index
for i := numBlocksToIndex + 1; i <= numBlocks; i++ {
_, err := blkfileMgr.retrieveBlockByNumber(uint64(i))
testutil.AssertSame(t, err, blkstorage.ErrNotFoundInIndex)
}
// perform index sync
if syncByRestart {
blkfileMgrWrapper.close()
blkfileMgrWrapper = newTestBlockfileWrapper(t, env)
defer blkfileMgrWrapper.close()
blkfileMgr = blkfileMgrWrapper.blockfileMgr
} else {
blkfileMgr.syncIndex()
}
// Now, last set of blocks should also be present in original index
for i := numBlocksToIndex + 1; i <= numBlocks; i++ {
block, err := blkfileMgr.retrieveBlockByNumber(uint64(i))
testutil.AssertNoError(t, err, fmt.Sprintf("block [%d] should have been present in the index", i))
testutil.AssertEquals(t, block, blocks[i-1])
}
}
func testBlockFileStreamUnexpectedEOF(t *testing.T, numBlocks int, partialBlockBytes []byte) {
env := newTestEnv(t)
defer env.Cleanup()
w := newTestBlockfileWrapper(t, env)
blockfileMgr := w.blockfileMgr
blocks := testutil.ConstructTestBlocks(t, numBlocks)
w.addBlocks(blocks)
blockfileMgr.currentFileWriter.append(partialBlockBytes, true)
w.close()
s, err := newBlockfileStream(blockfileMgr.rootDir, 0, 0)
defer s.close()
testutil.AssertNoError(t, err, "Error in constructing blockfile stream")
for i := 0; i < numBlocks; i++ {
blockBytes, err := s.nextBlockBytes()
testutil.AssertNotNil(t, blockBytes)
testutil.AssertNoError(t, err, "Error in getting next block")
}
blockBytes, err := s.nextBlockBytes()
testutil.AssertNil(t, blockBytes)
testutil.AssertSame(t, err, ErrUnexpectedEndOfBlockfile)
}
func TestDatabaseQuery(t *testing.T) {
//call a helper method to load the core.yaml
testutil.SetupCoreYAMLConfig("./../../../../../peer")
//Only run the tests if CouchDB is explitily enabled in the code,
//otherwise CouchDB may not be installed and all the tests would fail
//TODO replace this with external config property rather than config within the code
if ledgerconfig.IsCouchDBEnabled() == true {
env := newTestEnv(t)
//env.Cleanup() //cleanup at the beginning to ensure the database doesn't exist already
//defer env.Cleanup() //and cleanup at the end
txMgr := NewCouchDBTxMgr(env.conf,
env.couchDBAddress, //couchDB Address
env.couchDatabaseName, //couchDB db name
env.couchUsername, //enter couchDB id
env.couchPassword) //enter couchDB pw
type Asset struct {
ID string `json:"_id"`
Rev string `json:"_rev"`
AssetName string `json:"asset_name"`
Color string `json:"color"`
Size string `json:"size"`
Owner string `json:"owner"`
}
s1, _ := txMgr.NewTxSimulator()
s1.SetState("ns1", "key1", []byte("value1"))
s1.SetState("ns1", "key2", []byte("value2"))
s1.SetState("ns1", "key3", []byte("value3"))
s1.SetState("ns1", "key4", []byte("value4"))
s1.SetState("ns1", "key5", []byte("value5"))
s1.SetState("ns1", "key6", []byte("value6"))
s1.SetState("ns1", "key7", []byte("value7"))
s1.SetState("ns1", "key8", []byte("value8"))
s1.SetState("ns1", "key9", []byte(`{"asset_name":"marble1","color":"red","size":"25","owner":"jerry"}`))
s1.SetState("ns1", "key10", []byte(`{"asset_name":"marble2","color":"blue","size":"10","owner":"bob"}`))
s1.SetState("ns1", "key11", []byte(`{"asset_name":"marble3","color":"blue","size":"35","owner":"jerry"}`))
s1.SetState("ns1", "key12", []byte(`{"asset_name":"marble4","color":"green","size":"15","owner":"bob"}`))
s1.SetState("ns1", "key13", []byte(`{"asset_name":"marble5","color":"red","size":"35","owner":"jerry"}`))
s1.SetState("ns1", "key14", []byte(`{"asset_name":"marble6","color":"blue","size":"25","owner":"bob"}`))
s1.Done()
// validate and commit RWset
txRWSet := s1.(*CouchDBTxSimulator).getTxReadWriteSet()
isValid, err := txMgr.validateTx(txRWSet)
testutil.AssertNoError(t, err, fmt.Sprintf("Error in validateTx(): %s", err))
testutil.AssertSame(t, isValid, true)
txMgr.addWriteSetToBatch(txRWSet, version.NewHeight(1, 1))
err = txMgr.Commit()
testutil.AssertNoError(t, err, fmt.Sprintf("Error while calling commit(): %s", err))
queryExecuter, _ := txMgr.NewQueryExecutor()
queryString := "{\"selector\":{\"owner\": {\"$eq\": \"bob\"}},\"limit\": 10,\"skip\": 0}"
itr, _ := queryExecuter.ExecuteQuery(queryString)
counter := 0
for {
queryRecord, _ := itr.Next()
if queryRecord == nil {
break
}
//Unmarshal the document to Asset structure
assetResp := &Asset{}
json.Unmarshal(queryRecord.(*ledger.QueryRecord).Record, &assetResp)
//Verify the owner retrieved matches
testutil.AssertEquals(t, assetResp.Owner, "bob")
counter++
}
//Ensure the query returns 3 documents
testutil.AssertEquals(t, counter, 3)
txMgr.Shutdown()
}
}
