Ejemplo n.º 1
0
        public async Task Call_GetSignedTransactionsAsync_No_Signed_Transactions_Doesnt_Broadcast()
        {
            this.federationGatewaySettings.PublicKey.Returns(PublicKey);

            var emptyTransactionPair = new CrossChainTransfer[0];

            this.store.GetTransfersByStatus(new[] { CrossChainTransferStatus.FullySigned }).Returns(emptyTransactionPair);

            var signedMultisigTransactionBroadcaster = new SignedMultisigTransactionBroadcaster(
                this.asyncProvider,
                this.loggerFactory,
                this.store,
                this.nodeLifetime,
                this.mempoolManager,
                this.broadcasterManager,
                this.ibdState,
                this.federationWalletManager);

            await signedMultisigTransactionBroadcaster.BroadcastTransactionsAsync().ConfigureAwait(false);

            this.store.Received().GetTransfersByStatus(Arg.Any <CrossChainTransferStatus[]>());

            await this.broadcasterManager.DidNotReceive().BroadcastTransactionAsync(Arg.Any <Transaction>());

            this.logger.Received().Log(LogLevel.Trace,
                                       Arg.Any <EventId>(),
                                       Arg.Is <object>(o => o.ToString() == "Signed multisig transactions do not exist in the CrossChainTransfer store."),
                                       null,
                                       Arg.Any <Func <object, Exception, string> >());
        }
        public async Task Dont_Do_Work_Inactive_Federation()
        {
            this.federationWalletManager.IsFederationWalletActive().Returns(false);

            this.ibdState.IsInitialBlockDownload().Returns(true);

            using (var signedMultisigTransactionBroadcaster = new SignedMultisigTransactionBroadcaster(
                       this.loggerFactory,
                       this.mempoolManager,
                       this.broadcasterManager,
                       this.ibdState,
                       this.federationWalletManager,
                       this.signals))
            {
                signedMultisigTransactionBroadcaster.Start();

                var partial = new Transaction();
                var xfer    = new CrossChainTransfer();
                xfer.SetPartialTransaction(partial);

                this.signals.Publish(new CrossChainTransferTransactionFullySigned(xfer));
                await Task.Delay(100); //the event subscriber handles the event asynchronously so let's wait a bit to give it the time to complete.

                await this.broadcasterManager.Received(0).BroadcastTransactionAsync(Arg.Any <Transaction>());
            }
        }
Ejemplo n.º 3
0
        public async Task Call_GetSignedTransactionsAsync_Signed_Transactions_Broadcasts()
        {
            this.federationGatewaySettings.PublicKey.Returns(PublicKey);

            var partial = new Transaction();
            var xfer    = new CrossChainTransfer();

            xfer.SetPartialTransaction(partial);

            var transactionPair = new CrossChainTransfer[]
            {
                xfer
            };

            this.store.GetTransfersByStatus(Arg.Any <CrossChainTransferStatus[]>()).Returns(transactionPair);

            var signedMultisigTransactionBroadcaster = new SignedMultisigTransactionBroadcaster(
                this.asyncProvider,
                this.loggerFactory,
                this.store,
                this.nodeLifetime,
                this.mempoolManager,
                this.broadcasterManager,
                this.ibdState,
                this.federationWalletManager);

            await signedMultisigTransactionBroadcaster.BroadcastTransactionsAsync().ConfigureAwait(false);

            this.store.Received().GetTransfersByStatus(Arg.Any <CrossChainTransferStatus[]>());
            await this.broadcasterManager.Received(1).BroadcastTransactionAsync(Arg.Any <Transaction>());
        }
Ejemplo n.º 4
0
        public async Task Call_GetSignedTransactionsAsync_Signed_Transactions_Broadcasts_Async()
        {
            this.federatedPegSettings.PublicKey.Returns(PublicKey);

            var partial  = new Transaction();
            var transfer = new CrossChainTransfer();

            transfer.SetPartialTransaction(partial);

            ICrossChainTransferStore crossChainTransferStore = Substitute.For <ICrossChainTransferStore>();

            crossChainTransferStore.GetTransfersByStatus(default).ReturnsForAnyArgs(new[] { transfer });
        public async Task Call_GetSignedTransactionsAsync_Signed_Transactions_Broadcasts()
        {
            this.federatedPegSettings.PublicKey.Returns(PublicKey);

            using (var signedMultisigTransactionBroadcaster = new SignedMultisigTransactionBroadcaster(
                       this.loggerFactory,
                       this.mempoolManager,
                       this.broadcasterManager,
                       this.ibdState,
                       this.federationWalletManager,
                       this.signals))
            {
                signedMultisigTransactionBroadcaster.Start();

                var partial = new Transaction();
                var xfer    = new CrossChainTransfer();
                xfer.SetPartialTransaction(partial);

                this.signals.Publish(new CrossChainTransferTransactionFullySigned(xfer));
                await Task.Delay(100); //the event subscriber handles the event asynchronously so let's wait a bit to give it the time to complete.

                await this.broadcasterManager.Received(1).BroadcastTransactionAsync(Arg.Any <Transaction>());
            }
        }