[FAB-10686] testutil->testify kvledger/history

Change-Id: I5f3781e9f9c03d0e2721623d27c3551991de43f7
Signed-off-by: Matthew Sykes <sykesmat@us.ibm.com>

core/ledger/kvledger/history/historydb/histmgr_helper_test.go

@@ -19,23 +19,23 @@ package historydb
 import (
  "testing"
 
- "github.com/hyperledger/fabric/common/ledger/testutil"
+ "github.com/stretchr/testify/assert"
 )
 
 var strKeySep = string(CompositeKeySep)
 
 func TestConstructCompositeKey(t *testing.T) {
  compositeKey := ConstructCompositeHistoryKey("ns1", "key1", 1, 1)
- testutil.AssertNotNil(t, compositeKey)
+ assert.NotNil(t, compositeKey)
  //historyleveldb_test.go tests the actual output
 }
 
 func TestConstructPartialCompositeKey(t *testing.T) {
  compositeStartKey := ConstructPartialCompositeHistoryKey("ns1", "key1", false)
  compositeEndKey := ConstructPartialCompositeHistoryKey("ns1", "key1", true)
 
- testutil.AssertEquals(t, compositeStartKey, []byte("ns1"+strKeySep+"key1"+strKeySep))
- testutil.AssertEquals(t, compositeEndKey, []byte("ns1"+strKeySep+"key1"+strKeySep+string([]byte{0xff})))
+ assert.Equal(t, []byte("ns1"+strKeySep+"key1"+strKeySep), compositeStartKey)
+ assert.Equal(t, []byte("ns1"+strKeySep+"key1"+strKeySep+string([]byte{0xff})), compositeEndKey)
 }
 
 func TestSplitCompositeKey(t *testing.T) {
@@ -44,5 +44,5 @@ func TestSplitCompositeKey(t *testing.T) {
 
  _, extraBytes := SplitCompositeHistoryKey(compositeFullKey, compositePartialKey)
  // second position should hold the extra bytes that were split off
- testutil.AssertEquals(t, extraBytes, []byte("extra bytes to split"))
+ assert.Equal(t, []byte("extra bytes to split"), extraBytes)
 }

core/ledger/kvledger/history/historydb/historyleveldb/historyleveldb_test.go

@@ -21,6 +21,7 @@ import (
  "github.com/hyperledger/fabric/protos/ledger/queryresult"
  "github.com/hyperledger/fabric/protos/peer"
  "github.com/spf13/viper"
+ "github.com/stretchr/testify/assert"
 )
 
 func TestMain(m *testing.M) {
@@ -37,21 +38,21 @@ func TestSavepoint(t *testing.T) {
 
  // read the savepoint, it should not exist and should return nil Height object
  savepoint, err := env.testHistoryDB.GetLastSavepoint()
- testutil.AssertNoError(t, err, "Error upon historyDatabase.GetLastSavepoint()")
- testutil.AssertNil(t, savepoint)
+ assert.NoError(t, err, "Error upon historyDatabase.GetLastSavepoint()")
+ assert.Nil(t, savepoint)
 
  // ShouldRecover should return true when no savepoint is found and recovery from block 0
  status, blockNum, err := env.testHistoryDB.ShouldRecover(0)
- testutil.AssertNoError(t, err, "Error upon historyDatabase.ShouldRecover()")
- testutil.AssertEquals(t, status, true)
- testutil.AssertEquals(t, blockNum, uint64(0))
+ assert.NoError(t, err, "Error upon historyDatabase.ShouldRecover()")
+ assert.True(t, status)
+ assert.Equal(t, uint64(0), blockNum)
 
  bg, gb := testutil.NewBlockGenerator(t, "testLedger", false)
- testutil.AssertNoError(t, env.testHistoryDB.Commit(gb), "")
+ assert.NoError(t, env.testHistoryDB.Commit(gb))
  // read the savepoint, it should now exist and return a Height object with BlockNum 0
  savepoint, err = env.testHistoryDB.GetLastSavepoint()
- testutil.AssertNoError(t, err, "Error upon historyDatabase.GetLastSavepoint()")
- testutil.AssertEquals(t, savepoint.BlockNum, uint64(0))
+ assert.NoError(t, err, "Error upon historyDatabase.GetLastSavepoint()")
+ assert.Equal(t, uint64(0), savepoint.BlockNum)
 
  // create the next block (block 1)
  txid := util2.GenerateUUID()
@@ -61,16 +62,16 @@ func TestSavepoint(t *testing.T) {
  simRes, _ := simulator.GetTxSimulationResults()
  pubSimResBytes, _ := simRes.GetPubSimulationBytes()
  block1 := bg.NextBlock([][]byte{pubSimResBytes})
- testutil.AssertNoError(t, env.testHistoryDB.Commit(block1), "")
+ assert.NoError(t, env.testHistoryDB.Commit(block1))
  savepoint, err = env.testHistoryDB.GetLastSavepoint()
- testutil.AssertNoError(t, err, "Error upon historyDatabase.GetLastSavepoint()")
- testutil.AssertEquals(t, savepoint.BlockNum, uint64(1))
+ assert.NoError(t, err, "Error upon historyDatabase.GetLastSavepoint()")
+ assert.Equal(t, uint64(1), savepoint.BlockNum)
 
  // Should Recover should return false
  status, blockNum, err = env.testHistoryDB.ShouldRecover(1)
- testutil.AssertNoError(t, err, "Error upon historyDatabase.ShouldRecover()")
- testutil.AssertEquals(t, status, false)
- testutil.AssertEquals(t, blockNum, uint64(2))
+ assert.NoError(t, err, "Error upon historyDatabase.ShouldRecover()")
+ assert.False(t, status)
+ assert.Equal(t, uint64(2), blockNum)
 
  // create the next block (block 2)
  txid = util2.GenerateUUID()
@@ -84,14 +85,14 @@ func TestSavepoint(t *testing.T) {
  // assume that the peer failed to commit this block to historyDB and is being recovered now
  env.testHistoryDB.CommitLostBlock(&ledger.BlockAndPvtData{Block: block2})
  savepoint, err = env.testHistoryDB.GetLastSavepoint()
- testutil.AssertNoError(t, err, "Error upon historyDatabase.GetLastSavepoint()")
- testutil.AssertEquals(t, savepoint.BlockNum, uint64(2))
+ assert.NoError(t, err, "Error upon historyDatabase.GetLastSavepoint()")
+ assert.Equal(t, uint64(2), savepoint.BlockNum)
 
  //Pass high blockNum, ShouldRecover should return true with 3 as blocknum to recover from
  status, blockNum, err = env.testHistoryDB.ShouldRecover(10)
- testutil.AssertNoError(t, err, "Error upon historyDatabase.ShouldRecover()")
- testutil.AssertEquals(t, status, true)
- testutil.AssertEquals(t, blockNum, uint64(3))
+ assert.NoError(t, err, "Error upon historyDatabase.ShouldRecover()")
+ assert.True(t, status)
+ assert.Equal(t, uint64(3), blockNum)
 }
 
 func TestHistory(t *testing.T) {
@@ -100,12 +101,12 @@ func TestHistory(t *testing.T) {
  provider := env.testBlockStorageEnv.provider
  ledger1id := "ledger1"
  store1, err := provider.OpenBlockStore(ledger1id)
- testutil.AssertNoError(t, err, "Error upon provider.OpenBlockStore()")
+ assert.NoError(t, err, "Error upon provider.OpenBlockStore()")
  defer store1.Shutdown()
 
  bg, gb := testutil.NewBlockGenerator(t, ledger1id, false)
- testutil.AssertNoError(t, store1.AddBlock(gb), "")
- testutil.AssertNoError(t, env.testHistoryDB.Commit(gb), "")
+ assert.NoError(t, store1.AddBlock(gb))
+ assert.NoError(t, env.testHistoryDB.Commit(gb))
 
  //block1
  txid := util2.GenerateUUID()
@@ -117,9 +118,9 @@ func TestHistory(t *testing.T) {
  pubSimResBytes, _ := simRes.GetPubSimulationBytes()
  block1 := bg.NextBlock([][]byte{pubSimResBytes})
  err = store1.AddBlock(block1)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
  err = env.testHistoryDB.Commit(block1)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
 
  //block2 tran1
  simulationResults := [][]byte{}
@@ -142,9 +143,9 @@ func TestHistory(t *testing.T) {
  simulationResults = append(simulationResults, pubSimResBytes2)
  block2 := bg.NextBlock(simulationResults)
  err = store1.AddBlock(block2)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
  err = env.testHistoryDB.Commit(block2)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
 
  //block3
  txid = util2.GenerateUUID()
@@ -155,16 +156,16 @@ func TestHistory(t *testing.T) {
  pubSimResBytes, _ = simRes.GetPubSimulationBytes()
  block3 := bg.NextBlock([][]byte{pubSimResBytes})
  err = store1.AddBlock(block3)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
  err = env.testHistoryDB.Commit(block3)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
  t.Logf("Inserted all 3 blocks")
 
  qhistory, err := env.testHistoryDB.NewHistoryQueryExecutor(store1)
- testutil.AssertNoError(t, err, "Error upon NewHistoryQueryExecutor")
+ assert.NoError(t, err, "Error upon NewHistoryQueryExecutor")
 
  itr, err2 := qhistory.GetHistoryForKey("ns1", "key7")
- testutil.AssertNoError(t, err2, "Error upon GetHistoryForKey()")
+ assert.NoError(t, err2, "Error upon GetHistoryForKey()")
 
  count := 0
  for {
@@ -181,16 +182,16 @@ func TestHistory(t *testing.T) {
  count++
  if count != 4 {
  expectedValue := []byte("value" + strconv.Itoa(count))
- testutil.AssertEquals(t, retrievedValue, expectedValue)
- testutil.AssertNotEquals(t, retrievedTimestamp, nil)
- testutil.AssertEquals(t, retrievedIsDelete, false)
+ assert.Equal(t, expectedValue, retrievedValue)
+ assert.NotNil(t, retrievedTimestamp)
+ assert.False(t, retrievedIsDelete)
  } else {
- testutil.AssertEquals(t, retrievedValue, nil)
- testutil.AssertNotEquals(t, retrievedTimestamp, nil)
- testutil.AssertEquals(t, retrievedIsDelete, true)
+ assert.Equal(t, []uint8(nil), retrievedValue)
+ assert.NotNil(t, retrievedTimestamp)
+ assert.True(t, retrievedIsDelete)
  }
  }
- testutil.AssertEquals(t, count, 4)
+ assert.Equal(t, 4, count)
 }
 
 func TestHistoryForInvalidTran(t *testing.T) {
@@ -199,12 +200,12 @@ func TestHistoryForInvalidTran(t *testing.T) {
  provider := env.testBlockStorageEnv.provider
  ledger1id := "ledger1"
  store1, err := provider.OpenBlockStore(ledger1id)
- testutil.AssertNoError(t, err, "Error upon provider.OpenBlockStore()")
+ assert.NoError(t, err, "Error upon provider.OpenBlockStore()")
  defer store1.Shutdown()
 
  bg, gb := testutil.NewBlockGenerator(t, ledger1id, false)
- testutil.AssertNoError(t, store1.AddBlock(gb), "")
- testutil.AssertNoError(t, env.testHistoryDB.Commit(gb), "")
+ assert.NoError(t, store1.AddBlock(gb))
+ assert.NoError(t, env.testHistoryDB.Commit(gb))
 
  //block1
  txid := util2.GenerateUUID()
@@ -222,19 +223,19 @@ func TestHistoryForInvalidTran(t *testing.T) {
  block1.Metadata.Metadata[common.BlockMetadataIndex_TRANSACTIONS_FILTER] = txsFilter
 
  err = store1.AddBlock(block1)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
  err = env.testHistoryDB.Commit(block1)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
 
  qhistory, err := env.testHistoryDB.NewHistoryQueryExecutor(store1)
- testutil.AssertNoError(t, err, "Error upon NewHistoryQueryExecutor")
+ assert.NoError(t, err, "Error upon NewHistoryQueryExecutor")
 
  itr, err2 := qhistory.GetHistoryForKey("ns1", "key7")
- testutil.AssertNoError(t, err2, "Error upon GetHistoryForKey()")
+ assert.NoError(t, err2, "Error upon GetHistoryForKey()")
 
  // test that there are no history values, since the tran was marked as invalid
  kmod, _ := itr.Next()
- testutil.AssertNil(t, kmod)
+ assert.Nil(t, kmod)
 }
 
 //TestSavepoint tests that save points get written after each block and get returned via GetBlockNumfromSavepoint
@@ -244,9 +245,9 @@ func TestHistoryDisabled(t *testing.T) {
  viper.Set("ledger.history.enableHistoryDatabase", "false")
  //no need to pass blockstore into history executore, it won't be used in this test
  qhistory, err := env.testHistoryDB.NewHistoryQueryExecutor(nil)
- testutil.AssertNoError(t, err, "Error upon NewHistoryQueryExecutor")
+ assert.NoError(t, err, "Error upon NewHistoryQueryExecutor")
  _, err2 := qhistory.GetHistoryForKey("ns1", "key7")
- testutil.AssertError(t, err2, "Error should have been returned for GetHistoryForKey() when history disabled")
+ assert.Error(t, err2, "Error should have been returned for GetHistoryForKey() when history disabled")
 }
 
 //TestGenesisBlockNoError tests that Genesis blocks are ignored by history processing
@@ -255,9 +256,9 @@ func TestGenesisBlockNoError(t *testing.T) {
  env := newTestHistoryEnv(t)
  defer env.cleanup()
  block, err := configtxtest.MakeGenesisBlock("test_chainid")
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
  err = env.testHistoryDB.Commit(block)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
 }
 
 // TestHistoryWithKeyContainingNilBytes tests historydb when keys contains nil bytes (FAB-11244) -
@@ -268,12 +269,12 @@ func TestHistoryWithKeyContainingNilBytes(t *testing.T) {
  provider := env.testBlockStorageEnv.provider
  ledger1id := "ledger1"
  store1, err := provider.OpenBlockStore(ledger1id)
- testutil.AssertNoError(t, err, "Error upon provider.OpenBlockStore()")
+ assert.NoError(t, err, "Error upon provider.OpenBlockStore()")
  defer store1.Shutdown()
 
  bg, gb := testutil.NewBlockGenerator(t, ledger1id, false)
- testutil.AssertNoError(t, store1.AddBlock(gb), "")
- testutil.AssertNoError(t, env.testHistoryDB.Commit(gb), "")
+ assert.NoError(t, store1.AddBlock(gb))
+ assert.NoError(t, env.testHistoryDB.Commit(gb))
 
  //block1
  txid := util2.GenerateUUID()
@@ -284,9 +285,9 @@ func TestHistoryWithKeyContainingNilBytes(t *testing.T) {
  pubSimResBytes, _ := simRes.GetPubSimulationBytes()
  block1 := bg.NextBlock([][]byte{pubSimResBytes})
  err = store1.AddBlock(block1)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
  err = env.testHistoryDB.Commit(block1)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
 
  //block2 tran1
  simulationResults := [][]byte{}
@@ -310,20 +311,20 @@ func TestHistoryWithKeyContainingNilBytes(t *testing.T) {
  simulationResults = append(simulationResults, pubSimResBytes2)
  block2 := bg.NextBlock(simulationResults)
  err = store1.AddBlock(block2)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
  err = env.testHistoryDB.Commit(block2)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
 
  qhistory, err := env.testHistoryDB.NewHistoryQueryExecutor(store1)
- testutil.AssertNoError(t, err, "Error upon NewHistoryQueryExecutor")
+ assert.NoError(t, err, "Error upon NewHistoryQueryExecutor")
  testutilVerifyResults(t, qhistory, "ns1", "key", []string{"value1", "value2"})
  testutilVerifyResults(t, qhistory, "ns1", "key\x00\x01\x01\x15", []string{"dummyVal1"})
  testutilVerifyResults(t, qhistory, "ns1", "\x00key\x00\x01\x01\x15", []string{"dummyVal2"})
 }
 
 func testutilVerifyResults(t *testing.T, hqe ledger.HistoryQueryExecutor, ns, key string, expectedVals []string) {
  itr, err := hqe.GetHistoryForKey(ns, key)
- testutil.AssertNoError(t, err, "Error upon GetHistoryForKey()")
+ assert.NoError(t, err, "Error upon GetHistoryForKey()")
  retrievedVals := []string{}
  for {
  kmod, _ := itr.Next()
@@ -335,5 +336,5 @@ func testutilVerifyResults(t *testing.T, hqe ledger.HistoryQueryExecutor, ns, ke
  retrievedVals = append(retrievedVals, retrievedValue)
  t.Logf("Retrieved history record at TxId=%s with value %s", txid, retrievedValue)
  }
- testutil.AssertEquals(t, retrievedVals, expectedVals)
+ assert.Equal(t, expectedVals, retrievedVals)
 }

core/ledger/kvledger/history/historydb/historyleveldb/pkg_test.go

@@ -21,17 +21,16 @@ import (
  "os"
  "testing"
 
- "github.com/hyperledger/fabric/core/ledger/kvledger/bookkeeping"
-
  "github.com/hyperledger/fabric/common/ledger/blkstorage"
  "github.com/hyperledger/fabric/common/ledger/blkstorage/fsblkstorage"
- "github.com/hyperledger/fabric/common/ledger/testutil"
+ "github.com/hyperledger/fabric/core/ledger/kvledger/bookkeeping"
  "github.com/hyperledger/fabric/core/ledger/kvledger/history/historydb"
  "github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/privacyenabledstate"
  "github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/txmgr"
  "github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/txmgr/lockbasedtxmgr"
  "github.com/hyperledger/fabric/core/ledger/ledgerconfig"
  "github.com/spf13/viper"
+ "github.com/stretchr/testify/assert"
 )
 
 /////// levelDBLockBasedHistoryEnv //////
@@ -61,11 +60,11 @@ func newTestHistoryEnv(t *testing.T) *levelDBLockBasedHistoryEnv {
  testBookkeepingEnv := bookkeeping.NewTestEnv(t)
 
  txMgr, err := lockbasedtxmgr.NewLockBasedTxMgr(testLedgerID, testDB, nil, nil, testBookkeepingEnv.TestProvider)
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
 
  testHistoryDBProvider := NewHistoryDBProvider()
  testHistoryDB, err := testHistoryDBProvider.GetDBHandle("TestHistoryDB")
- testutil.AssertNoError(t, err, "")
+ assert.NoError(t, err)
 
  return &levelDBLockBasedHistoryEnv{t,
  blockStorageTestEnv, testDBEnv, testBookkeepingEnv,