public void Should_Reconcile_On_New_Delta_Hash()
{
var hash1 = _hashProvider.ComputeUtf8MultiHash("update");
var hash2 = _hashProvider.ComputeUtf8MultiHash("update again");
var updates = new[] { hash1, hash2 };
_ledgerSynchroniser.CacheDeltasBetween(default, default, default)
public async Task GetHighestDeltaIndexAsync_Should_Return_DeltaIndex()
{
var deltaHeight = 100u;
GeneratePeers(100);
_peerClient.When(x => x.SendMessageToPeers(Arg.Any <IMessage>(), Arg.Any <IEnumerable <PeerId> >())).Do(x =>
{
var peerIds = (IEnumerable <PeerId>)x[1];
foreach (var peerId in peerIds)
{
var deltaHeightResponse = new LatestDeltaHashResponse
{
DeltaIndex = new DeltaIndex {
Cid = _hashProvider.ComputeUtf8MultiHash(deltaHeight.ToString()).ToCid().ToArray().ToByteString(), Height = deltaHeight
},
IsSync = true
};
_deltaHeightReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
deltaHeightResponse.ToProtocolMessage(peerId, CorrelationId.GenerateCorrelationId())));
}
});
var deltaHeightWatcher = new DeltaHeightWatcher(_peerClient, _peerRepository, _peerService, minimumPeers: 0);
deltaHeightWatcher.Start();
var deltaIndex = await deltaHeightWatcher.GetHighestDeltaIndexAsync();
deltaIndex.Height.Should().Be(deltaHeight);
}
public void HandleBroadcast_Should_Cast_Hashes_To_Multihash_And_Try_Update()
{
var newHash = _hashProvider.ComputeUtf8MultiHash("newHash").CreateCid();
var prevHash = _hashProvider.ComputeUtf8MultiHash("prevHash").CreateCid();
var receivedMessage = PrepareReceivedMessage(newHash.ToArray(), prevHash.ToArray());
var deltaDfsHashObserver = new DeltaDfsHashObserver(_deltaHashProvider, _logger);
deltaDfsHashObserver.HandleBroadcast(receivedMessage);
_deltaHashProvider.Received(1).TryUpdateLatestHash(prevHash, newHash);
}
public void TryReadDeltaFromDfs_Should_Return_False_And_Log_When_Hash_Not_Found_On_Dfs()
{
var exception = new FileNotFoundException("that hash is not good");
_dfs.ReadAsync(Arg.Any <Cid>(), Arg.Any <CancellationToken>())
.Throws(exception);
var cid = _hashProvider.ComputeUtf8MultiHash("bad hash").CreateCid();
_dfsReader.TryReadDeltaFromDfs(cid, out _, CancellationToken.None).Should().BeFalse();
_logger.Received(1).Error(exception,
Arg.Any <string>(),
Arg.Is <Cid>(s => s == cid));
}
public LedgerTests()
{
_testScheduler = new TestScheduler();
_fakeRepository = Substitute.For <IAccountRepository>();
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_mapperProvider = new TestMapperProvider();
_logger = Substitute.For <ILogger>();
_mempool = Substitute.For <IMempool <PublicEntryDao> >();
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_receipts = Substitute.For <ITransactionRepository>();
_synchroniser = Substitute.For <ISynchroniser>();
_genesisHash = _hashProvider.ComputeUtf8MultiHash("genesis").ToCid();
_synchroniser.DeltaCache.GenesisHash.Returns(_genesisHash);
_executor = Substitute.For <IDeltaExecutor>();
_stateProvider = Substitute.For <IStateProvider>();
_storageProvider = Substitute.For <IStorageProvider>();
_cryptoContext = new FfiWrapper();
_signingContext = new SigningContext
{
NetworkType = NetworkType.Devnet,
SignatureType = SignatureType.TransactionPublic
};
_deltaIndexService = new DeltaIndexService(new InMemoryRepository <DeltaIndexDao, string>());
}
public void Successful_Add_File_Can_Respond_With_Finished_Code()
{
_nodeFileTransferFactory.RegisterTransfer(Arg.Any <IDownloadFileInformation>())
.Returns(FileTransferResponseCodeTypes.Successful);
var expectedCid = _hashProvider.ComputeUtf8MultiHash("expectedHash").ToCid();
var fakeBlock = Substitute.For <IFileSystemNode>();
fakeBlock.Id.Returns(expectedCid);
_fakeDfsService.UnixFsApi.AddAsync(Arg.Any <Stream>(), Arg.Any <string>(), Arg.Any <AddFileOptions>()).Returns(fakeBlock);
var protocolMessage = GenerateProtocolMessage();
AddFileToDfsResponse addFileToDfsResponse = null;
async void UseArgument(IDownloadFileInformation information)
{
information.RecipientChannel = Substitute.For <IChannel>();
information.UpdateChunkIndicator(0, true);
information.Dispose();
await information.RecipientChannel.WriteAndFlushAsync(Arg.Do <MessageDto>(x =>
{
addFileToDfsResponse = x.Content.FromProtocolMessage <AddFileToDfsResponse>();
_manualResetEvent.Set();
}));
}
_nodeFileTransferFactory.RegisterTransfer(Arg.Do <IDownloadFileInformation>(UseArgument));
protocolMessage.SendToHandler(_fakeContext, _addFileToDfsRequestObserver);
_manualResetEvent.WaitOne();
addFileToDfsResponse.ResponseCode[0].Should().Be((byte)FileTransferResponseCodeTypes.Finished.Id);
addFileToDfsResponse.DfsHash.Should().Be(expectedCid);
}
public void HandleBroadcast_Should_Cast_Hashes_To_Multihash_And_Try_Update()
{
var newHash = _hashProvider.ComputeUtf8MultiHash("newHash").ToCid();
var prevHash = _hashProvider.ComputeUtf8MultiHash("prevHash").ToCid();
var receivedMessage = PrepareReceivedMessage(newHash.ToArray(), prevHash.ToArray());
_peerRepository.GetPeersByIpAndPublicKey(receivedMessage.Payload.PeerId.Ip, receivedMessage.Payload.PeerId.PublicKey).Returns(new List <Peer>()
{
new Peer()
});
var deltaDfsHashObserver = new DeltaDfsHashObserver(_deltaHashProvider, _syncState, _peerRepository, _logger);
deltaDfsHashObserver.HandleBroadcast(receivedMessage);
_deltaHashProvider.Received(1).TryUpdateLatestHash(prevHash, newHash);
}
public DeltaBuilderTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_random = new Random();
_randomFactory = Substitute.For <IDeterministicRandomFactory>();
_randomFactory.GetDeterministicRandomFromSeed(Arg.Any <byte[]>())
.Returns(ci => new IsaacRandom(((byte[])ci[0]).ToHex()));
_producerId = PeerIdHelper.GetPeerId("producer");
_peerSettings = _producerId.ToSubstitutedPeerSettings();
_previousDeltaHash = _hashProvider.ComputeUtf8MultiHash("previousDelta").CreateCid();
_zeroCoinbaseEntry = new CoinbaseEntry
{
Amount = UInt256.Zero.ToUint256ByteString(),
ReceiverPublicKey = _producerId.PublicKey.ToByteString()
};
_logger = Substitute.For <ILogger>();
_cache = Substitute.For <IDeltaCache>();
_dateTimeProvider = new DateTimeProvider();
}
public async Task GetDeltaRequestObserver_Should_Send_Response_When_Delta_Found_In_Cache()
{
var cid = _hashProvider.ComputeUtf8MultiHash("abcd").CreateCid();
var delta = CreateAndExpectDeltaFromCache(cid);
var observable = CreateStreamWithDeltaRequest(cid);
_observer.StartObserving(observable);
_testScheduler.Start();
_deltaCache.Received(1).TryGetOrAddConfirmedDelta(Arg.Is <Cid>(
s => s.Equals(cid)), out Arg.Any <Delta>());
await _fakeContext.Channel.ReceivedWithAnyArgs(1)
.WriteAndFlushAsync(Arg.Is <IMessageDto <ProtocolMessage> >(pm =>
pm.Content.FromProtocolMessage <GetDeltaResponse>().Delta.PreviousDeltaDfsHash ==
delta.PreviousDeltaDfsHash));
}
public void Should_Reconcile_On_New_Delta_Hash()
{
var hash1 = _hashProvider.ComputeUtf8MultiHash("update").ToCid();
var hash2 = _hashProvider.ComputeUtf8MultiHash("update again").ToCid();
var updates = new[] { hash1, hash2 };
_synchroniser.CacheDeltasBetween(Arg.Is(_genesisHash), Arg.Is(hash1), default)
.ReturnsForAnyArgs(new[] { hash2, hash1, _genesisHash });
_deltaHashProvider.DeltaHashUpdates.Returns(updates.ToObservable(_testScheduler));
_ledger = new Ledger(_executor, _stateProvider, _storageProvider, new StateDb(), new StateDb(),
_fakeRepository, _deltaIndexService, _receipts, _deltaHashProvider, _synchroniser, _mempool, _mapperProvider, _hashProvider, _logger);
_testScheduler.Start();
_ledger.LatestKnownDelta.Should().Be(_genesisHash);
}
public void Init()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_random = new Random(1);
_randomFactory = Substitute.For <IDeterministicRandomFactory>();
_randomFactory.GetDeterministicRandomFromSeed(Arg.Any <byte[]>())
.Returns(ci => new IsaacRandom(((byte[])ci[0]).ToHex()));
_producerId = PeerIdHelper.GetPeerId("producer");
_peerSettings = _producerId.ToSubstitutedPeerSettings();
_previousDeltaHash = _hashProvider.ComputeUtf8MultiHash("previousDelta").ToCid();
_zeroCoinbaseEntry = new CoinbaseEntry
{
Amount = UInt256.Zero.ToUint256ByteString(),
ReceiverPublicKey = _producerId.PublicKey.ToByteString()
};
_logger = Substitute.For <ILogger>();
_cache = Substitute.For <IDeltaCache>();
Delta previousDelta = new Delta();
previousDelta.StateRoot = ByteString.CopyFrom(Keccak.EmptyTreeHash.Bytes);
_cache.TryGetOrAddConfirmedDelta(Arg.Any <Cid>(), out Arg.Any <Delta>()).Returns(x =>
{
x[1] = previousDelta;
return(true);
});
_dateTimeProvider = new DateTimeProvider();
IDb codeDb = new MemDb();
ISnapshotableDb stateDb = new StateDb();
ISpecProvider specProvider = new CatalystSpecProvider();
_cryptoContext = new FfiWrapper();
_stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
IStorageProvider storageProvider = new StorageProvider(stateDb, _stateProvider, LimboLogs.Instance);
KatVirtualMachine virtualMachine = new KatVirtualMachine(_stateProvider,
storageProvider,
new StateUpdateHashProvider(),
specProvider,
new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256")),
new FfiWrapper(),
LimboLogs.Instance);
_deltaExecutor = new DeltaExecutor(specProvider,
_stateProvider,
storageProvider,
virtualMachine,
_cryptoContext,
_logger);
}
private MultiHash AddFileToDfs(long byteSize, out long crcValue, out Stream stream)
{
var fileToTransfer = FileHelper.CreateRandomTempFile(byteSize);
var fakeId = _hashProvider.ComputeUtf8MultiHash(CorrelationId.GenerateCorrelationId().ToString());
crcValue = FileHelper.GetCrcValue(fileToTransfer);
stream = new MemoryStream(File.ReadAllBytes(fileToTransfer));
_dfsService.UnixFsApi.ReadFileAsync(fakeId.ToString()).Returns(stream);
return(fakeId);
}
/// <inheritdoc />
public async Task <Cid> AddTextAsync(string utf8Content, CancellationToken cancellationToken = default)
{
var cid = _hashProvider.ComputeUtf8MultiHash(utf8Content).CreateCid();
var filePath = Path.Combine(_baseFolder.FullName, cid);
await _fileSystem.File.WriteAllTextAsync(
filePath,
utf8Content, Encoding.UTF8, cancellationToken);
return(cid);
}
private IObserverDto <ProtocolMessage> GetFileFromDfsRequestMessage()
{
var getFileFromDfsRequestMessage = new GetFileFromDfsRequest
{
DfsHash = _hashProvider.ComputeUtf8MultiHash("test").ToBase32()
};
var protocolMessage = getFileFromDfsRequestMessage
.ToProtocolMessage(PeerIdHelper.GetPeerId("TestMan"), CorrelationId.GenerateCorrelationId());
return(new ObserverDto(Substitute.For <IChannelHandlerContext>(), protocolMessage));
}
private DeltaHistoryResponse GenerateSampleData(int height, int range, int maxHeight = -1)
{
var deltaHeightResponse = new DeltaHistoryResponse();
var deltaIndexList = new List <DeltaIndex>();
var heightSum = height + range;
if (heightSum > maxHeight)
{
heightSum = maxHeight;
}
for (var i = height; i <= heightSum; i++)
{
deltaIndexList.Add(new DeltaIndex
{
Cid = ByteString.CopyFrom(_hashProvider.ComputeUtf8MultiHash(i.ToString()).ToCid().ToArray()),
Height = (uint)i
});
}
deltaHeightResponse.DeltaIndex.Add(deltaIndexList);
return(deltaHeightResponse);
}
public LedgerTests()
{
_testScheduler = new TestScheduler();
_fakeRepository = Substitute.For <IAccountRepository>();
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_logger = Substitute.For <ILogger>();
_mempool = Substitute.For <IMempool <MempoolDocument> >();
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_ledgerSynchroniser = Substitute.For <ILedgerSynchroniser>();
_genesisHash = _hashProvider.ComputeUtf8MultiHash("genesis");
_ledgerSynchroniser.DeltaCache.GenesisHash.Returns(_genesisHash);
_ledgerSynchroniser.DeltaCache.GenesisAddress.Returns(_genesisHash.ToBase32());
}
public void TryGetDelta_Should_Not_Hit_The_Dfs_Or_Store_Delta_When_Delta_Is_In_Cache()
{
_memoryCache.ClearReceivedCalls(); // needed because of the CreateEntry call from the DeltaCache .ctor
var deltaFromCache = DeltaHelper.GetDelta(_hashProvider);
var cid = CidHelper.CreateCid(_hashProvider.ComputeUtf8MultiHash("abc"));
_memoryCache.TryGetValue(Arg.Is(cid.Hash), out Arg.Any <Delta>())
.Returns(ci =>
{
ci[1] = deltaFromCache;
return(true);
});
var found = _deltaCache.TryGetOrAddConfirmedDelta(cid.Hash, out var delta);
delta.Should().Be(deltaFromCache);
found.Should().BeTrue();
_dfsReader.DidNotReceiveWithAnyArgs().TryReadDeltaFromDfs(default, out _);
public async Task AddTextAsync_Should_Save_File_In_Subfolder_With_Hash_As_Name()
{
var someGoodUtf8Content = "some good utf8 content!";
var cid = await _dfs.AddTextAsync(someGoodUtf8Content);
var expectedCid = _hashProvider.ComputeUtf8MultiHash(someGoodUtf8Content).CreateCid();
await _fileSystem.File.Received(1).WriteAllTextAsync(
Arg.Is(Path.Combine(_baseFolder, expectedCid.Encode())),
Arg.Any <string>(),
Arg.Is(Encoding.UTF8),
Arg.Any <CancellationToken>());
cid.Should().Be(expectedCid);
}
public async Task Can_Populate_Peers_Correctly()
{
var peerRepository = Substitute.For <IPeerRepository>();
var pubkey = _hashProvider.ComputeUtf8MultiHash("hello").ToBase32();
var peers = new[]
{
new PoaPeer {
Ip = "92.207.178.198", Port = 42069, PublicKey = pubkey
},
new PoaPeer {
Ip = "127.0.0.1", Port = 42069, PublicKey = pubkey
}
};
await FileSystem.WriteTextFileToCddAsync(PoaDiscovery.PoaPeerFile, JsonConvert.SerializeObject(peers));
var peerDiscovery = new PoaDiscovery(peerRepository, FileSystem, Substitute.For <ILogger>());
await peerDiscovery.DiscoveryAsync().ConfigureAwait(false);
peerRepository.Received(peers.Length).Add(Arg.Any <Peer>());
}
public void Init()
{
_cancellationToken = new CancellationToken();
_manualResetEventSlim = new ManualResetEventSlim(false);
_testScheduler = new TestScheduler();
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_peerSettings = Substitute.For <IPeerSettings>();
_peerSettings.PeerId.Returns(PeerIdHelper.GetPeerId());
_deltaDfsReader = Substitute.For <IDeltaDfsReader>();
_deltaDfsReader.TryReadDeltaFromDfs(Arg.Any <Cid>(), out Arg.Any <Delta>()).Returns(x => true);
_deltaCache = Substitute.For <IDeltaCache>();
_deltaCache.GenesisHash.Returns("bafk2bzacecji5gcdd6lxsoazgnbg46c3vttjwwkptiw27enachziizhhkir2w".ToCid());
_ledger = Substitute.For <ILedger>();
_peerService = Substitute.For <IPeerService>();
_deltaHashProvider = new DeltaHashProvider(_deltaCache, Substitute.For <IDeltaIndexService>(), Substitute.For <ILogger>());
_deltaIndexService = new DeltaIndexService(new InMemoryRepository <DeltaIndexDao, string>());
_deltaIndexService.Add(new DeltaIndexDao {
Cid = _hashProvider.ComputeUtf8MultiHash("0").ToCid(), Height = 0
});
_peerClient = Substitute.For <IPeerClient>();
ModifyPeerClient <LatestDeltaHashRequest>((request, senderPeerIdentifier) =>
{
var deltaHeightResponse = new LatestDeltaHashResponse
{
DeltaIndex = new DeltaIndex
{
Cid = _hashProvider.ComputeUtf8MultiHash(_syncTestHeight.ToString()).ToCid().ToArray()
.ToByteString(),
Height = (uint)_syncTestHeight
}
};
_deltaHeightReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
deltaHeightResponse.ToProtocolMessage(senderPeerIdentifier, CorrelationId.GenerateCorrelationId())));
});
ModifyPeerClient <DeltaHistoryRequest>((request, senderPeerIdentifier) =>
{
var data = GenerateSampleData((int)request.Height, (int)request.Range, (int)_syncTestHeight);
_deltaIndexService.Add(data.DeltaIndex.Select(x => DeltaIndexDao.ToDao <DeltaIndex>(x, _mapperProvider)));
_deltaHistoryReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
data
.ToProtocolMessage(senderPeerIdentifier, CorrelationId.GenerateCorrelationId())));
});
_peerRepository = new PeerRepository(new InMemoryRepository <Peer, string>());
Enumerable.Repeat(new Peer {
PeerId = PeerIdHelper.GetPeerId()
}, 5).ToList().ForEach(_peerRepository.Add);
_deltaHeightReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
_deltaHistoryReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
var mergeMessageStreams = _deltaHeightReplaySubject.AsObservable()
.Merge(_deltaHistoryReplaySubject.AsObservable());
_peerService.MessageStream.Returns(mergeMessageStreams);
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_deltaHashProvider.TryUpdateLatestHash(Arg.Any <Cid>(), Arg.Any <Cid>()).Returns(true);
_mapperProvider = new TestMapperProvider();
_userOutput = Substitute.For <IUserOutput>();
_deltaHeightWatcher = new DeltaHeightWatcher(_peerClient, _peerRepository, _peerService, minimumPeers: 0);
var dfsService = Substitute.For <IDfsService>();
_peerSyncManager = new PeerSyncManager(_peerClient, _peerRepository,
_peerService, _userOutput, _deltaHeightWatcher, Substitute.For <IDfsService>(), 0.7, 0);
}
