cs-codex-dist-tests/Tests/CodexTests/CodexDistTest.cs

170 lines
5.4 KiB
C#
Raw Normal View History

2023-09-19 14:22:07 +00:00
using CodexContractsPlugin;
using CodexNetDeployer;
2023-09-19 14:22:07 +00:00
using CodexPlugin;
2024-07-25 14:00:51 +00:00
using CodexPlugin.OverwatchSupport;
2023-11-12 09:36:48 +00:00
using CodexTests.Helpers;
2023-09-20 11:56:01 +00:00
using Core;
2023-09-13 12:24:43 +00:00
using DistTestCore;
using DistTestCore.Helpers;
using DistTestCore.Logs;
using Logging;
using MetricsPlugin;
using Newtonsoft.Json;
using NUnit.Framework;
2023-09-19 14:22:07 +00:00
using NUnit.Framework.Constraints;
2024-07-25 14:00:51 +00:00
using OverwatchTranscript;
2023-09-13 12:24:43 +00:00
namespace CodexTests
2023-09-13 12:24:43 +00:00
{
public class CodexDistTest : DistTest
{
2024-07-25 14:00:51 +00:00
private const bool enableOverwatchTranscript = true;
private static readonly Dictionary<TestLifecycle, CodexTranscriptWriter> writers = new Dictionary<TestLifecycle, CodexTranscriptWriter>();
2023-09-20 11:56:01 +00:00
public CodexDistTest()
{
ProjectPlugin.Load<CodexPlugin.CodexPlugin>();
ProjectPlugin.Load<CodexContractsPlugin.CodexContractsPlugin>();
ProjectPlugin.Load<GethPlugin.GethPlugin>();
ProjectPlugin.Load<MetricsPlugin.MetricsPlugin>();
}
protected override void Initialize(FixtureLog fixtureLog)
{
var localBuilder = new LocalCodexBuilder(fixtureLog);
localBuilder.Intialize();
localBuilder.Build();
}
2024-07-25 14:00:51 +00:00
protected override void LifecycleStart(TestLifecycle lifecycle)
{
base.LifecycleStart(lifecycle);
SetupTranscript(lifecycle);
2024-07-25 14:00:51 +00:00
}
protected override void LifecycleStop(TestLifecycle lifecycle, DistTestResult result)
2024-07-25 14:00:51 +00:00
{
base.LifecycleStop(lifecycle, result);
TeardownTranscript(lifecycle, result);
2024-07-25 14:00:51 +00:00
}
2024-05-09 07:32:48 +00:00
public ICodexNode StartCodex()
2023-09-13 12:24:43 +00:00
{
2024-05-09 07:32:48 +00:00
return StartCodex(s => { });
2023-09-13 12:24:43 +00:00
}
2024-05-09 07:32:48 +00:00
public ICodexNode StartCodex(Action<ICodexSetup> setup)
2023-09-13 12:24:43 +00:00
{
2024-05-09 07:32:48 +00:00
return StartCodex(1, setup)[0];
2023-09-13 12:24:43 +00:00
}
2024-05-09 07:32:48 +00:00
public ICodexNodeGroup StartCodex(int numberOfNodes)
2023-09-13 12:24:43 +00:00
{
2024-05-09 07:32:48 +00:00
return StartCodex(numberOfNodes, s => { });
2023-09-13 12:24:43 +00:00
}
2024-05-09 07:32:48 +00:00
public ICodexNodeGroup StartCodex(int numberOfNodes, Action<ICodexSetup> setup)
2023-09-13 12:24:43 +00:00
{
2023-09-20 10:02:32 +00:00
var group = Ci.StartCodexNodes(numberOfNodes, s =>
2023-09-13 12:24:43 +00:00
{
setup(s);
OnCodexSetup(s);
});
2024-06-12 13:28:08 +00:00
2023-09-13 12:24:43 +00:00
return group;
}
public PeerConnectionTestHelpers CreatePeerConnectionTestHelpers()
{
return new PeerConnectionTestHelpers(GetTestLog());
}
public PeerDownloadTestHelpers CreatePeerDownloadTestHelpers()
{
return new PeerDownloadTestHelpers(GetTestLog(), Get().GetFileManager());
}
2023-10-30 12:30:14 +00:00
public void AssertBalance(ICodexContracts contracts, ICodexNode codexNode, Constraint constraint, string msg = "")
2023-09-19 14:22:07 +00:00
{
2023-10-30 12:30:14 +00:00
AssertHelpers.RetryAssert(constraint, () => contracts.GetTestTokenBalance(codexNode), nameof(AssertBalance) + msg);
2023-09-19 14:22:07 +00:00
}
public void CheckLogForErrors(params ICodexNode[] nodes)
{
foreach (var node in nodes) CheckLogForErrors(node);
}
public void CheckLogForErrors(ICodexNode node)
{
2024-03-20 10:11:59 +00:00
Log($"Checking {node.GetName()} log for errors.");
var log = Ci.DownloadLog(node);
log.AssertLogDoesNotContain("Block validation failed");
log.AssertLogDoesNotContain("ERR ");
}
public void LogNodeStatus(ICodexNode node, IMetricsAccess? metrics = null)
{
Log("Status for " + node.GetName() + Environment.NewLine +
GetBasicNodeStatus(node));
}
private string GetBasicNodeStatus(ICodexNode node)
{
return JsonConvert.SerializeObject(node.GetDebugInfo(), Formatting.Indented) + Environment.NewLine +
node.Space().ToString() + Environment.NewLine;
}
// Disabled for now: Makes huge log files!
//private string GetNodeMetrics(IMetricsAccess? metrics)
//{
// if (metrics == null) return "No metrics enabled";
// var m = metrics.GetAllMetrics();
// if (m == null) return "No metrics received";
// return m.AsCsv();
//}
2023-09-13 12:24:43 +00:00
protected virtual void OnCodexSetup(ICodexSetup setup)
{
}
private void SetupTranscript(TestLifecycle lifecycle)
{
if (!enableOverwatchTranscript) return;
var writer = new CodexTranscriptWriter(Transcript.NewWriter());
Ci.SetCodexHooksProvider(writer);
writers.Add(lifecycle, writer);
}
private void TeardownTranscript(TestLifecycle lifecycle, DistTestResult result)
{
if (!enableOverwatchTranscript) return;
var writer = writers[lifecycle];
writers.Remove(lifecycle);
writer.AddResult(result.Success, result.Result);
try
{
Stopwatch.Measure(lifecycle.Log, "Transcript.ProcessLogs", () =>
{
writer.ProcessLogs(lifecycle.DownloadAllLogs());
});
var file = lifecycle.Log.CreateSubfile("owts");
Stopwatch.Measure(lifecycle.Log, $"Transcript.Finalize: {file.FullFilename}", () =>
{
writer.IncludeFile(lifecycle.Log.LogFile.FullFilename);
writer.Finalize(file.FullFilename);
});
}
catch (Exception ex)
{
lifecycle.Log.Error("Failure during transcript teardown: " + ex);
}
}
2023-09-13 12:24:43 +00:00
}
}