public void MatchJavaLineExtendedEventTest()
{
const string regexPattern = @"(?<ts>[^;]+); (?<pid>[^\s]+) (?<thread>[^\s]+) (?<class>[^\s]+) (?<sev>[^\s]+) (?<message>[^\s]+) " +
@"(?<req>[^\s]+) (?<sess>[^\s]+) (?<site>[^\s]+) (?<user>[^\s]+)";
const string input = "2020-09-28 17:44:18.273; 123 thread1 class1 info testMessage testRequest testSession testSite testUser";
var expectedCommonOutput = new Dictionary <string, object>
{
{ "Class", "class1" },
{ "Message", "testMessage" },
{ "ProcessId", 123 },
{ "Severity", "info" },
{ "SuccessfulMatch", true },
{ "Thread", "thread1" },
{ "Timestamp", new DateTime(2020, 9, 28, 17, 44, 18, 273) },
};
var expectedExtendedOutput = new Dictionary <string, object>(expectedCommonOutput)
{
{ "RequestId", "testRequest" },
{ "SessionId", "testSession" },
{ "Site", "testSite" },
{ "User", "testUser" }
};
var regex = new Regex(regexPattern);
var resultForCommonLine = input.MatchJavaLine(regex);
AssertMethods.AssertThatAllClassOwnPropsAreAtDefaultExpectFor(resultForCommonLine, expectedCommonOutput, "Base method with extra fields");
var resultForExtendedLine = input.MatchJavaLineWithSessionInfo(regex);
AssertMethods.AssertThatAllClassOwnPropsAreAtDefaultExpectFor(resultForExtendedLine, expectedExtendedOutput, "Extended method with extra fields");
}
public void TestUtxoLookAheadWarmupException()
{
var deferredCursor = new Mock <IDeferredChainStateCursor>();
deferredCursor.Setup(x => x.CursorCount).Returns(4);
var blockTxes = new BufferBlock <DecodedBlockTx>();
var lookAhead = UtxoLookAhead.LookAhead(blockTxes, deferredCursor.Object);
var blockTx0 = BlockTx.Create(0, RandomData.RandomTransaction(new RandomDataOptions {
TxInputCount = 2
}));
var blockTx1 = BlockTx.Create(1, RandomData.RandomTransaction(new RandomDataOptions {
TxInputCount = 2
}));
var expectedException = new InvalidOperationException();
deferredCursor.Setup(x => x.WarmUnspentTx(blockTx1.Transaction.Inputs[0].PrevTxOutputKey.TxHash)).Throws(expectedException);
blockTxes.Post(blockTx0);
blockTxes.Post(blockTx1);
blockTxes.Complete();
Exception actualEx;
AssertMethods.AssertAggregateThrows <Exception>(() =>
lookAhead.Completion.Wait(2000), out actualEx);
Assert.AreSame(expectedException, actualEx);
}
public void TestMissingHeader()
{
var fakeHeaders = new FakeHeaders();
var header0 = fakeHeaders.GenesisChained();
var header1 = fakeHeaders.NextChained();
var header2 = fakeHeaders.NextChained();
var rules = Mock.Of <ICoreRules>();
var coreStorage = new Mock <ICoreStorage>();
var storageManager = new Mock <IStorageManager>();
var chainStateCursor = new Mock <IChainStateCursor>();
storageManager.Setup(x => x.OpenChainStateCursor()).Returns(
new DisposeHandle <IChainStateCursor>(_ => { }, chainStateCursor.Object));
// don't mock header 1 so it is missing
chainStateCursor.Setup(x => x.TryGetHeader(header0.Hash, out header0)).Returns(true);
chainStateCursor.Setup(x => x.TryGetHeader(header2.Hash, out header2)).Returns(true);
// return header 2 as the chain tip
chainStateCursor.Setup(x => x.ChainTip).Returns(header2);
// init chain state builder with missing header
StorageCorruptException actualEx;
AssertMethods.AssertThrows <StorageCorruptException>(() =>
{
var chain = new ChainStateBuilder(rules, coreStorage.Object, storageManager.Object).Chain;
},
out actualEx);
Assert.AreEqual(StorageType.ChainState, actualEx.StorageType);
Assert.AreEqual("ChainState is missing header.", actualEx.Message);
}
public void TestExceptionInLoadTxInput()
{
var expectedException = new Exception();
var coreStorage = new Mock <ICoreStorage>();
var chainedHeader = RandomData.RandomChainedHeader();
var tx = RandomData.RandomTransaction(new RandomDataOptions {
TxInputCount = 1
});
var txLookupKey = new TxLookupKey(UInt256.Zero, 0);
var inputTx = RandomData.RandomTransaction();
var loadingTx = new LoadingTx(1, tx, chainedHeader, ImmutableArray.Create(txLookupKey));
var loadingTxes = new BufferBlock <LoadingTx>();
loadingTxes.Post(loadingTx);
loadingTxes.Complete();
// throw expected exception when the input transaction is looked up
BlockTx outputTx = null;
coreStorage.Setup(x => x.TryGetTransaction(txLookupKey.BlockHash, txLookupKey.TxIndex, out outputTx)).Throws(expectedException);
var loadedTxes = TxLoader.LoadTxes(coreStorage.Object, loadingTxes);
Exception actualEx;
AssertMethods.AssertAggregateThrows <Exception>(() =>
loadedTxes.ToEnumerable().ToList(), out actualEx);
Assert.AreSame(expectedException, actualEx);
}
public void TestAuctions3NT(string testName, string northHand, string southHand, string expectedBidsNorth, string expectedBidsSouth)
{
SetupTest.setupTest(testName, logger);
var bidManager = new BidManager(new BidGeneratorDescription(), fasesWithOffset, reverseDictionaries, false);
var auction = bidManager.GetAuction(northHand, southHand);
AssertMethods.AssertAuction(expectedBidsNorth, expectedBidsSouth, auction);
}
public void TestAuctions4Diamond(string testName, string northHand, string southHand, string expectedBidsNorth, string expectedBidsSouth)
{
SetupTest.setupTest(testName, logger);
var bidManager = new BidManager(new BidGeneratorDescription(), fasesWithOffset, reverseDictionaries, (auction, northHand, sourceInformation) => { return(BidManager.RelayBidKind.fourDiamondEndSignal); });
var auction = bidManager.GetAuction(northHand, southHand);
AssertMethods.AssertAuction(expectedBidsNorth, expectedBidsSouth, auction);
}
public void TestCreateFromInvalidEnumerable()
{
// create a chain
var fakeHeaders = new FakeHeaders();
var header0 = fakeHeaders.GenesisChained();
var header1 = fakeHeaders.NextChained();
// create builder from out of order enumerable
AssertMethods.AssertThrows <InvalidOperationException>(() => new ChainBuilder(new[] { header1, header0 }));
}
public void MatchJavaLineSharedTests(string testName, string regexPattern, object input, IDictionary <string, object> expectedOutputProps)
{
var regex = new Regex(regexPattern);
var resultForCommonLine = input.MatchJavaLine(regex);
AssertMethods.AssertThatAllClassOwnPropsAreAtDefaultExpectFor(resultForCommonLine, expectedOutputProps, testName);
var resultForExtendedLine = input.MatchJavaLineWithSessionInfo(regex);
AssertMethods.AssertThatAllClassOwnPropsAreAtDefaultExpectFor(resultForExtendedLine, expectedOutputProps, testName);
}
public void TestChainTipOutOfSync()
{
var fakeHeaders = new FakeHeaders();
var header0 = fakeHeaders.GenesisChained();
var header1 = fakeHeaders.NextChained();
var header2 = fakeHeaders.NextChained();
var rules = Mock.Of <ICoreRules>();
var coreStorage = new Mock <ICoreStorage>();
var storageManager = new Mock <IStorageManager>();
var chainStateCursor = new Mock <IDeferredChainStateCursor>();
storageManager.Setup(x => x.OpenChainStateCursor()).Returns(
new DisposeHandle <IChainStateCursor>(_ => { }, chainStateCursor.Object));
storageManager.Setup(x => x.OpenDeferredChainStateCursor(It.IsAny <IChainState>())).Returns(
new DisposeHandle <IDeferredChainStateCursor>(_ => { }, chainStateCursor.Object));
chainStateCursor.Setup(x => x.TryGetHeader(header0.Hash, out header0)).Returns(true);
chainStateCursor.Setup(x => x.TryGetHeader(header1.Hash, out header1)).Returns(true);
chainStateCursor.Setup(x => x.TryGetHeader(header2.Hash, out header2)).Returns(true);
// return header 1 as the chain tip
chainStateCursor.Setup(x => x.ChainTip).Returns(header1);
// init chain state builder seeing header 1
var chainStateBuilder = new ChainStateBuilder(rules, coreStorage.Object, storageManager.Object);
Assert.AreEqual(header1.Hash, chainStateBuilder.Chain.LastBlock.Hash);
// alter the chain tip outside of the chain state builder
chainStateCursor.Setup(x => x.ChainTip).Returns(header2);
// attempt to add block when out of sync
ChainStateOutOfSyncException actualEx;
AssertMethods.AssertAggregateThrows <ChainStateOutOfSyncException>(() =>
chainStateBuilder.AddBlockAsync(header2, Enumerable.Empty <BlockTx>()).Wait(),
out actualEx);
Assert.AreEqual(header1.Hash, actualEx.ExpectedChainTip.Hash);
Assert.AreEqual(header2.Hash, actualEx.ActualChainTip.Hash);
// attempt to rollback block when out of sync
AssertMethods.AssertThrows <ChainStateOutOfSyncException>(() =>
chainStateBuilder.RollbackBlock(header2, Enumerable.Empty <BlockTx>()),
out actualEx);
Assert.AreEqual(header1.Hash, actualEx.ExpectedChainTip.Hash);
Assert.AreEqual(header2.Hash, actualEx.ActualChainTip.Hash);
}
public void TestDoubleSpend()
{
// prepare block
var fakeHeaders = new FakeHeaders();
var chainedHeader0 = fakeHeaders.GenesisChained();
var chainedHeader1 = fakeHeaders.NextChained();
var chainedHeader2 = fakeHeaders.NextChained();
var chain = Chain.CreateForGenesisBlock(chainedHeader0).ToBuilder();
var emptyCoinbaseTx0 = BlockTx.Create(0, Transaction.Create(0, ImmutableArray.Create <TxInput>(), ImmutableArray.Create <TxOutput>(), 0));
var emptyCoinbaseTx1 = BlockTx.Create(0, Transaction.Create(1, ImmutableArray.Create <TxInput>(), ImmutableArray.Create <TxOutput>(), 0));
// initialize memory utxo builder storage
var memoryStorage = new MemoryStorageManager();
var memoryChainStateCursor = memoryStorage.OpenChainStateCursor().Item;
memoryChainStateCursor.BeginTransaction();
// initialize utxo builder
var utxoBuilder = new UtxoBuilder();
// prepare an unspent transaction
var txHash = new UInt256(100);
var unspentTx = new UnspentTx(txHash, chainedHeader1.Height, 0, 0, false, 1, OutputState.Unspent);
var txOutputKey = new TxOutputKey(txHash, 0);
var txOutput = new TxOutput(0, ImmutableArray <byte> .Empty);
// add the unspent transaction
memoryChainStateCursor.TryAddUnspentTx(unspentTx);
memoryChainStateCursor.TryAddUnspentTxOutput(txOutputKey, txOutput);
// create an input to spend the unspent transaction
var input = new TxInput(txHash, 0, ImmutableArray.Create <byte>(), 0);
var tx = BlockTx.Create(1, Transaction.Create(0, ImmutableArray.Create(input), ImmutableArray.Create <TxOutput>(), 0));
// spend the input
chain.AddBlock(chainedHeader1);
utxoBuilder.CalculateUtxo(memoryChainStateCursor, chain.ToImmutable(), new[] { emptyCoinbaseTx0, tx }.ToBufferBlock()).ToEnumerable().ToList();
// verify utxo storage
UnspentTx actualUnspentTx; TxOutput actualTxOutput;
Assert.IsTrue(memoryChainStateCursor.TryGetUnspentTx(txHash, out actualUnspentTx));
Assert.IsTrue(actualUnspentTx.IsFullySpent);
Assert.IsTrue(memoryChainStateCursor.TryGetUnspentTxOutput(txOutputKey, out actualTxOutput));
Assert.AreEqual(txOutput, actualTxOutput);
// attempt to spend the input again, validation exception should be thrown
chain.AddBlock(chainedHeader2);
AssertMethods.AssertAggregateThrows <ValidationException>(() =>
utxoBuilder.CalculateUtxo(memoryChainStateCursor, chain.ToImmutable(), new[] { emptyCoinbaseTx1, tx }.ToBufferBlock()).ToEnumerable().ToList());
}
public void TestInvalidMerkleRoot()
{
// prepare mocks
var coreStorage = new Mock <ICoreStorage>();
var storageManager = new Mock <IStorageManager>();
var chainStateCursor = new Mock <IDeferredChainStateCursor>();
storageManager.Setup(x => x.OpenChainStateCursor()).Returns(
new DisposeHandle <IChainStateCursor>(_ => { }, chainStateCursor.Object));
storageManager.Setup(x => x.OpenDeferredChainStateCursor(It.IsAny <IChainState>())).Returns(
new DisposeHandle <IDeferredChainStateCursor>(_ => { }, chainStateCursor.Object));
chainStateCursor.Setup(x => x.CursorCount).Returns(1);
chainStateCursor.Setup(x => x.DataFlowBlocks).Returns(new IDataflowBlock[0]);
// prepare a test block
var testBlocks = new TestBlocks();
var rules = testBlocks.Rules;
var block = testBlocks.MineAndAddBlock(txCount: 10);
var chainedHeader = testBlocks.Chain.LastBlock;
// create an invalid version of the header where the merkle root is incorrect
var invalidChainedHeader = ChainedHeader.CreateFromPrev(rules.ChainParams.GenesisChainedHeader, block.Header.With(MerkleRoot: UInt256.Zero), DateTimeOffset.Now);
// mock genesis block & chain tip
var genesisHeader = rules.ChainParams.GenesisChainedHeader;
chainStateCursor.Setup(x => x.ChainTip).Returns(genesisHeader);
chainStateCursor.Setup(x => x.TryGetHeader(genesisHeader.Hash, out genesisHeader)).Returns(true);
// mock invalid block
chainStateCursor.Setup(x => x.TryGetHeader(chainedHeader.Hash, out invalidChainedHeader)).Returns(true);
// init chain state builder
var chainStateBuilder = new ChainStateBuilder(rules, coreStorage.Object, storageManager.Object);
Assert.AreEqual(rules.ChainParams.GenesisBlock.Hash, chainStateBuilder.Chain.LastBlock.Hash);
// attempt to add block with invalid merkle root
ValidationException actualEx;
AssertMethods.AssertAggregateThrows <ValidationException>(() =>
chainStateBuilder.AddBlockAsync(invalidChainedHeader, Enumerable.Empty <BlockTx>()).Wait(),
out actualEx);
// verify error
Assert.AreEqual($"Failing block {invalidChainedHeader.Hash} at height 1: Merkle root is invalid", actualEx.Message);
}
public void TestMonitorAddress()
{
if (Debugger.IsAttached)
{
Assert.Inconclusive();
}
var sha256 = new SHA256Managed();
//var publicKey =
// "04ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32f"
// .HexToByteArray();
var publicKey =
"04f9804cfb86fb17441a6562b07c4ee8f012bdb2da5be022032e4b87100350ccc7c0f4d47078b06c9d22b0ec10bdce4c590e0d01aed618987a6caa8c94d74ee6dc"
.HexToByteArray().ToImmutableArray();
var walletMonitor = new WalletMonitor(LogManager.CreateNullLogger());
walletMonitor.AddAddress(new PublicKeyAddress(publicKey));
using (var simulator = new MainnetSimulator())
{
simulator.CoreDaemon.SubscribeChainStateVisitor(walletMonitor);
var block9999 = simulator.BlockProvider.GetBlock(9999);
simulator.AddBlockRange(0, 9999);
simulator.WaitForDaemon(expectedHeight: 9999);
AssertMethods.AssertDaemonAtBlock(9999, block9999.Hash, simulator.CoreDaemon);
var minedTxOutputs = walletMonitor.Entries.Where(x => x.Type == EnumWalletEntryType.Mine).ToList();
var receivedTxOutputs = walletMonitor.Entries.Where(x => x.Type == EnumWalletEntryType.Receive).ToList();
var spentTxOutputs = walletMonitor.Entries.Where(x => x.Type == EnumWalletEntryType.Spend).ToList();
var actualMinedBtc = minedTxOutputs.Sum(x => (decimal)x.Value) / 100.MILLION();
var actualReceivedBtc = receivedTxOutputs.Sum(x => (decimal)x.Value) / 100.MILLION();
var actualSpentBtc = spentTxOutputs.Sum(x => (decimal)x.Value) / 100.MILLION();
Assert.AreEqual(0, minedTxOutputs.Count);
Assert.AreEqual(16, receivedTxOutputs.Count);
Assert.AreEqual(14, spentTxOutputs.Count);
Assert.AreEqual(0M, actualMinedBtc);
Assert.AreEqual(569.44M, actualReceivedBtc);
Assert.AreEqual(536.52M, actualSpentBtc);
}
}
public void TestRpcGetBlockCount()
{
using (var simulator = new MainnetSimulator())
{
var logger = simulator.Kernel.Get <Logger>();
using (var rpcServer = new CoreRpcServer(logger, simulator.CoreDaemon))
{
rpcServer.StartListening();
var block9 = simulator.BlockProvider.GetBlock(9);
simulator.AddBlockRange(0, 9);
simulator.WaitForDaemon(expectedHeight: 9);
AssertMethods.AssertDaemonAtBlock(9, block9.Hash, simulator.CoreDaemon);
var jsonRequestId = Guid.NewGuid().ToString();
var jsonRequest = JsonConvert.SerializeObject(
new JsonRpcRequest
{
method = "getblockcount",
@params = new string[0],
id = jsonRequestId
});
var jsonRequestBytes = Encoding.UTF8.GetBytes(jsonRequest);
var request = (HttpWebRequest)WebRequest.Create("http://localhost:8332");
request.Method = WebRequestMethods.Http.Post;
using (var requestStream = request.GetRequestStream())
{
requestStream.Write(jsonRequestBytes, 0, jsonRequestBytes.Length);
}
using (var response = request.GetResponse())
using (var responseStream = response.GetResponseStream())
using (var responseStreamReader = new StreamReader(responseStream, Encoding.UTF8))
{
var jsonResponseString = responseStreamReader.ReadToEnd();
var jsonResponse = JsonConvert.DeserializeObject <JsonRpcResponse>(jsonResponseString);
Assert.AreEqual("2.0", jsonResponse.jsonrpc);
Assert.AreEqual("9", jsonResponse.result);
Assert.AreEqual(jsonRequestId, jsonResponse.id);
}
}
}
}
public void TestAddBlockInvalid()
{
var fakeHeaders = new FakeHeaders();
var header0 = fakeHeaders.GenesisChained();
var header1 = fakeHeaders.NextChained();
var header2 = fakeHeaders.NextChained();
var chainBuilder = new ChainBuilder();
// adding header 1 first should fail
AssertMethods.AssertThrows <InvalidOperationException>(() => chainBuilder.AddBlock(header1));
// add header 0
chainBuilder.AddBlock(header0);
// adding header 2 without header 1 should fail
AssertMethods.AssertThrows <InvalidOperationException>(() => chainBuilder.AddBlock(header2));
}
public void TestExceptionInLoadingTxes()
{
var expectedException = new Exception();
var coreStorage = Mock.Of <ICoreStorage>();
var loadingTxes = new BufferBlock <LoadingTx>();
((IDataflowBlock)loadingTxes).Fault(expectedException);
var loadedTxes = TxLoader.LoadTxes(coreStorage, loadingTxes);
Exception actualEx;
AssertMethods.AssertAggregateThrows <Exception>(() =>
loadedTxes.ToEnumerable().ToList(), out actualEx);
Assert.AreSame(expectedException, actualEx);
}
public void TestRemoveBlockInvalid()
{
var fakeHeaders = new FakeHeaders();
var header0 = fakeHeaders.GenesisChained();
var header1 = fakeHeaders.NextChained();
var header2 = fakeHeaders.NextChained();
var chainBuilder = new ChainBuilder(new[] { header0, header1, header2 });
// removing header 1 first should fail
AssertMethods.AssertThrows <InvalidOperationException>(() => chainBuilder.RemoveBlock(header1));
// remove header 2
chainBuilder.RemoveBlock(header2);
// removing header 0 with header 1 present should fail
AssertMethods.AssertThrows <InvalidOperationException>(() => chainBuilder.AddBlock(header0));
}
public void TestDifferentEvents(string testName, string @class, string message, string severity, IDictionary <string, object> nonNullProps)
{
var testLine = GetTestLine(@class, message, severity);
var result = _eventParser.ParseEvent(_testLogLine, testLine);
if (nonNullProps == null)
{
result.Should().BeNull();
return;
}
result.Should().NotBeNull();
var expectedPropValues = AddFixedPropValues(nonNullProps, @class, message, severity);
AssertMethods.AssertThatAllClassOwnPropsAreAtDefaultExpectFor(result, expectedPropValues, testName);
result.VerifyBaseEventProperties(Timestamp, _testLogLine);
_buildTrackerMock.Verify(m => m.GetBuild(Timestamp), Times.Once);
}
public void TestNavigateTowardsInvalidChains()
{
// create distinct chains
var fakeHeadersA = new FakeHeaders();
var header0A = fakeHeadersA.GenesisChained();
var header1A = fakeHeadersA.NextChained();
var fakeHeadersB = new FakeHeaders();
var header0B = fakeHeadersB.GenesisChained();
var header1B = fakeHeadersB.NextChained();
var chainEmpty = new ChainBuilder().ToImmutable();
var chainA = new ChainBuilder(new[] { header0A, header1A }).ToImmutable();
var chainB = new ChainBuilder(new[] { header0B, header1B, }).ToImmutable();
// unrelated chains should error
AssertMethods.AssertThrows <InvalidOperationException>(() => chainA.NavigateTowards(chainB).ToList());
AssertMethods.AssertThrows <InvalidOperationException>(() => chainB.NavigateTowards(chainA).ToList());
}
public void RunTestCases(string testName, string logLineText, DateTime timestamp, LogType logType, IDictionary <string, object> nonNullProps)
{
var testWriterFactory = new TestWriterFactory();
var logLine = new LogLine(new ReadLogLineResult(123, logLineText), TestLogFileInfo);
SinglePluginExecutionResults processingResults;
using (var plugin = new LogShark.Plugins.TabadminController.TabadminControllerPlugin())
{
plugin.Configure(testWriterFactory, null, _processingNotificationsCollectorMock.Object, new NullLoggerFactory());
plugin.ProcessLogLine(logLine, logType);
processingResults = plugin.CompleteProcessing();
}
_processingNotificationsCollectorMock.VerifyNoOtherCalls();
processingResults.AdditionalTags.Should().BeEmpty();
processingResults.HasAdditionalTags.Should().BeFalse();
processingResults.WritersStatistics.Count.Should().Be(1);
if (nonNullProps == null)
{
testWriterFactory.AssertAllWritersAreDisposedAndEmpty(1);
processingResults.WritersStatistics[0].LinesPersisted.Should().Be(0);
return;
}
processingResults.WritersStatistics[0].LinesPersisted.Should().Be(1);
var testWriter = testWriterFactory.GetOneWriterAndVerifyOthersAreEmptyAndDisposed <TabadminControllerEvent>("TabadminControllerEvents", 1);
testWriter.ReceivedObjects.Count.Should().Be(1);
var result = testWriter.ReceivedObjects.FirstOrDefault() as TabadminControllerEvent;
result.Should().NotBeNull();
AssertMethods.AssertThatAllClassOwnPropsAreAtDefaultExpectFor(result, nonNullProps, testName);
result.VerifyBaseEventProperties(timestamp, logLine);
}
