func TestTransactionResult(t *testing.T) { ledgerTestWrapper := createFreshDBAndTestLedgerWrapper(t) ledger := ledgerTestWrapper.ledger // Block 0 ledger.BeginTxBatch(0) ledger.TxBegin("txUuid1") ledger.SetState("chaincode1", "key1", []byte("value1A")) ledger.SetState("chaincode2", "key2", []byte("value2A")) ledger.SetState("chaincode3", "key3", []byte("value3A")) ledger.TxFinished("txUuid1", true) transaction, uuid := buildTestTx(t) transactionResult := &protos.TransactionResult{Uuid: uuid, ErrorCode: 500, Error: "bad"} ledger.CommitTxBatch(0, []*protos.Transaction{transaction}, []*protos.TransactionResult{transactionResult}, []byte("proof")) block := ledgerTestWrapper.GetBlockByNumber(0) nonHashData := block.GetNonHashData() if nonHashData == nil { t.Fatal("Expected block to have non hash data, but non hash data was nil.") } if nonHashData.TransactionResults == nil || len(nonHashData.TransactionResults) == 0 { t.Fatal("Expected block to have non hash data transaction results.") } testutil.AssertEquals(t, nonHashData.TransactionResults[0].Uuid, uuid) testutil.AssertEquals(t, nonHashData.TransactionResults[0].Error, "bad") testutil.AssertEquals(t, nonHashData.TransactionResults[0].ErrorCode, uint32(500)) }
func TestBlockChain_SimpleChain(t *testing.T) { testDBWrapper.CreateFreshDB(t) blockchainTestWrapper := newTestBlockchainWrapper(t) blockchain := blockchainTestWrapper.blockchain allBlocks, allStateHashes := blockchainTestWrapper.populateBlockChainWithSampleData() testutil.AssertEquals(t, blockchain.getSize(), uint64(len(allBlocks))) testutil.AssertEquals(t, blockchainTestWrapper.fetchBlockchainSizeFromDB(), uint64(len(allBlocks))) for i := range allStateHashes { t.Logf("Checking state hash for block number = [%d]", i) testutil.AssertEquals(t, blockchainTestWrapper.getBlock(uint64(i)).GetStateHash(), allStateHashes[i]) } for i := range allBlocks { t.Logf("Checking block hash for block number = [%d]", i) blockhash, _ := blockchainTestWrapper.getBlock(uint64(i)).GetHash() expectedBlockHash, _ := allBlocks[i].GetHash() testutil.AssertEquals(t, blockhash, expectedBlockHash) } testutil.AssertNil(t, blockchainTestWrapper.getBlock(uint64(0)).PreviousBlockHash) i := 1 for i < len(allBlocks) { t.Logf("Checking previous block hash for block number = [%d]", i) expectedPreviousBlockHash, _ := allBlocks[i-1].GetHash() testutil.AssertEquals(t, blockchainTestWrapper.getBlock(uint64(i)).PreviousBlockHash, expectedPreviousBlockHash) i++ } }
func testTrieNodeMarshalUnmarshal(trieNode *trieNode, t *testing.T) { trieNodeTestWrapper := &trieNodeTestWrapper{trieNode, t} serializedContent := trieNodeTestWrapper.marshal() trieNodeFromUnmarshal := trieNodeTestWrapper.unmarshal(trieNode.trieKey, serializedContent) testutil.AssertEquals(t, trieNodeFromUnmarshal.trieKey, trieNode.trieKey) testutil.AssertEquals(t, trieNodeFromUnmarshal.value, trieNode.value) testutil.AssertEquals(t, trieNodeFromUnmarshal.childrenCryptoHashes, trieNode.childrenCryptoHashes) testutil.AssertEquals(t, trieNodeFromUnmarshal.getNumChildren(), trieNode.getNumChildren()) }
func TestConfigInit(t *testing.T) { configs := viper.GetStringMap("ledger.state.dataStructure.configs") t.Logf("Configs loaded from yaml = %#v", configs) testDBWrapper.CreateFreshDB(t) stateImpl := NewStateImpl() stateImpl.Initialize(configs) testutil.AssertEquals(t, conf.getNumBucketsAtLowestLevel(), configs[ConfigNumBuckets]) testutil.AssertEquals(t, conf.getMaxGroupingAtEachLevel(), configs[ConfigMaxGroupingAtEachLevel]) }
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 TestBucketKeyGetChildIndex(t *testing.T) { conf = newConfig(26, 3, fnvHash) bucketKey := newBucketKey(3, 22) testutil.AssertEquals(t, bucketKey.getParentKey().getChildIndex(bucketKey), 0) bucketKey = newBucketKey(3, 23) testutil.AssertEquals(t, bucketKey.getParentKey().getChildIndex(bucketKey), 1) bucketKey = newBucketKey(3, 24) testutil.AssertEquals(t, bucketKey.getParentKey().getChildIndex(bucketKey), 2) }
func TestBucketKeyEqual(t *testing.T) { conf = newConfig(26, 3, fnvHash) bucketKey1 := newBucketKey(1, 2) bucketKey2 := newBucketKey(1, 2) testutil.AssertEquals(t, bucketKey1.equals(bucketKey2), true) bucketKey2 = newBucketKey(2, 2) testutil.AssertEquals(t, bucketKey1.equals(bucketKey2), false) bucketKey2 = newBucketKey(1, 3) testutil.AssertEquals(t, bucketKey1.equals(bucketKey2), false) bucketKey2 = newBucketKey(2, 3) testutil.AssertEquals(t, bucketKey1.equals(bucketKey2), false) }
func TestLedgerCommit(t *testing.T) { ledgerTestWrapper := createFreshDBAndTestLedgerWrapper(t) ledger := ledgerTestWrapper.ledger ledger.BeginTxBatch(1) ledger.TxBegin("txUuid") ledger.SetState("chaincode1", "key1", []byte("value1")) ledger.SetState("chaincode2", "key2", []byte("value2")) ledger.SetState("chaincode3", "key3", []byte("value3")) ledger.TxFinished("txUuid", true) transaction, _ := buildTestTx(t) ledger.CommitTxBatch(1, []*protos.Transaction{transaction}, nil, []byte("proof")) testutil.AssertEquals(t, ledgerTestWrapper.GetState("chaincode1", "key1", false), []byte("value1")) testutil.AssertEquals(t, ledgerTestWrapper.GetState("chaincode1", "key1", true), []byte("value1")) }
func TestBucketNodeMarshalUnmarshal(t *testing.T) { conf = newConfig(26, 3, fnvHash) bucketNode := newBucketNode(newBucketKey(2, 7)) childKey1 := newBucketKey(3, 19) bucketNode.setChildCryptoHash(childKey1, []byte("cryptoHashChild1")) childKey3 := newBucketKey(3, 21) bucketNode.setChildCryptoHash(childKey3, []byte("cryptoHashChild3")) serializedBytes := bucketNode.marshal() deserializedBucketNode := unmarshalBucketNode(newBucketKey(2, 7), serializedBytes) testutil.AssertEquals(t, bucketNode.bucketKey, deserializedBucketNode.bucketKey) testutil.AssertEquals(t, bucketNode.childrenCryptoHash, deserializedBucketNode.childrenCryptoHash) }
func TestStateDeltaCryptoHash(t *testing.T) { stateDelta := NewStateDelta() testutil.AssertNil(t, stateDelta.ComputeCryptoHash()) stateDelta.Set("chaincodeID1", "key2", []byte("value2"), nil) stateDelta.Set("chaincodeID1", "key1", []byte("value1"), nil) stateDelta.Set("chaincodeID2", "key2", []byte("value2"), nil) stateDelta.Set("chaincodeID2", "key1", []byte("value1"), nil) testutil.AssertEquals(t, stateDelta.ComputeCryptoHash(), testutil.ComputeCryptoHash([]byte("chaincodeID1key1value1key2value2chaincodeID2key1value1key2value2"))) stateDelta.Delete("chaincodeID2", "key1", nil) testutil.AssertEquals(t, stateDelta.ComputeCryptoHash(), testutil.ComputeCryptoHash([]byte("chaincodeID1key1value1key2value2chaincodeID2key1key2value2"))) }
func TestBucketNodeMerge(t *testing.T) { conf = newConfig(26, 3, fnvHash) bucketNode := newBucketNode(newBucketKey(2, 7)) bucketNode.childrenCryptoHash[0] = []byte("cryptoHashChild1") bucketNode.childrenCryptoHash[2] = []byte("cryptoHashChild3") dbBucketNode := newBucketNode(newBucketKey(2, 7)) dbBucketNode.childrenCryptoHash[0] = []byte("DBcryptoHashChild1") dbBucketNode.childrenCryptoHash[1] = []byte("DBcryptoHashChild2") bucketNode.mergeBucketNode(dbBucketNode) testutil.AssertEquals(t, bucketNode.childrenCryptoHash[0], []byte("cryptoHashChild1")) testutil.AssertEquals(t, bucketNode.childrenCryptoHash[1], []byte("DBcryptoHashChild2")) testutil.AssertEquals(t, bucketNode.childrenCryptoHash[2], []byte("cryptoHashChild3")) }
func TestTrieNode_MergeAttributes(t *testing.T) { trieNode := newTrieNode(newTrieKey("chaincodeID", "key"), []byte("newValue!"), true) trieNode.setChildCryptoHash(0, []byte("crypto-hash-for-test-0")) trieNode.setChildCryptoHash(5, []byte("crypto-hash-for-test-5")) existingTrieNode := newTrieNode(newTrieKey("chaincodeID", "key"), []byte("existingValue"), false) existingTrieNode.setChildCryptoHash(5, []byte("crypto-hash-for-test-5-existing")) existingTrieNode.setChildCryptoHash(10, []byte("crypto-hash-for-test-10-existing")) trieNode.mergeMissingAttributesFrom(existingTrieNode) testutil.AssertEquals(t, trieNode.value, []byte("newValue!")) testutil.AssertEquals(t, trieNode.childrenCryptoHashes[0], []byte("crypto-hash-for-test-0")) testutil.AssertEquals(t, trieNode.childrenCryptoHashes[5], []byte("crypto-hash-for-test-5")) testutil.AssertEquals(t, trieNode.childrenCryptoHashes[10], []byte("crypto-hash-for-test-10-existing")) }
// AssertIteratorContains - tests wether the iterator (itr) contains expected results (provided in map) func AssertIteratorContains(t *testing.T, itr RangeScanIterator, expected map[string][]byte) { count := 0 actual := make(map[string][]byte) for itr.Next() { count++ k, v := itr.GetKeyValue() actual[k] = v } t.Logf("Results from iterator: %s", actual) testutil.AssertEquals(t, count, len(expected)) for k, v := range expected { testutil.AssertEquals(t, actual[k], v) } }
func TestExpectedBucketHashContentForTest(t *testing.T) { expectedHashContent1 := expectedBucketHashContentForTest( []string{"chaincodeID1", "key1", "value1"}, []string{"chaincodeID_2", "key_1", "value_1", "key_2", "value_2"}, []string{"chaincodeID3", "key1", "value1", "key2", "value2", "key3", "value3"}, ) expectedHashContent2 := testutil.AppendAll( encodeNumberForTest(len("chaincodeID1")), []byte("chaincodeID1"), encodeNumberForTest(1), encodeNumberForTest(len("key1")), []byte("key1"), encodeNumberForTest(len("value1")), []byte("value1"), encodeNumberForTest(len("chaincodeID_2")), []byte("chaincodeID_2"), encodeNumberForTest(2), encodeNumberForTest(len("key_1")), []byte("key_1"), encodeNumberForTest(len("value_1")), []byte("value_1"), encodeNumberForTest(len("key_2")), []byte("key_2"), encodeNumberForTest(len("value_2")), []byte("value_2"), encodeNumberForTest(len("chaincodeID3")), []byte("chaincodeID3"), encodeNumberForTest(3), encodeNumberForTest(len("key1")), []byte("key1"), encodeNumberForTest(len("value1")), []byte("value1"), encodeNumberForTest(len("key2")), []byte("key2"), encodeNumberForTest(len("value2")), []byte("value2"), encodeNumberForTest(len("key3")), []byte("key3"), encodeNumberForTest(len("value3")), []byte("value3"), ) testutil.AssertEquals(t, expectedHashContent1, expectedHashContent2) }
func TestIndexesAsync_ClientWaitScenario(t *testing.T) { testDBWrapper.CreateFreshDB(t) testBlockchainWrapper := newTestBlockchainWrapper(t) chain := testBlockchainWrapper.blockchain if chain.indexer.isSynchronous() { t.Skip("Skipping because blockchain is configured to index block data synchronously") } blocks, _, err := testBlockchainWrapper.populateBlockChainWithSampleData() if err != nil { t.Logf("Error populating block chain with sample data: %s", err) t.Fail() } t.Log("Increasing size of blockchain by one artificially so as to make client wait") chain.size = chain.size + 1 t.Log("Resetting size of blockchain to original and adding one block in a separate go routine so as to wake up the client") go func() { time.Sleep(2 * time.Second) chain.size = chain.size - 1 blk, err := buildTestBlock(t) if err != nil { t.Logf("Error building test block: %s", err) t.Fail() } testBlockchainWrapper.addNewBlock(blk, []byte("stateHash")) }() t.Log("Executing client query. The client would wait and will be woken up") blockHash, _ := blocks[0].GetHash() block := testBlockchainWrapper.getBlockByHash(blockHash) testutil.AssertEquals(t, block, blocks[0]) }
func TestStateTrie_ComputeHash_AllInMemory_NoContents(t *testing.T) { testDBWrapper.CreateFreshDB(t) stateTrie := NewStateTrie() stateTrieTestWrapper := &stateTrieTestWrapper{stateTrie, t} hash := stateTrieTestWrapper.PrepareWorkingSetAndComputeCryptoHash(statemgmt.NewStateDelta()) testutil.AssertEquals(t, hash, nil) }
func TestStateImpl_ComputeHash_AllInMemory_1(t *testing.T) { // number of buckets at each level 26,9,3,1 testHasher, stateImplTestWrapper, stateDelta := createFreshDBAndInitTestStateImplWithCustomHasher(t, 26, 3) testHasher.populate("chaincodeID1", "key1", 0) testHasher.populate("chaincodeID2", "key2", 0) testHasher.populate("chaincodeID3", "key3", 0) testHasher.populate("chaincodeID4", "key4", 3) 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) rootHash := stateImplTestWrapper.prepareWorkingSetAndComputeCryptoHash(stateDelta) expectedHashBucket3_1 := expectedBucketHashForTest( []string{"chaincodeID1", "key1", "value1"}, []string{"chaincodeID2", "key2", "value2"}, []string{"chaincodeID3", "key3", "value3"}, ) expectedHashBucket3_4 := expectedBucketHashForTest( []string{"chaincodeID4", "key4", "value4"}, ) expectedHash := testutil.ComputeCryptoHash(expectedHashBucket3_1, expectedHashBucket3_4) testutil.AssertEquals(t, rootHash, expectedHash) }
func TestDataKey(t *testing.T) { conf = initConfig(26, 3, fnvHash) dataKey := newDataKey("chaincodeID", "key") encodedBytes := dataKey.getEncodedBytes() dataKeyFromEncodedBytes := newDataKeyFromEncodedBytes(encodedBytes) testutil.AssertEquals(t, dataKey, dataKeyFromEncodedBytes) }
func TestTrieNode_ComputeCryptoHash_NoValue_SingleChild(t *testing.T) { trieNode := newTrieNode(newTrieKey("chaincodeID", "key"), nil, false) singleChildCryptoHash := []byte("childCryptoHash-0") trieNode.setChildCryptoHash(0, singleChildCryptoHash) hash := trieNode.computeCryptoHash() testutil.AssertEquals(t, hash, singleChildCryptoHash) }
func TestPreviewTXBatchBlock(t *testing.T) { ledgerTestWrapper := createFreshDBAndTestLedgerWrapper(t) ledger := ledgerTestWrapper.ledger // Block 0 ledger.BeginTxBatch(0) ledger.TxBegin("txUuid1") ledger.SetState("chaincode1", "key1", []byte("value1A")) ledger.SetState("chaincode2", "key2", []byte("value2A")) ledger.SetState("chaincode3", "key3", []byte("value3A")) ledger.TxFinished("txUuid1", true) transaction, _ := buildTestTx(t) previewBlock, err := ledger.GetTXBatchPreviewBlock(0, []*protos.Transaction{transaction}, []byte("proof")) testutil.AssertNoError(t, err, "Error fetching preview block.") ledger.CommitTxBatch(0, []*protos.Transaction{transaction}, nil, []byte("proof")) commitedBlock := ledgerTestWrapper.GetBlockByNumber(0) previewBlockHash, err := previewBlock.GetHash() testutil.AssertNoError(t, err, "Error fetching preview block hash.") commitedBlockHash, err := commitedBlock.GetHash() testutil.AssertNoError(t, err, "Error fetching committed block hash.") testutil.AssertEquals(t, previewBlockHash, commitedBlockHash) }
func TestLedgerRollbackWithHash(t *testing.T) { ledgerTestWrapper := createFreshDBAndTestLedgerWrapper(t) ledger := ledgerTestWrapper.ledger ledger.BeginTxBatch(0) ledger.TxBegin("txUuid") ledger.SetState("chaincode0", "key1", []byte("value1")) ledger.SetState("chaincode0", "key2", []byte("value2")) ledger.SetState("chaincode0", "key3", []byte("value3")) ledger.TxFinished("txUuid", true) ledger.RollbackTxBatch(0) hash0 := ledgerTestWrapper.GetTempStateHash() ledger.BeginTxBatch(1) ledger.TxBegin("txUuid") ledger.SetState("chaincode1", "key1", []byte("value1")) ledger.SetState("chaincode2", "key2", []byte("value2")) ledger.SetState("chaincode3", "key3", []byte("value3")) ledger.TxFinished("txUuid", true) hash1 := ledgerTestWrapper.GetTempStateHash() testutil.AssertNotEquals(t, hash1, hash0) ledger.RollbackTxBatch(1) hash1 = ledgerTestWrapper.GetTempStateHash() testutil.AssertEquals(t, hash1, hash0) testutil.AssertNil(t, ledgerTestWrapper.GetState("chaincode1", "key1", false)) }
func TestIndexes_GetBlockByBlockNumber(t *testing.T) { testDBWrapper.CreateFreshDB(t) testBlockchainWrapper := newTestBlockchainWrapper(t) blocks, _ := testBlockchainWrapper.populateBlockChainWithSampleData() for i := range blocks { testutil.AssertEquals(t, testBlockchainWrapper.getBlock(uint64(i)), blocks[i]) } }
func TestBucketNodeComputeHash(t *testing.T) { conf = newConfig(26, 3, fnvHash) bucketNode := newBucketNode(newBucketKey(2, 7)) testutil.AssertEquals(t, bucketNode.computeCryptoHash(), nil) childKey1 := newBucketKey(3, 19) bucketNode.setChildCryptoHash(childKey1, []byte("cryptoHashChild1")) testutil.AssertEquals(t, bucketNode.computeCryptoHash(), []byte("cryptoHashChild1")) childKey3 := newBucketKey(3, 21) bucketNode.setChildCryptoHash(childKey3, []byte("cryptoHashChild3")) testutil.AssertEquals(t, bucketNode.computeCryptoHash(), testutil.ComputeCryptoHash([]byte("cryptoHashChild1cryptoHashChild3"))) childKey2 := newBucketKey(3, 20) bucketNode.setChildCryptoHash(childKey2, []byte("cryptoHashChild2")) testutil.AssertEquals(t, bucketNode.computeCryptoHash(), testutil.ComputeCryptoHash([]byte("cryptoHashChild1cryptoHashChild2cryptoHashChild3"))) }
func TestIndexes_GetTransactionByUUID(t *testing.T) { testDBWrapper.CreateFreshDB(t) testBlockchainWrapper := newTestBlockchainWrapper(t) tx1, uuid1 := buildTestTx(t) tx2, uuid2 := buildTestTx(t) block1 := protos.NewBlock([]*protos.Transaction{tx1, tx2}, nil) testBlockchainWrapper.addNewBlock(block1, []byte("stateHash1")) tx3, uuid3 := buildTestTx(t) tx4, uuid4 := buildTestTx(t) block2 := protos.NewBlock([]*protos.Transaction{tx3, tx4}, nil) testBlockchainWrapper.addNewBlock(block2, []byte("stateHash2")) testutil.AssertEquals(t, testBlockchainWrapper.getTransactionByUUID(uuid1), tx1) testutil.AssertEquals(t, testBlockchainWrapper.getTransactionByUUID(uuid2), tx2) testutil.AssertEquals(t, testBlockchainWrapper.getTransactionByUUID(uuid3), tx3) testutil.AssertEquals(t, testBlockchainWrapper.getTransactionByUUID(uuid4), tx4) }
func TestIndexes_GetBlockByBlockHash(t *testing.T) { testDBWrapper.CreateFreshDB(t) testBlockchainWrapper := newTestBlockchainWrapper(t) blocks, _ := testBlockchainWrapper.populateBlockChainWithSampleData() for i := range blocks { blockHash, _ := blocks[i].GetHash() testutil.AssertEquals(t, testBlockchainWrapper.getBlockByHash(blockHash), blocks[i]) } }
func TestTrieNode_ComputeCryptoHash_WithValue_NoChild(t *testing.T) { trieKey := newTrieKey("chaincodeID", "key") value := []byte("testValue") trieNode := newTrieNode(trieKey, value, false) hash := trieNode.computeCryptoHash() expectedHash := expectedCryptoHashForTest(trieKey, value) testutil.AssertEquals(t, hash, expectedHash) }
func TestLedgerPutRawBlock(t *testing.T) { ledgerTestWrapper := createFreshDBAndTestLedgerWrapper(t) ledger := ledgerTestWrapper.ledger block := new(protos.Block) block.PreviousBlockHash = []byte("foo") block.StateHash = []byte("bar") ledger.PutRawBlock(block, 4) testutil.AssertEquals(t, ledgerTestWrapper.GetBlockByNumber(4), block) }
func TestIndexes_GetTransactionByBlockNumberAndTxIndex(t *testing.T) { testDBWrapper.CreateFreshDB(t) testBlockchainWrapper := newTestBlockchainWrapper(t) blocks, _ := testBlockchainWrapper.populateBlockChainWithSampleData() for i, block := range blocks { for j, tx := range block.GetTransactions() { testutil.AssertEquals(t, testBlockchainWrapper.getTransaction(uint64(i), uint64(j)), tx) } } }
func TestBlockChainEmptyChain(t *testing.T) { testDBWrapper.CreateFreshDB(t) blockchainTestWrapper := newTestBlockchainWrapper(t) testutil.AssertEquals(t, blockchainTestWrapper.blockchain.getSize(), uint64(0)) block := blockchainTestWrapper.getLastBlock() if block != nil { t.Fatalf("Get last block on an empty chain should return nil.") } t.Logf("last block = [%s]", block) }
func TestStateSnapshotIterator(t *testing.T) { testDBWrapper.CreateFreshDB(t) stateImplTestWrapper := newStateImplTestWrapper(t) 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) stateImplTestWrapper.prepareWorkingSet(stateDelta) stateImplTestWrapper.persistChangesAndResetInMemoryChanges() //check that the key is persisted testutil.AssertEquals(t, stateImplTestWrapper.get("chaincodeID5", "key5"), []byte("value5")) // take db snapeshot dbSnapshot := db.GetDBHandle().GetSnapshot() // delete keys stateDelta.Delete("chaincodeID1", "key1", nil) stateDelta.Delete("chaincodeID2", "key2", nil) stateDelta.Delete("chaincodeID3", "key3", nil) stateDelta.Delete("chaincodeID4", "key4", nil) stateDelta.Delete("chaincodeID5", "key5", nil) stateDelta.Delete("chaincodeID6", "key6", nil) stateImplTestWrapper.prepareWorkingSet(stateDelta) stateImplTestWrapper.persistChangesAndResetInMemoryChanges() //check that the key is deleted testutil.AssertNil(t, stateImplTestWrapper.get("chaincodeID5", "key5")) itr, err := newStateSnapshotIterator(dbSnapshot) testutil.AssertNoError(t, err, "Error while getting state snapeshot iterator") numKeys := 0 for itr.Next() { key, value := itr.GetRawKeyValue() t.Logf("key=[%s], value=[%s]", string(key), string(value)) numKeys++ } testutil.AssertEquals(t, numKeys, 6) }