public void Init()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_deltaVoter = Substitute.For <IDeltaVoter>();
_fakeChannelContext = Substitute.For <IChannelHandlerContext>();
var logger = Substitute.For <ILogger>();
_newHash = hashProvider.ComputeUtf8MultiHash("newHash").ToCid();
_prevHash = hashProvider.ComputeUtf8MultiHash("prevHash").ToCid();
_producerId = PeerIdHelper.GetPeerId("candidate delta producer");
var peerRepository = Substitute.For <IPeerRepository>();
peerRepository.GetPeersByIpAndPublicKey(Arg.Any <ByteString>(), Arg.Any <ByteString>()).Returns(new List <Lib.P2P.Models.Peer> {
new Lib.P2P.Models.Peer()
});
var deltaIndexService = Substitute.For <IDeltaIndexService>();
deltaIndexService.LatestDeltaIndex().Returns(new Lib.DAO.Ledger.DeltaIndexDao()
{
Cid = _prevHash, Height = 0
});
_candidateDeltaObserver = new CandidateDeltaObserver(_deltaVoter, deltaIndexService, new SyncState()
{
IsSynchronized = true
}, peerRepository, hashProvider, logger);
}
public async Task ReadAsync_Should_Rely_On_IpfsEngine_And_Return_Streamed_Content()
{
var cid = CidHelper.CreateCid(_hashProvider.ComputeUtf8MultiHash("file"));
_ipfsEngine.FileSystem
.ReadFileAsync(cid.Encode(), Arg.Any <CancellationToken>())
.Returns(c => "the content".ToMemoryStream());
using (var stream = await _dfs.ReadAsync(cid.Encode()))
{
stream.ReadAllAsUtf8String(false).Should().Be("the content");
}
}
public CandidateDeltaObserverTests()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_deltaVoter = Substitute.For <IDeltaVoter>();
_fakeChannelContext = Substitute.For <IChannelHandlerContext>();
var logger = Substitute.For <ILogger>();
_newHash = hashProvider.ComputeUtf8MultiHash("newHash").CreateCid();
_prevHash = hashProvider.ComputeUtf8MultiHash("prevHash").CreateCid();
_producerId = PeerIdHelper.GetPeerId("candidate delta producer");
_candidateDeltaObserver = new CandidateDeltaObserver(_deltaVoter, hashProvider, logger);
}
public CycleEventsProviderTests(ITestOutputHelper output)
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_output = output;
_testScheduler = new TestScheduler();
_schedulerProvider = Substitute.For <ICycleSchedulerProvider>();
_schedulerProvider.Scheduler.Returns(_testScheduler);
_dateTimeProvider = Substitute.For <IDateTimeProvider>();
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_logger = Substitute.For <ILogger>();
_deltaHashProvider.GetLatestDeltaHash(Arg.Any <DateTime>())
.Returns(hashProvider.ComputeUtf8MultiHash("test"));
_dateTimeProvider.UtcNow.Returns(_ => _testScheduler.Now.DateTime);
_cycleProvider = new CycleEventsProvider(CycleConfiguration.Default, _dateTimeProvider, _schedulerProvider,
_deltaHashProvider, _logger);
_spy = Substitute.For <IObserver <IPhase> >();
_stopWatch = _testScheduler.StartStopwatch();
_subscription = _cycleProvider.PhaseChanges.Take(50)
.Subscribe(p =>
{
_output.WriteLine($"{_stopWatch.Elapsed.TotalSeconds} -- {p}");
_spy.OnNext(p);
}, () =>
{
_output.WriteLine($"completed after {_stopWatch.Elapsed.TotalSeconds:g}");
_spy.OnCompleted();
});
}
private Dictionary <Cid, Delta> BuildChainedDeltas(int chainSize)
{
var chainedDeltas = Enumerable.Range(0, chainSize + 1).ToDictionary(
i => _hashProvider.ComputeUtf8MultiHash(i.ToString()).CreateCid(),
i =>
{
var previousHash = _hashProvider.ComputeUtf8MultiHash((i - 1).ToString()).CreateCid();
var delta = DeltaHelper.GetDelta(_hashProvider, previousHash);
return(delta);
});
_output.WriteLine("chain is:");
_output.WriteLine(string.Join(Environment.NewLine,
chainedDeltas.Select((c, i) =>
$"{i}: current {c.Key} | previous {c.Value.PreviousDeltaDfsHash.ToByteArray().ToCid()}")));
return(chainedDeltas);
}
public void DeltaDfsHashBroadcastDao_DeltaDfsHashBroadcast_Should_Be_Convertible()
{
var hash = MultiBase.Decode(_hashProvider.ComputeUtf8MultiHash("this hash").CreateCid());
var previousDfsHash =
MultiBase.Decode(_hashProvider.ComputeUtf8MultiHash("previousDfsHash").CreateCid());
var original = new DeltaDfsHashBroadcast
{
DeltaDfsHash = hash.ToByteString(),
PreviousDeltaDfsHash = previousDfsHash.ToByteString()
};
var contextDao = original.ToDao <DeltaDfsHashBroadcast, DeltaDfsHashBroadcastDao>(_mapperProvider);
var reconverted = contextDao.ToProtoBuff <DeltaDfsHashBroadcastDao, DeltaDfsHashBroadcast>(_mapperProvider);
reconverted.Should().Be(original);
}
public void Cli_Can_Request_Node_Info()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
var hash = hashProvider.ComputeUtf8MultiHash("hello").ToCid();
var result = Shell.ParseCommand("getdelta", "-h", hash, NodeArgumentPrefix, ServerNodeName);
result.Should().BeTrue();
var request = AssertSentMessageAndGetMessageContent <GetDeltaRequest>();
MultiBase.Encode(request.DeltaDfsHash.ToByteArray(), "base32").Should().Be(hash);
}
public static Address GetAddress(string publicKeySeed = "publicKey",
NetworkType networkType = NetworkType.Devnet,
AccountType accountType = AccountType.PublicAccount)
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
var address = new Address
{
AccountType = accountType,
NetworkType = networkType,
PublicKeyHash = hashProvider.ComputeUtf8MultiHash(publicKeySeed).ToArray().ToByteString()
};
return(address);
}
public void Init()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_deltaElector = Substitute.For <IDeltaElector>();
_fakeChannelContext = Substitute.For <IChannelHandlerContext>();
var logger = Substitute.For <ILogger>();
_voterId = PeerIdHelper.GetPeerId("favourite delta voter");
_producerId = PeerIdHelper.GetPeerId("candidate delta producer");
var peerRepository = Substitute.For <IPeerRepository>();
peerRepository.GetPeersByIpAndPublicKey(Arg.Any <ByteString>(), Arg.Any <ByteString>()).Returns(new List <Peer> {
new Peer()
});
_favouriteDeltaObserver = new FavouriteDeltaObserver(_deltaElector, new SyncState()
{
IsSynchronized = true
}, peerRepository, hashProvider, logger);
_newHash = MultiBase.Decode(hashProvider.ComputeUtf8MultiHash("newHash").ToCid());
_prevHash = MultiBase.Decode(hashProvider.ComputeUtf8MultiHash("prevHash").ToCid());
}
public void GetDeltaRequest_Can_Be_Sent()
{
//Arrange
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
var deltaMultiHash = CidHelper.CreateCid(hashProvider.ComputeUtf8MultiHash("previous"));
var commandContext = TestCommandHelpers.GenerateCliRequestCommandContext();
var connectedNode = commandContext.GetConnectedNode(null);
var command = new GetDeltaCommand(commandContext, _logger);
//Act
TestCommandHelpers.GenerateRequest(commandContext, command, "-n", "node1", "-h", deltaMultiHash);
//Assert
var requestSent = TestCommandHelpers.GetRequest <GetDeltaRequest>(connectedNode);
requestSent.Should().BeOfType(typeof(GetDeltaRequest));
}
public DfsTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_ipfsEngine = Substitute.For <ICoreApi>();
var fileSystem = Substitute.For <IFileSystemApi>();
_ipfsEngine.FileSystem.Returns(fileSystem);
var logger = Substitute.For <ILogger>();
_expectedCid = CidHelper.CreateCid(_hashProvider.ComputeUtf8MultiHash("data"));
_addedRecord = Substitute.For <IFileSystemNode>();
_addedRecord.Id.ReturnsForAnyArgs(_expectedCid);
_cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(DelayInMs));
_dfs = new Dfs(_ipfsEngine, _hashProvider, logger);
}
public static ICommandContext GenerateCliCommandContext()
{
var userOutput = Substitute.For <IUserOutput>();
var nodeRpcClientFactory = Substitute.For <IRpcClientFactory>();
var certificateStore = Substitute.For <ICertificateStore>();
var commandContext = Substitute.For <ICommandContext>();
commandContext.UserOutput.Returns(userOutput);
commandContext.RpcClientFactory.Returns(nodeRpcClientFactory);
commandContext.CertificateStore.Returns(certificateStore);
IHashProvider hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
var deltaMultiHash = hashProvider.ComputeUtf8MultiHash("previous");
commandContext.PeerId.Returns(
PeerIdHelper.GetPeerId(deltaMultiHash.Digest, IPAddress.Any, 9010));
return(commandContext);
}
public void Init()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_output = TestContext.CurrentContext;
_testScheduler = new TestScheduler();
_schedulerProvider = Substitute.For <ICycleSchedulerProvider>();
_schedulerProvider.Scheduler.Returns(_testScheduler);
_dateTimeProvider = Substitute.For <IDateTimeProvider>();
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_logger = Substitute.For <ILogger>();
_deltaHashProvider.GetLatestDeltaHash(Arg.Any <DateTime>())
.Returns(hashProvider.ComputeUtf8MultiHash("test"));
_dateTimeProvider.UtcNow.Returns(_ => _testScheduler.Now.DateTime);
_cycleProvider = new CycleEventsProvider(CycleConfiguration.Default, _dateTimeProvider, _schedulerProvider,
_deltaHashProvider, new Abstractions.Sync.SyncState()
{
IsSynchronized = true
}, _logger);
_spy = Substitute.For <IObserver <IPhase> >();
_stopWatch = _testScheduler.StartStopwatch();
_subscription = _cycleProvider.PhaseChanges.Take(50)
.Subscribe(p =>
{
TestContext.WriteLine($"{_stopWatch.Elapsed.TotalSeconds} -- {p}");
_spy.OnNext(p);
}, () =>
{
TestContext.WriteLine($"completed after {_stopWatch.Elapsed.TotalSeconds:g}");
_spy.OnCompleted();
});
}
