func TestSaveLoadABlockHead(t *testing.T) { b1 := CreateTestAdminBlock(nil) dbo := NewOverlay(new(mapdb.MapDB)) defer dbo.Close() err := dbo.SaveABlockHead(b1) if err != nil { t.Error(err) } head, err := dbo.FetchABlockHead() if err != nil { t.Error(err) } if head == nil { t.Error("DBlock head is nil") } m1, err := b1.MarshalBinary() if err != nil { t.Error(err) } m2, err := head.MarshalBinary() if err != nil { t.Error(err) } if primitives.AreBytesEqual(m1, m2) == false { t.Error("Blocks are not equal") } b2 := CreateTestAdminBlock(b1) err = dbo.SaveABlockHead(b2) if err != nil { t.Error(err) } head, err = dbo.FetchABlockHead() if err != nil { t.Error(err) } if head == nil { t.Error("DBlock head is nil") } m1, err = b2.MarshalBinary() if err != nil { t.Error(err) } m2, err = head.MarshalBinary() if err != nil { t.Error(err) } if primitives.AreBytesEqual(m1, m2) == false { t.Error("Blocks are not equal") } }
func TestECBlockHashingConsistency(t *testing.T) { ecb := createECBlock() h1, err := ecb.Hash() if err != nil { t.Error(err) } k1, err := ecb.HeaderHash() if err != nil { t.Error(err) } h2, err := ecb.Hash() if err != nil { t.Error(err) } k2, err := ecb.HeaderHash() if err != nil { t.Error(err) } if primitives.AreBytesEqual(h1.Bytes(), h2.Bytes()) == false { t.Error("ecb.Hash()es are not equal") } if primitives.AreBytesEqual(k1.Bytes(), k2.Bytes()) == false { t.Error("ecb.HeaderHash()es are not equal") } }
func TestInsertFetch(t *testing.T) { dbo := createOverlay() defer dbo.Close() b := NewDBTestObject() b.Data = []byte{0x00, 0x01, 0x02, 0x03} err := dbo.Insert(TestBucket, b) if err != nil { t.Error(err) } index := b.DatabasePrimaryIndex() b2 := NewDBTestObject() resp, err := dbo.FetchBlock(TestBucket, index, b2) if err != nil { t.Error(err) } if resp == nil { t.Error("Response is nil while it shouldn't be.") } bResp := resp.(*DBTestObject) bytes1 := b.Data bytes2 := bResp.Data if primitives.AreBytesEqual(bytes1, bytes2) == false { t.Errorf("Bytes are not equal - %x vs %x", bytes1, bytes2) } }
func TestSignature(t *testing.T) { pub, priv, err := ed25519.GenerateKey(rand.Reader) if err != nil { t.Error(err) } t.Logf("priv, pub - %x, %x", *priv, *pub) testData := []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07} sig := ed25519.Sign(priv, testData) ok := ed25519.Verify(pub, testData, sig) if ok == false { t.Error("Signature could not be verified") } pub2, err := primitives.PrivateKeyToPublicKey(priv[:]) if err != nil { t.Error(err) } t.Logf("pub1 - %x", pub) t.Logf("pub2 - %x", pub2) if primitives.AreBytesEqual(pub[:], pub2[:]) == false { t.Error("Public keys are not equal") } }
func TestAppendExtIDs(t *testing.T) { ids := [][]byte{ []byte{0x01, 0x02}, []byte{0x03, 0x04}, []byte{0x05, 0x06}, []byte{0x07, 0x08}, []byte{0x09, 0x0a}, } appended := []byte{ 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, } resp, err := AppendExtIDs(ids, 1, 4) if err != nil { t.Errorf("%v", err) } if primitives.AreBytesEqual(resp, appended) == false { t.Errorf("AppendExtIDs are not equal - %x vs %x", resp, appended) } resp, err = AppendExtIDs(ids, 1, 5) if err == nil { t.Error("Err is not when it should not be") } if resp != nil { t.Error("Resp is not nil when it should be") } }
func TestFetchECTransactionByHash(t *testing.T) { blocks := CreateFullTestBlockSet() dbo := CreateAndPopulateTestDatabaseOverlay() for _, block := range blocks { for _, tx := range block.ECBlock.GetEntries() { if tx.ECID() != entryCreditBlock.ECIDChainCommit && tx.ECID() != entryCreditBlock.ECIDEntryCommit || tx.ECID() == entryCreditBlock.ECIDBalanceIncrease { continue } dTx, err := dbo.FetchECTransaction(tx.Hash()) if err != nil { t.Errorf("%v", err) } if dTx == nil { t.Errorf("Tx %v not found!", tx.Hash().String()) continue } h1, err := tx.MarshalBinary() if err != nil { t.Errorf("%v", err) } h2, err := dTx.MarshalBinary() if err != nil { t.Errorf("%v", err) } if primitives.AreBytesEqual(h1, h2) == false { t.Error("Returned transactions are not equal") } } } }
func TestMarshalUnmarshalAnchorRecordV2(t *testing.T) { record := `{"AnchorRecordVer":1,"DBHeight":5,"KeyMR":"980ab6d50d9fad574ad4df6dba06a8c02b1c67288ee5beab3fbfde2723f73ef6","RecordHeight":6,"Bitcoin":{"Address":"1K2SXgApmo9uZoyahvsbSanpVWbzZWVVMF","TXID":"e2ac71c9c0fd8edc0be8c0ba7098b77fb7d90dcca755d5b9348116f3f9d9f951","BlockHeight":372576,"BlockHash":"000000000000000003059382ed4dd82b2086e99ec78d1b6e811ebb9d53d8656d","Offset":1144}}` ar, err := UnmarshalAnchorRecord([]byte(record)) if err != nil { t.Error(err) } priv := "ec9f1cefa00406b80d46135a53504f1f4182d4c0f3fed6cca9281bc020eff973" pk1, err := primitives.NewPrivateKeyFromHex(priv) if err != nil { t.Error(err) } data, sig, err := ar.MarshalAndSignV2(pk1) if err != nil { t.Error(err) } if primitives.AreBytesEqual([]byte(record), data) == false { t.Errorf("Anchors are not equal\n%s\nvs\n%s", record, string(data)) } ar, valid, err := UnmarshalAndValidateAnchorRecordV2(data, [][]byte{sig}, pk1.Pub) if err != nil { t.Error(err) } if valid != true { t.Errorf("Anchor record is not valid") } if ar == nil { t.Errorf("No anchor record returned!") } }
func TestFetchFactoidTransactionByHash(t *testing.T) { blocks := CreateFullTestBlockSet() dbo := CreateAndPopulateTestDatabaseOverlay() for _, block := range blocks { for _, tx := range block.FBlock.GetTransactions() { dTx, err := dbo.FetchFactoidTransaction(tx.GetHash()) if err != nil { t.Errorf("%v", err) } if dTx == nil { t.Errorf("Tx %v not found!", tx.GetHash().String()) continue } h1, err := tx.MarshalBinary() if err != nil { t.Errorf("%v", err) } h2, err := dTx.MarshalBinary() if err != nil { t.Errorf("%v", err) } if primitives.AreBytesEqual(h1, h2) == false { t.Error("Returned transactions are not equal") } } } }
func TestRCDAddress(t *testing.T) { priv := NewPrivKey(0) rcd := NewFactoidRCDAddress(0) pub := rcd.(*factoid.RCD_1).GetPublicKey() //pub2 := [32]byte{} //copy(pub2[:], pub) pub3 := PrivateKeyToEDPub(priv) if primitives.AreBytesEqual(pub, pub3) == false { t.Error("RCD public keys are not equal") } }
func TestCommitMarshalUnmarshal(t *testing.T) { blocks := testHelper.CreateFullTestBlockSet() for _, block := range blocks { for _, tx := range block.ECBlock.GetEntries() { h1, err := tx.MarshalBinary() if err != nil { t.Errorf("Error marshalling - %v", err) } var h2 []byte var e interfaces.BinaryMarshallable switch tx.ECID() { case ECIDChainCommit: e = new(CommitChain) break case ECIDEntryCommit: e = new(CommitEntry) break case ECIDBalanceIncrease: e = new(IncreaseBalance) break case ECIDMinuteNumber: e = new(MinuteNumber) break case ECIDServerIndexNumber: e = new(ServerIndexNumber) break default: t.Error("Wrong ECID") break } h2, err = e.UnmarshalBinaryData(h1) if err != nil { t.Logf("Tried to unmarshal %x", h1) t.Errorf("Error unmarshalling - %v", err) continue } if len(h2) > 0 { t.Errorf("Leftovers from unmarshalling - %x", h2) } h2, err = e.MarshalBinary() if err != nil { t.Errorf("Error marshalling2 - %v", err) continue } if primitives.AreBytesEqual(h1, h2) == false { t.Error("ECEntries are not identical - %x vs %x", h1, h2) } } } }
func (d1 *DBTestObject) IsEqual(d2 *DBTestObject) bool { if d1.DatabaseHeight != d2.DatabaseHeight { return false } if primitives.AreBytesEqual(d1.Data, d2.Data) == false { return false } if primitives.AreBytesEqual(d1.PrimaryIndex.Bytes(), d2.PrimaryIndex.Bytes()) == false { return false } if primitives.AreBytesEqual(d1.SecondaryIndex.Bytes(), d2.SecondaryIndex.Bytes()) == false { return false } if primitives.AreBytesEqual(d1.ChainID.Bytes(), d2.ChainID.Bytes()) == false { return false } return true }
func (a *CommitChain) IsSameAs(b *CommitChain) bool { if b == nil { return false } bin1, err := a.MarshalBinary() if err != nil { return false } bin2, err := b.MarshalBinary() if err != nil { return false } return primitives.AreBytesEqual(bin1, bin2) }
func TestMarshalUnmarshalAnchorRecord(t *testing.T) { record := `{"AnchorRecordVer":1,"DBHeight":5,"KeyMR":"980ab6d50d9fad574ad4df6dba06a8c02b1c67288ee5beab3fbfde2723f73ef6","RecordHeight":6,"Bitcoin":{"Address":"1K2SXgApmo9uZoyahvsbSanpVWbzZWVVMF","TXID":"e2ac71c9c0fd8edc0be8c0ba7098b77fb7d90dcca755d5b9348116f3f9d9f951","BlockHeight":372576,"BlockHash":"000000000000000003059382ed4dd82b2086e99ec78d1b6e811ebb9d53d8656d","Offset":1144}}` ar, err := UnmarshalAnchorRecord([]byte(record)) if err != nil { t.Error(err) } data, err := ar.Marshal() if err != nil { t.Error(err) } if primitives.AreBytesEqual([]byte(record), data) == false { t.Errorf("Anchors are not equal\n%s\nvs\n%s", record, string(data)) } }
func TestMarshalUnmarshal(t *testing.T) { rawStr := "000000000000000000000000000000000000000000000000000000000000000f16a82932aa64e6ad45b2749f2abb871fcf3353ab9d4e163c9bd90e5bbd745b59a164ccbb77a21904edc4f2bb753aa60635fb2b60279c06ae01aa211f375417362fb170f73c3961d4218ff806dd75e6e348ca1798a5fc7a99d443fbe2ff939d9900000000000a2be8000000010000000002000000c702014f8a7fcd1b00000002014f8a851657010001e397a1607d4f56c528ab09da5bbf7b37b0b453f43db303730e28e9ebe02657dff431d4f7dfaf840017ef7a21d1a616d65e6b73f3c6a7ad5c49340a6c2592872020ec60767ff00d7d01a5be79b6ada79c0af4d6b7f91234ff321f3b647ed01e02ccbbc0fe9dcc63293482f22455b9756ee4b4db411a5d00e31b689c1bd1abe1d1e887cf4c52e67fc51fe4d9594c24643a91009c6ea91701b5b6df240248c2f39453162b61d71b98270100000000000000000000" raw, err := hex.DecodeString(rawStr) if err != nil { t.Errorf("%v", err) } f := new(FBlock) rest, err := f.UnmarshalBinaryData(raw) if err != nil { t.Errorf("%v", err) } if len(rest) > 0 { t.Errorf("Returned too much data - %x", rest) } b, err := f.MarshalBinary() if err != nil { t.Errorf("%v", err) } if primitives.AreBytesEqual(raw, b) == false { t.Errorf("Marshalled bytes are not equal - %x vs %x", raw, b) } //f.CalculateHashes() if f.DatabasePrimaryIndex().String() != "aa100f203f159e4369081bb366f6816b302387ec19a4f8b9c98495d97fbe3527" { t.Errorf("Wrong PrimaryIndex - %v vs %v", f.DatabasePrimaryIndex().String(), "aa100f203f159e4369081bb366f6816b302387ec19a4f8b9c98495d97fbe3527") } if f.DatabaseSecondaryIndex().String() != "5810ed83155dfb7b6039323b8a5572cd03166a37d1c3e86d4538c99907a81757" { t.Errorf("Wrong SecondaryIndex - %v vs %v", f.DatabaseSecondaryIndex().String(), "5810ed83155dfb7b6039323b8a5572cd03166a37d1c3e86d4538c99907a81757") } err = f.Validate() if err != nil { t.Errorf("%v", err) } }
func (a *DataResponse) IsSameAs(b *DataResponse) bool { if b == nil { return false } if a.Timestamp.GetTimeMilli() != b.Timestamp.GetTimeMilli() { return false } if a.DataType != b.DataType { return false } if a.DataHash == nil && b.DataHash != nil { return false } if a.DataHash != nil { if a.DataHash.IsSameAs(b.DataHash) == false { return false } } if a.DataObject == nil && b.DataObject != nil { return false } if a.DataObject != nil { hex1, err := a.DataObject.MarshalBinary() if err != nil { return false } hex2, err := b.DataObject.MarshalBinary() if err != nil { return false } if primitives.AreBytesEqual(hex1, hex2) == false { return false } } return true }
func TestMultiBatch(t *testing.T) { dbo := NewOverlay(new(mapdb.MapDB)) var prev *testHelper.BlockSet = nil var err error for i := 0; i < 10; i++ { dbo.StartMultiBatch() prev = testHelper.CreateTestBlockSet(prev) err = dbo.ProcessABlockMultiBatch(prev.ABlock) if err != nil { t.Error(err) } err = dbo.ProcessEBlockMultiBatch(prev.EBlock, true) if err != nil { t.Error(err) } err = dbo.ProcessEBlockMultiBatch(prev.AnchorEBlock, true) if err != nil { t.Error(err) } err = dbo.ProcessECBlockMultiBatch(prev.ECBlock, false) if err != nil { t.Error(err) } err = dbo.ProcessFBlockMultiBatch(prev.FBlock) if err != nil { t.Error(err) } err = dbo.ProcessDBlockMultiBatch(prev.DBlock) if err != nil { t.Error(err) } for _, entry := range prev.Entries { err = dbo.InsertEntryMultiBatch(entry) if err != nil { t.Error(err) } } if err := dbo.ExecuteMultiBatch(); err != nil { t.Error(err) } } ahead, err := dbo.FetchABlockHead() if err != nil { t.Error(err) } if ahead == nil { t.Error("DBlock head is nil") } m1, err := prev.ABlock.MarshalBinary() if err != nil { t.Error(err) } m2, err := ahead.MarshalBinary() if err != nil { t.Error(err) } if primitives.AreBytesEqual(m1, m2) == false { t.Error("ABlocks are not equal") } fhead, err := dbo.FetchFBlockHead() if err != nil { t.Error(err) } if fhead == nil { t.Error("DBlock head is nil") } m1, err = prev.FBlock.MarshalBinary() if err != nil { t.Error(err) } m2, err = fhead.MarshalBinary() if err != nil { t.Error(err) } if primitives.AreBytesEqual(m1, m2) == false { t.Error("FBlocks are not equal") } echead, err := dbo.FetchECBlockHead() if err != nil { t.Error(err) } if echead == nil { t.Error("DBlock head is nil") } m1, err = prev.ECBlock.MarshalBinary() if err != nil { t.Error(err) } m2, err = echead.MarshalBinary() if err != nil { t.Error(err) } if primitives.AreBytesEqual(m1, m2) == false { t.Error("ECBlocks are not equal") } dhead, err := dbo.FetchDBlockHead() if err != nil { t.Error(err) } if dhead == nil { t.Error("DBlock head is nil") } m1, err = prev.DBlock.MarshalBinary() if err != nil { t.Error(err) } m2, err = dhead.MarshalBinary() if err != nil { t.Error(err) } if primitives.AreBytesEqual(m1, m2) == false { t.Error("DBlocks are not equal") } }
func TestSaveLoadEBlockHead(t *testing.T) { b1, _ := CreateTestEntryBlock(nil) chain, err := primitives.NewShaHash(b1.GetChainID().Bytes()) if err != nil { t.Error(err) } dbo := NewOverlay(new(mapdb.MapDB)) defer dbo.Close() err = dbo.SaveEBlockHead(b1, false) if err != nil { t.Error(err) } head, err := dbo.FetchEBlockHead(chain) if err != nil { t.Error(err) } if head == nil { t.Error("DBlock head is nil") } m1, err := b1.MarshalBinary() if err != nil { t.Error(err) } m2, err := head.MarshalBinary() if err != nil { t.Error(err) } if primitives.AreBytesEqual(m1, m2) == false { t.Error("Blocks are not equal") } b2, _ := CreateTestEntryBlock(b1) err = dbo.SaveEBlockHead(b2, false) if err != nil { t.Error(err) } head, err = dbo.FetchEBlockHead(chain) if err != nil { t.Error(err) } if head == nil { t.Error("DBlock head is nil") } m1, err = b2.MarshalBinary() if err != nil { t.Error(err) } m2, err = head.MarshalBinary() if err != nil { t.Error(err) } if primitives.AreBytesEqual(m1, m2) == false { t.Error("Blocks are not equal") } }
func TestSaveLoadEntries(t *testing.T) { dbo := NewOverlay(new(mapdb.MapDB)) defer dbo.Close() entries := []*entryBlock.Entry{} firstEntry := CreateFirstTestEntry() err := dbo.InsertEntry(firstEntry) if err != nil { t.Error(err) } entries = append(entries, firstEntry) max := 10 for i := 0; i < max; i++ { entry := CreateTestEntry(uint32(i)) err = dbo.InsertEntry(entry) if err != nil { t.Error(err) } entries = append(entries, entry) } for _, entry := range entries { loaded, err := dbo.FetchEntry(entry.GetHash()) if err != nil { t.Error(err) } m1, err := entry.MarshalBinary() if err != nil { t.Error(err) } m2, err := loaded.MarshalBinary() if err != nil { t.Error(err) } if primitives.AreBytesEqual(m1, m2) == false { t.Error("Entries are not equal") } } all, err := dbo.FetchAllEntriesByChainID(firstEntry.GetChainIDHash()) if err != nil { t.Error(err) } if len(entries) != len(all) { t.Errorf("Loaded %v out of %v entries", len(all), len(entries)) } foundCount := 0 for _, entry := range entries { found := false for _, loaded := range all { if entry.GetHash().IsSameAs(loaded.GetHash()) { found = true m1, err := entry.MarshalBinary() if err != nil { t.Error(err) } m2, err := loaded.MarshalBinary() if err != nil { t.Error(err) } if primitives.AreBytesEqual(m1, m2) == false { t.Error("Entries are not equal") } break } } if found == false { t.Error("Entry %v not found", entry) } else { foundCount++ } } if foundCount != len(entries) { t.Errorf("Found %v out of %v entries", foundCount, len(entries)) } }
func TestFetchBy(t *testing.T) { dbo := createOverlay() defer dbo.Close() blocks := []*DBTestObject{} max := 10 for i := 0; i < max; i++ { b := NewDBTestObject() b.ChainID = primitives.NewHash(CopyZeroHash()) b.Data = []byte{byte(i), byte(i + 1), byte(i + 2), byte(i + 3)} primaryIndex := CopyZeroHash() primaryIndex[len(primaryIndex)-1] = byte(i) secondaryIndex := CopyZeroHash() secondaryIndex[0] = byte(i) b.PrimaryIndex = primitives.NewHash(primaryIndex) b.SecondaryIndex = primitives.NewHash(secondaryIndex) b.DatabaseHeight = uint32(i) blocks = append(blocks, b) err := dbo.ProcessBlockBatch(TestBucket, TestNumberBucket, TestSecondaryIndexBucket, b) if err != nil { t.Error(err) } } headIndex, err := dbo.FetchHeadIndexByChainID(primitives.NewHash(CopyZeroHash())) if err != nil { t.Error(err) } if headIndex.IsSameAs(blocks[max-1].PrimaryIndex) == false { t.Error("Wrong chain head") } head, err := dbo.FetchChainHeadByChainID(TestBucket, primitives.NewHash(CopyZeroHash()), new(DBTestObject)) if err != nil { t.Error(err) } if blocks[max-1].IsEqual(head.(*DBTestObject)) == false { t.Error("Heads are not equal") } for i := 0; i < max; i++ { primaryIndex := CopyZeroHash() primaryIndex[len(primaryIndex)-1] = byte(i) secondaryIndex := CopyZeroHash() secondaryIndex[0] = byte(i) dbHeight := uint32(i) block, err := dbo.FetchBlockByHeight(TestNumberBucket, TestBucket, dbHeight, new(DBTestObject)) if err != nil { t.Error(err) } if blocks[i].IsEqual(block.(*DBTestObject)) == false { t.Error("Blocks are not equal") } index, err := dbo.FetchBlockIndexByHeight(TestNumberBucket, dbHeight) if err != nil { t.Error(err) } if primitives.AreBytesEqual(index.Bytes(), primaryIndex) == false { t.Error("Wrong primary index returned") } index, err = dbo.FetchPrimaryIndexBySecondaryIndex(TestSecondaryIndexBucket, primitives.NewHash(secondaryIndex)) if err != nil { t.Error(err) } if primitives.AreBytesEqual(index.Bytes(), primaryIndex) == false { t.Error("Wrong primary index returned") } block, err = dbo.FetchBlockBySecondaryIndex(TestSecondaryIndexBucket, TestBucket, primitives.NewHash(secondaryIndex), new(DBTestObject)) if err != nil { t.Error(err) } if blocks[i].IsEqual(block.(*DBTestObject)) == false { t.Error("Blocks are not equal") } } fetchedBlocks, err := dbo.FetchAllBlocksFromBucket(TestBucket, new(DBTestObject)) if err != nil { t.Error(err) } if len(fetchedBlocks) != len(blocks) { t.Error("Invalid amount of blocks returned") } for i := 0; i < max; i++ { if blocks[i].IsEqual(fetchedBlocks[i].(*DBTestObject)) == false { t.Error("Block from batch is not equal") } } startIndex := 3 indexCount := 4 fetchedIndexes, err := dbo.FetchBlockIndexesInHeightRange(TestNumberBucket, int64(startIndex), int64(startIndex+indexCount)) if len(fetchedIndexes) != indexCount { t.Error("Invalid amount of indexes returned") } for i := 0; i < indexCount; i++ { primaryIndex := CopyZeroHash() primaryIndex[len(primaryIndex)-1] = byte(i + startIndex) if primitives.AreBytesEqual(primaryIndex, fetchedIndexes[i].Bytes()) == false { t.Error("Index from batch is not equal") } } }