func testBlockfileStream(t *testing.T, numBlocks int) { env := newTestEnv(t) defer env.Cleanup() w := newTestBlockfileWrapper(t, env) blockfileMgr := w.blockfileMgr blocks := testutil.ConstructTestBlocks(t, numBlocks) w.addBlocks(blocks) w.close() s, err := newBlockfileStream(blockfileMgr.rootDir, 0, 0) defer s.close() testutil.AssertNoError(t, err, "Error in constructing blockfile stream") blockCount := 0 for { blockBytes, err := s.nextBlockBytes() testutil.AssertNoError(t, err, "Error in getting next block") if blockBytes == nil { break } blockCount++ } // After the stream has been exhausted, both blockBytes and err should be nil blockBytes, err := s.nextBlockBytes() testutil.AssertNil(t, blockBytes) testutil.AssertNoError(t, err, "Error in getting next block after exhausting the file") testutil.AssertEquals(t, blockCount, numBlocks) }
func TestRawLedger(t *testing.T) { cleanup(t) rawLedger := NewFSBasedRawLedger(testFolder) defer rawLedger.Close() defer cleanup(t) // Construct test blocks and add to raw ledger blocks := testutil.ConstructTestBlocks(t, 10) for _, block := range blocks { rawLedger.CommitBlock(block) } // test GetBlockchainInfo() bcInfo, err := rawLedger.GetBlockchainInfo() testutil.AssertNoError(t, err, "Error in getting BlockchainInfo") testutil.AssertEquals(t, bcInfo.Height, uint64(10)) // test GetBlockByNumber() block, err := rawLedger.GetBlockByNumber(2) testutil.AssertNoError(t, err, "Error in getting block by number") testutil.AssertEquals(t, block, blocks[1]) // get blocks iterator for block number starting from 3 itr, err := rawLedger.GetBlocksIterator(3) testutil.AssertNoError(t, err, "Error in getting iterator") blockHolder, err := itr.Next() testutil.AssertNoError(t, err, "") testutil.AssertEquals(t, blockHolder.(ledger.BlockHolder).GetBlock(), blocks[2]) // get next block from iterator. The block should be 4th block blockHolder, err = itr.Next() testutil.AssertNoError(t, err, "") testutil.AssertEquals(t, blockHolder.(ledger.BlockHolder).GetBlock(), blocks[3]) }
func TestBlockFileScanSmallTxLastTxIncomplete(t *testing.T) { env := newTestEnv(t) defer env.Cleanup() blkfileMgrWrapper := newTestBlockfileWrapper(t, env) bg := testutil.NewBlockGenerator(t) blocks := []*common.Block{} blocks = append(blocks, bg.NextTestBlock(0, 0)) blocks = append(blocks, bg.NextTestBlock(0, 0)) blocks = append(blocks, bg.NextTestBlock(0, 0)) blkfileMgrWrapper.addBlocks(blocks) blkfileMgrWrapper.close() filePath := deriveBlockfilePath(env.conf.blockfilesDir, 0) _, fileSize, err := util.FileExists(filePath) testutil.AssertNoError(t, err, "") file, err := os.OpenFile(filePath, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660) defer file.Close() testutil.AssertNoError(t, err, "") err = file.Truncate(fileSize - 1) testutil.AssertNoError(t, err, "") _, numBlocks, err := scanForLastCompleteBlock(env.conf.blockfilesDir, 0, 0) testutil.AssertNoError(t, err, "") testutil.AssertEquals(t, numBlocks, len(blocks)-1) }
func testBlockStream(t *testing.T, numFiles int) { env := newTestEnv(t) defer env.Cleanup() w := newTestBlockfileWrapper(t, env) defer w.close() blockfileMgr := w.blockfileMgr numBlocksInEachFile := 10 bg := testutil.NewBlockGenerator(t) for i := 0; i < numFiles; i++ { blocks := bg.NextTestBlocks(numBlocksInEachFile) w.addBlocks(blocks) blockfileMgr.moveToNextFile() } s, err := newBlockStream(blockfileMgr.rootDir, 0, 0, numFiles-1) defer s.close() testutil.AssertNoError(t, err, "Error in constructing new block stream") blockCount := 0 for { blockBytes, err := s.nextBlockBytes() testutil.AssertNoError(t, err, "Error in getting next block") if blockBytes == nil { break } blockCount++ } // After the stream has been exhausted, both blockBytes and err should be nil blockBytes, err := s.nextBlockBytes() testutil.AssertNil(t, blockBytes) testutil.AssertNoError(t, err, "Error in getting next block after exhausting the file") testutil.AssertEquals(t, blockCount, numFiles*numBlocksInEachFile) }
// TestBasicRW tests basic read-write func TestBasicRW(t *testing.T, db statedb.VersionedDB) { db.Open() defer db.Close() val, err := db.GetState("ns", "key1") testutil.AssertNoError(t, err, "") testutil.AssertNil(t, val) batch := statedb.NewUpdateBatch() vv1 := statedb.VersionedValue{Value: []byte("value1"), Version: version.NewHeight(1, 1)} vv2 := statedb.VersionedValue{Value: []byte("value2"), Version: version.NewHeight(1, 2)} vv3 := statedb.VersionedValue{Value: []byte("value3"), Version: version.NewHeight(1, 3)} vv4 := statedb.VersionedValue{Value: []byte{}, Version: version.NewHeight(1, 4)} batch.Put("ns1", "key1", vv1.Value, vv1.Version) batch.Put("ns1", "key2", vv2.Value, vv2.Version) batch.Put("ns2", "key3", vv3.Value, vv3.Version) batch.Put("ns2", "key4", vv4.Value, vv4.Version) savePoint := version.NewHeight(2, 5) db.ApplyUpdates(batch, savePoint) vv, _ := db.GetState("ns1", "key1") testutil.AssertEquals(t, vv, &vv1) vv, _ = db.GetState("ns2", "key4") testutil.AssertEquals(t, vv, &vv4) sp, err := db.GetLatestSavePoint() testutil.AssertNoError(t, err, "") testutil.AssertEquals(t, sp, savePoint) }
// TestDeletes tests deteles func TestDeletes(t *testing.T, db statedb.VersionedDB) { db.Open() defer db.Close() batch := statedb.NewUpdateBatch() vv1 := statedb.VersionedValue{Value: []byte("value1"), Version: version.NewHeight(1, 1)} vv2 := statedb.VersionedValue{Value: []byte("value2"), Version: version.NewHeight(1, 2)} vv3 := statedb.VersionedValue{Value: []byte("value1"), Version: version.NewHeight(1, 3)} vv4 := statedb.VersionedValue{Value: []byte("value2"), Version: version.NewHeight(1, 4)} batch.Put("ns", "key1", vv1.Value, vv1.Version) batch.Put("ns", "key2", vv2.Value, vv2.Version) batch.Put("ns", "key3", vv2.Value, vv3.Version) batch.Put("ns", "key4", vv2.Value, vv4.Version) batch.Delete("ns", "key3", version.NewHeight(1, 5)) savePoint := version.NewHeight(1, 5) err := db.ApplyUpdates(batch, savePoint) testutil.AssertNoError(t, err, "") vv, _ := db.GetState("ns", "key2") testutil.AssertEquals(t, vv, &vv2) vv, err = db.GetState("ns", "key3") testutil.AssertNoError(t, err, "") testutil.AssertNil(t, vv) batch = statedb.NewUpdateBatch() batch.Delete("ns", "key2", version.NewHeight(1, 6)) err = db.ApplyUpdates(batch, savePoint) testutil.AssertNoError(t, err, "") vv, err = db.GetState("ns", "key2") testutil.AssertNoError(t, err, "") testutil.AssertNil(t, vv) }
func TestTxRWSetMarshalUnmarshal(t *testing.T) { txRW := &TxReadWriteSet{} nsRW1 := &NsReadWriteSet{"ns1", []*KVRead{&KVRead{"key1", version.NewHeight(1, 1)}}, []*KVWrite{&KVWrite{"key2", false, []byte("value2")}}} nsRW2 := &NsReadWriteSet{"ns2", []*KVRead{&KVRead{"key3", version.NewHeight(1, 2)}}, []*KVWrite{&KVWrite{"key4", true, nil}}} nsRW3 := &NsReadWriteSet{"ns3", []*KVRead{&KVRead{"key5", version.NewHeight(1, 3)}}, []*KVWrite{&KVWrite{"key6", false, []byte("value6")}, &KVWrite{"key7", false, []byte("value7")}}} txRW.NsRWs = append(txRW.NsRWs, nsRW1, nsRW2, nsRW3) b, err := txRW.Marshal() testutil.AssertNoError(t, err, "Error while marshalling changeset") deserializedRWSet := &TxReadWriteSet{} err = deserializedRWSet.Unmarshal(b) testutil.AssertNoError(t, err, "Error while unmarshalling changeset") t.Logf("Unmarshalled changeset = %#+v", deserializedRWSet.NsRWs[0].Writes[0].IsDelete) testutil.AssertEquals(t, deserializedRWSet, txRW) }
func TestDirNotEmptyAndFileExists(t *testing.T) { cleanup(DbPathTest) defer cleanup(DbPathTest) //create the directory dirEmpty, err := CreateDirIfMissing(DbPathTest) testutil.AssertNoError(t, err, fmt.Sprintf("Error when trying to create a test db directory at [%s]", DbPathTest)) testutil.AssertEquals(t, dirEmpty, true) //test file does not exists and size is returned correctly exists2, size2, err2 := FileExists(DbFileTest) testutil.AssertNoError(t, err2, fmt.Sprintf("Error when trying to determine if file exist when it does not at [%s]", DbFileTest)) testutil.AssertEquals(t, size2, int64(0)) testutil.AssertEquals(t, exists2, false) //test file that does not exists reports false //create file testStr := "This is some test data in a file" sizeOfFileCreated, err3 := createAndWriteAFile(testStr) testutil.AssertNoError(t, err3, fmt.Sprintf("Error when trying to create and write to file at [%s]", DbFileTest)) testutil.AssertEquals(t, sizeOfFileCreated, len(testStr)) //test file size returned is correct //test that the file exists and size is returned correctly exists, size, err4 := FileExists(DbFileTest) testutil.AssertNoError(t, err4, fmt.Sprintf("Error when trying to determine if file exist at [%s]", DbFileTest)) testutil.AssertEquals(t, size, int64(sizeOfFileCreated)) testutil.AssertEquals(t, exists, true) //test file that does exists reports true //test that if the directory is not empty dirEmpty5, err5 := DirEmpty(DbPathTest) testutil.AssertNoError(t, err5, fmt.Sprintf("Error when detecting if empty at db directory [%s]", DbPathTest)) testutil.AssertEquals(t, dirEmpty5, false) //test directory is empty is returning false }
//TestSavepoint tests the recordSavepoint and GetBlockNumfromSavepoint methods for recording and reading a savepoint document func TestSavepoint(t *testing.T) { //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) txMgr := NewCouchDBTxMgr(env.conf, env.couchDBAddress, //couchDB Address env.couchDatabaseName, //couchDB db name env.couchUsername, //enter couchDB id env.couchPassword) //enter couchDB pw // record savepoint txMgr.blockNum = 5 err := txMgr.recordSavepoint() testutil.AssertNoError(t, err, fmt.Sprintf("Error when saving recordpoint data")) // read the savepoint blockNum, err := txMgr.GetBlockNumFromSavepoint() testutil.AssertNoError(t, err, fmt.Sprintf("Error when saving recordpoint data")) testutil.AssertEquals(t, txMgr.blockNum, blockNum) txMgr.Shutdown() } }
func TestDBBadJSON(t *testing.T) { if ledgerconfig.IsCouchDBEnabled() == true { cleanup() defer cleanup() //create a new connection db, err := CreateConnectionDefinition(connectURL, database, username, password) testutil.AssertNoError(t, err, fmt.Sprintf("Error when trying to create database connection definition")) //create a new database _, errdb := db.CreateDatabaseIfNotExist() testutil.AssertNoError(t, errdb, fmt.Sprintf("Error when trying to create database")) //Retrieve the info for the new database and make sure the name matches dbResp, _, errdb := db.GetDatabaseInfo() testutil.AssertNoError(t, errdb, fmt.Sprintf("Error when trying to retrieve database information")) testutil.AssertEquals(t, dbResp.DbName, database) badJSON := []byte(`{"asset_name"}`) //Save the test document _, saveerr := db.SaveDoc("1", "", badJSON, nil) testutil.AssertError(t, saveerr, fmt.Sprintf("Error should have been thrown for a bad JSON")) } }
func TestBlockSerialization(t *testing.T) { block := testutil.ConstructTestBlock(t, 10, 100) bb, _, err := serializeBlock(block) testutil.AssertNoError(t, err, "") deserializedBlock, err := deserializeBlock(bb) testutil.AssertNoError(t, err, "") testutil.AssertEquals(t, deserializedBlock, block) }
//InitTestLedger provides a ledger for testing. This method creates a fresh db and constructs a ledger instance on that. func InitTestLedger(t *testing.T) *Ledger { testDBWrapper.CleanDB(t) _, err := GetLedger() testutil.AssertNoError(t, err, "Error while constructing ledger") newLedger, err := GetNewLedger() testutil.AssertNoError(t, err, "Error while constructing ledger") ledger = newLedger return newLedger }
func (w *testBlockfileMgrWrapper) testGetBlockByNumber(blocks []*common.Block, startingNum uint64) { for i := 0; i < len(blocks); i++ { b, err := w.blockfileMgr.retrieveBlockByNumber(startingNum + uint64(i)) testutil.AssertNoError(w.t, err, fmt.Sprintf("Error while retrieving [%d]th block from blockfileMgr", i)) testutil.AssertEquals(w.t, b, blocks[i]) } // test getting the last block b, err := w.blockfileMgr.retrieveBlockByNumber(math.MaxUint64) iLastBlock := len(blocks) - 1 testutil.AssertNoError(w.t, err, fmt.Sprintf("Error while retrieving last block from blockfileMgr")) testutil.AssertEquals(w.t, b, blocks[iLastBlock]) }
func TestNilTxRWSet(t *testing.T) { txRW := &TxReadWriteSet{} nsRW1 := &NsReadWriteSet{"ns1", []*KVRead{&KVRead{"key1", nil}}, []*KVWrite{&KVWrite{"key1", false, []byte("value1")}}} txRW.NsRWs = append(txRW.NsRWs, nsRW1) b, err := txRW.Marshal() testutil.AssertNoError(t, err, "Error while marshalling changeset") deserializedRWSet := &TxReadWriteSet{} err = deserializedRWSet.Unmarshal(b) testutil.AssertNoError(t, err, "Error while unmarshalling changeset") t.Logf("Unmarshalled changeset = %#+v", deserializedRWSet.NsRWs[0].Writes[0].IsDelete) testutil.AssertEquals(t, deserializedRWSet, txRW) }
func (h *txMgrTestHelper) validateAndCommitRWSet(txRWSet []byte) { block := h.bg.NextBlock([][]byte{txRWSet}, false) err := h.txMgr.ValidateAndPrepare(block, true) testutil.AssertNoError(h.t, err, "") txsFltr := util.NewFilterBitArrayFromBytes(block.Metadata.Metadata[common.BlockMetadataIndex_TRANSACTIONS_FILTER]) invalidTxNum := 0 for i := 0; i < len(block.Data.Data); i++ { if txsFltr.IsSet(uint(i)) { invalidTxNum++ } } testutil.AssertEquals(h.t, invalidTxNum, 0) err = h.txMgr.Commit() testutil.AssertNoError(h.t, err, "") }
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 (stateTrieTestWrapper *stateTrieTestWrapper) PrepareWorkingSetAndComputeCryptoHash(stateDelta *statemgmt.StateDelta) []byte { stateTrieTestWrapper.stateTrie.PrepareWorkingSet(stateDelta) cryptoHash, err := stateTrieTestWrapper.stateTrie.ComputeCryptoHash() testutil.AssertNoError(stateTrieTestWrapper.t, err, "Error while computing crypto hash") stateTrieTestWrapper.t.Logf("Cryptohash = [%x]", cryptoHash) return cryptoHash }
func TestCreatingDBDirWhenDirDoesAndDoesNotExists(t *testing.T) { cleanup(DbPathTest) //invoked prior to test to make sure test is executed in desired environment defer cleanup(DbPathTest) //test creating a directory without path separator passed dirEmpty, err := CreateDirIfMissing(DbPathTest) testutil.AssertNoError(t, err, fmt.Sprintf("Error when trying to create a test db directory at [%s]", DbPathTest)) testutil.AssertEquals(t, dirEmpty, true) //test creating directory AGAIN, that is the directory already exists dirEmpty2, err2 := CreateDirIfMissing(DbPathTest) testutil.AssertNoError(t, err2, fmt.Sprintf("Error not handling existing directory when trying to create a test db directory at [%s]", DbPathTest)) testutil.AssertEquals(t, dirEmpty2, true) }
func newStateImplTestWrapper(t testing.TB) *stateImplTestWrapper { var configMap map[string]interface{} stateImpl := NewStateImpl() err := stateImpl.Initialize(configMap) testutil.AssertNoError(t, err, "Error while constrcuting stateImpl") return &stateImplTestWrapper{configMap, stateImpl, t} }
func newStateImplTestWrapperWithCustomConfig(t testing.TB, numBuckets int, maxGroupingAtEachLevel int) *stateImplTestWrapper { configMap := map[string]interface{}{ConfigNumBuckets: numBuckets, ConfigMaxGroupingAtEachLevel: maxGroupingAtEachLevel} stateImpl := NewStateImpl() err := stateImpl.Initialize(configMap) testutil.AssertNoError(t, err, "Error while constrcuting stateImpl") return &stateImplTestWrapper{configMap, stateImpl, t} }
func TestBlockfileMgrFileRolling(t *testing.T) { env := newTestEnv(t) blocks := testutil.ConstructTestBlocks(t, 100) size := 0 for _, block := range blocks { by, _, err := serializeBlock(block) testutil.AssertNoError(t, err, "Error while serializing block") blockBytesSize := len(by) encodedLen := proto.EncodeVarint(uint64(blockBytesSize)) size += blockBytesSize + len(encodedLen) } env.conf.maxBlockfileSize = int(0.75 * float64(size)) blkfileMgrWrapper := newTestBlockfileWrapper(t, env) blkfileMgrWrapper.addBlocks(blocks) testutil.AssertEquals(t, blkfileMgrWrapper.blockfileMgr.cpInfo.latestFileChunkSuffixNum, 1) blkfileMgrWrapper.testGetBlockByHash(blocks) blkfileMgrWrapper.close() env.Cleanup() env = newTestEnv(t) defer env.Cleanup() env.conf.maxBlockfileSize = int(0.40 * float64(size)) blkfileMgrWrapper = newTestBlockfileWrapper(t, env) defer blkfileMgrWrapper.close() blkfileMgrWrapper.addBlocks(blocks) testutil.AssertEquals(t, blkfileMgrWrapper.blockfileMgr.cpInfo.latestFileChunkSuffixNum, 2) blkfileMgrWrapper.testGetBlockByHash(blocks) }
func TestBlocksItrBlockingNext(t *testing.T) { env := newTestEnv(t) defer env.Cleanup() blkfileMgrWrapper := newTestBlockfileWrapper(t, env) defer blkfileMgrWrapper.close() blkfileMgr := blkfileMgrWrapper.blockfileMgr blocks := testutil.ConstructTestBlocks(t, 10) blkfileMgrWrapper.addBlocks(blocks[:5]) itr, err := blkfileMgr.retrieveBlocks(2) defer itr.Close() testutil.AssertNoError(t, err, "") doneChan := make(chan bool) go testIterateAndVerify(t, itr, blocks[1:], doneChan) for { if itr.blockNumToRetrieve == 6 { break } time.Sleep(time.Millisecond * 10) } testAppendBlocks(blkfileMgrWrapper, blocks[5:7]) blkfileMgr.moveToNextFile() time.Sleep(time.Millisecond * 10) testAppendBlocks(blkfileMgrWrapper, blocks[7:]) <-doneChan }
func TestStateSnapshotIterator(t *testing.T) { testDBWrapper.CreateFreshDB(t) stateTrieTestWrapper := newStateTrieTestWrapper(t) stateTrie := stateTrieTestWrapper.stateTrie stateDelta := statemgmt.NewStateDelta() // insert keys stateDelta.Set("chaincodeID1", "key1", []byte("value1"), nil) stateDelta.Set("chaincodeID2", "key2", []byte("value2"), nil) stateDelta.Set("chaincodeID3", "key3", []byte("value3"), nil) stateDelta.Set("chaincodeID4", "key4", []byte("value4"), nil) stateDelta.Set("chaincodeID5", "key5", []byte("value5"), nil) stateDelta.Set("chaincodeID6", "key6", []byte("value6"), nil) stateTrie.PrepareWorkingSet(stateDelta) stateTrieTestWrapper.PersistChangesAndResetInMemoryChanges() //check that the key is persisted testutil.AssertEquals(t, stateTrieTestWrapper.Get("chaincodeID1", "key1"), []byte("value1")) testutil.AssertEquals(t, stateTrieTestWrapper.Get("chaincodeID2", "key2"), []byte("value2")) testutil.AssertEquals(t, stateTrieTestWrapper.Get("chaincodeID3", "key3"), []byte("value3")) testutil.AssertEquals(t, stateTrieTestWrapper.Get("chaincodeID4", "key4"), []byte("value4")) testutil.AssertEquals(t, stateTrieTestWrapper.Get("chaincodeID5", "key5"), []byte("value5")) testutil.AssertEquals(t, stateTrieTestWrapper.Get("chaincodeID6", "key6"), []byte("value6")) // take db snapeshot dbSnapshot := db.GetDBHandle().GetSnapshot() stateDelta1 := statemgmt.NewStateDelta() // delete a few keys stateDelta1.Delete("chaincodeID1", "key1", nil) stateDelta1.Delete("chaincodeID3", "key3", nil) stateDelta1.Delete("chaincodeID4", "key4", nil) stateDelta1.Delete("chaincodeID6", "key6", nil) // update remaining keys stateDelta1.Set("chaincodeID2", "key2", []byte("value2_new"), nil) stateDelta1.Set("chaincodeID5", "key5", []byte("value5_new"), nil) stateTrie.PrepareWorkingSet(stateDelta1) stateTrieTestWrapper.PersistChangesAndResetInMemoryChanges() //check that the keys are updated testutil.AssertNil(t, stateTrieTestWrapper.Get("chaincodeID1", "key1")) testutil.AssertNil(t, stateTrieTestWrapper.Get("chaincodeID3", "key3")) testutil.AssertNil(t, stateTrieTestWrapper.Get("chaincodeID4", "key4")) testutil.AssertNil(t, stateTrieTestWrapper.Get("chaincodeID6", "key6")) testutil.AssertEquals(t, stateTrieTestWrapper.Get("chaincodeID2", "key2"), []byte("value2_new")) testutil.AssertEquals(t, stateTrieTestWrapper.Get("chaincodeID5", "key5"), []byte("value5_new")) itr, err := newStateSnapshotIterator(dbSnapshot) testutil.AssertNoError(t, err, "Error while getting state snapeshot iterator") stateDeltaFromSnapshot := statemgmt.NewStateDelta() for itr.Next() { keyBytes, valueBytes := itr.GetRawKeyValue() t.Logf("key=[%s], value=[%s]", string(keyBytes), string(valueBytes)) chaincodeID, key := statemgmt.DecodeCompositeKey(keyBytes) stateDeltaFromSnapshot.Set(chaincodeID, key, valueBytes, nil) } testutil.AssertEquals(t, stateDelta, stateDeltaFromSnapshot) }
func testBlockfileMgrBlockIterator(t *testing.T, blockfileMgr *blockfileMgr, firstBlockNum int, lastBlockNum int, expectedBlocks []*common.Block) { itr, err := blockfileMgr.retrieveBlocks(uint64(firstBlockNum)) defer itr.Close() testutil.AssertNoError(t, err, "Error while getting blocks iterator") numBlocksItrated := 0 for { block, err := itr.Next() testutil.AssertNoError(t, err, fmt.Sprintf("Error while getting block number [%d] from iterator", numBlocksItrated)) testutil.AssertEquals(t, block.(*BlockHolder).GetBlock(), expectedBlocks[numBlocksItrated]) numBlocksItrated++ if numBlocksItrated == lastBlockNum-firstBlockNum+1 { break } } testutil.AssertEquals(t, numBlocksItrated, lastBlockNum-firstBlockNum+1) }
func TestExtractTxid(t *testing.T) { txid := "txID" txEnv, txid, _ := testutil.ConstructTransaction(t, testutil.ConstructRandomBytes(t, 50), false) txEnvBytes, _ := putils.GetBytesEnvelope(txEnv) extractedTxid, err := extractTxID(txEnvBytes) testutil.AssertNoError(t, err, "") testutil.AssertEquals(t, extractedTxid, txid) }
func (w *testBlockfileMgrWrapper) testGetBlockByHash(blocks []*common.Block) { for i, block := range blocks { hash := block.Header.Hash() b, err := w.blockfileMgr.retrieveBlockByHash(hash) testutil.AssertNoError(w.t, err, fmt.Sprintf("Error while retrieving [%d]th block from blockfileMgr", i)) testutil.AssertEquals(w.t, b, block) } }
// couchdb_test.go tests couchdb functions already. This test just tests that a CouchDB state database is auto-created // upon creating a new ledger transaction manager func TestDatabaseAutoCreate(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 //NewCouchDBTxMgr should have automatically created the database, let's make sure it has been created //Retrieve the info for the new database and make sure the name matches dbResp, _, errdb := txMgr.couchDB.GetDatabaseInfo() testutil.AssertNoError(t, errdb, fmt.Sprintf("Error when trying to retrieve database information")) testutil.AssertEquals(t, dbResp.DbName, env.couchDatabaseName) txMgr.Shutdown() //Call NewCouchDBTxMgr again, this time the database will already exist from last time txMgr2 := NewCouchDBTxMgr(env.conf, env.couchDBAddress, //couchDB Address env.couchDatabaseName, //couchDB db name env.couchUsername, //enter couchDB id env.couchPassword) //enter couchDB pw //Retrieve the info for the database again, and make sure the name still matches dbResp2, _, errdb2 := txMgr2.couchDB.GetDatabaseInfo() testutil.AssertNoError(t, errdb2, fmt.Sprintf("Error when trying to retrieve database information")) testutil.AssertEquals(t, dbResp2.DbName, env.couchDatabaseName) txMgr2.Shutdown() } }
func (testWrapper *blockchainTestWrapper) addNewBlock(block *protos.Block, stateHash []byte) uint64 { writeBatch := gorocksdb.NewWriteBatch() defer writeBatch.Destroy() newBlockNumber, err := testWrapper.blockchain.addPersistenceChangesForNewBlock(context.TODO(), block, stateHash, writeBatch) testutil.AssertNoError(testWrapper.t, err, "Error while adding a new block") testDBWrapper.WriteToDB(testWrapper.t, writeBatch) testWrapper.blockchain.blockPersistenceStatus(true) return newBlockNumber }
func TestBlockchain_InfoNoBlock(t *testing.T) { testDBWrapper.CleanDB(t) blockchainTestWrapper := newTestBlockchainWrapper(t) blockchain := blockchainTestWrapper.blockchain blockchainInfo, err := blockchain.getBlockchainInfo() testutil.AssertNoError(t, err, "Error while invoking getBlockchainInfo() on an emply blockchain") testutil.AssertEquals(t, blockchainInfo.Height, uint64(0)) testutil.AssertEquals(t, blockchainInfo.CurrentBlockHash, nil) testutil.AssertEquals(t, blockchainInfo.PreviousBlockHash, nil) }
func TestDBConnectionDef(t *testing.T) { //call a helper method to load the core.yaml testutil.SetupCoreYAMLConfig("./../../../../peer") //create a new connection _, err := CreateConnectionDefinition(connectURL, "database", "", "") testutil.AssertNoError(t, err, fmt.Sprintf("Error when trying to create database connection definition")) }