private void TestWithException <TException>(Delegate test, Configuration configuration, bool replay)
where TException : Exception
{
configuration = configuration ?? GetConfiguration();
Type exceptionType = typeof(TException);
Assert.True(exceptionType.IsSubclassOf(typeof(Exception)), "Please configure the test correctly. " +
$"Type '{exceptionType}' is not an exception type.");
TextWriter logger;
if (configuration.IsVerbose)
{
logger = new TestOutputLogger(this.TestOutput, true);
}
else
{
logger = TextWriter.Null;
}
try
{
var engine = RunTest(test, configuration, logger);
CheckErrors(engine, exceptionType);
if (replay)
{
configuration.SchedulingStrategy = "replay";
configuration.ScheduleTrace = engine.ReproducableTrace;
engine = RunTest(test, configuration, logger);
string replayError = (engine.Strategy as ReplayStrategy).ErrorText;
Assert.True(replayError.Length == 0, replayError);
CheckErrors(engine, exceptionType);
}
}
catch (Exception ex)
{
Assert.False(true, ex.Message + "\n" + ex.StackTrace);
}
finally
{
logger.Dispose();
}
}
public async SystemTasks.Task TestReceiveEventWithPredicate()
{
int notificationCount = 0;
var tcs = new TaskCompletionSource <bool>();
var logger = new TestOutputLogger(this.TestOutput, false);
var mockActorManager = new MockActorManager(logger,
(notification, evt, _) =>
{
notificationCount++;
if (notificationCount == 3)
{
Assert.Equal(MockActorManager.Notification.ReceiveEvent, notification);
tcs.SetResult(true);
}
});
using (var queue = new EventQueue(mockActorManager))
{
var receivedEventTask = queue.ReceiveEventAsync(typeof(E4), evt => (evt as E4).Value);
var enqueueStatus = queue.Enqueue(new E4(false), null, null);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
Assert.Equal(1, queue.Size);
enqueueStatus = queue.Enqueue(new E4(true), null, null);
Assert.Equal(EnqueueStatus.Received, enqueueStatus);
Assert.Equal(1, queue.Size);
var receivedEvent = await receivedEventTask;
Assert.IsType <E4>(receivedEvent);
Assert.True((receivedEvent as E4).Value);
Assert.Equal(1, queue.Size);
var(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.IsType <E4>(e);
Assert.False((e as E4).Value);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(0, queue.Size);
(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus);
Assert.Equal(0, queue.Size);
await Task.WhenAny(tcs.Task, Task.Delay(500));
Assert.True(tcs.Task.IsCompleted);
}
}
public async Task TestEnqueueReceiveEventsAlternateType()
{
var logger = new TestOutputLogger(this.TestOutput, false);
var machineStateManager = new MockStateMachineManager(logger,
(notification, evt, _) => { });
var queue = new EventQueue(machineStateManager);
int numMessages = 10000;
var enqueueTask = Task.Run(() =>
{
for (int i = 0; i < numMessages; i++)
{
if (i % 2 == 0)
{
queue.Enqueue(new E1(), Guid.Empty, null);
}
else
{
queue.Enqueue(new E2(), Guid.Empty, null);
}
}
});
var receiveTask = Task.Run(async() =>
{
for (int i = 0; i < numMessages; i++)
{
if (i % 2 == 0)
{
var e = await queue.ReceiveEventAsync(typeof(E1));
Assert.IsType <E1>(e);
}
else
{
var e = await queue.ReceiveEventAsync(typeof(E2));
Assert.IsType <E2>(e);
}
}
});
await Task.WhenAny(Task.WhenAll(enqueueTask, receiveTask), Task.Delay(3000));
Assert.True(enqueueTask.IsCompleted);
Assert.True(receiveTask.IsCompleted);
}
public async Task TestReceiveEventWithoutWaiting()
{
int notificationCount = 0;
var tcs = new TaskCompletionSource <bool>();
var logger = new TestOutputLogger(this.TestOutput, false);
var machineStateManager = new MockMachineStateManager(logger,
(notification, evt, _) =>
{
notificationCount++;
if (notificationCount == 3)
{
Assert.Equal(MockMachineStateManager.Notification.ReceiveEventWithoutWaiting, notification);
tcs.SetResult(true);
}
});
var queue = new EventQueue(machineStateManager);
var enqueueStatus = queue.Enqueue(new E4(false), Guid.Empty, null);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
Assert.Equal(1, queue.Size);
enqueueStatus = queue.Enqueue(new E4(true), Guid.Empty, null);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
Assert.Equal(2, queue.Size);
var receivedEvent = await queue.ReceiveAsync(typeof(E4), evt => (evt as E4).Value);
Assert.IsType <E4>(receivedEvent);
Assert.True((receivedEvent as E4).Value);
Assert.Equal(1, queue.Size);
var(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E4>(e);
Assert.False((e as E4).Value);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(0, queue.Size);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus);
Assert.Equal(0, queue.Size);
await Task.WhenAny(tcs.Task, Task.Delay(500));
Assert.True(tcs.Task.IsCompleted);
}
public void TestEnqueueEventWithHandlerNotRunning()
{
var logger = new TestOutputLogger(this.TestOutput, false);
var mockActorManager = new MockActorManager(logger,
(notification, evt, _) => { });
using (var queue = new EventQueue(mockActorManager))
{
var(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus);
Assert.Equal(0, queue.Size);
var enqueueStatus = queue.Enqueue(new E1(), Guid.Empty, null);
Assert.Equal(EnqueueStatus.EventHandlerNotRunning, enqueueStatus);
Assert.Equal(1, queue.Size);
}
}
public void TestRaiseEvent()
{
var logger = new TestOutputLogger(this.TestOutput, false);
var machineStateManager = new MockMachineStateManager(logger,
(notification, evt, _) => { });
var queue = new EventQueue(machineStateManager);
queue.Raise(new E1(), Guid.Empty);
Assert.True(queue.IsEventRaised);
Assert.Equal(0, queue.Size);
var(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E1>(e);
Assert.Equal(DequeueStatus.Raised, deqeueStatus);
Assert.False(queue.IsEventRaised);
Assert.Equal(0, queue.Size);
}
public void TestDeferEvent()
{
int notificationCount = 0;
var logger = new TestOutputLogger(this.TestOutput, false);
using var queue = new TestEventQueue(logger, (notification, evt, _) =>
{
notificationCount++;
if (notificationCount is 4)
{
Assert.Equal(TestEventQueue.Notification.DeferEvent, notification);
}
}, deferredEvents: new Type[1] {
typeof(E1)
});
var enqueueStatus = queue.Enqueue(new E2(), null, null);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
Assert.Equal(1, queue.Size);
enqueueStatus = queue.Enqueue(new E1(), null, null);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
Assert.Equal(2, queue.Size);
enqueueStatus = queue.Enqueue(new E3(), null, null);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
Assert.Equal(3, queue.Size);
var(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.IsType <E2>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(2, queue.Size);
(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.IsType <E3>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(1, queue.Size);
(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.Unavailable, deqeueStatus);
Assert.Equal(1, queue.Size);
}
public void TestRaiseEvent()
{
var logger = new TestOutputLogger(this.TestOutput, false);
var mockActorManager = new MockActorManager(logger,
(notification, evt, _) => { });
using (var queue = new EventQueue(mockActorManager))
{
queue.RaiseEvent(new E1(), null);
Assert.True(queue.IsEventRaised);
Assert.Equal(0, queue.Size);
var(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.IsType <E1>(e);
Assert.Equal(DequeueStatus.Raised, deqeueStatus);
Assert.False(queue.IsEventRaised);
Assert.Equal(0, queue.Size);
}
}
public async Task TestReceiveEventMultipleTypes()
{
int notificationCount = 0;
var tcs = new TaskCompletionSource <bool>();
var logger = new TestOutputLogger(this.TestOutput, false);
var machineStateManager = new MockMachineStateManager(logger,
(notification, evt, _) =>
{
notificationCount++;
if (notificationCount == 2)
{
Assert.Equal(MockMachineStateManager.Notification.ReceiveEvent, notification);
tcs.SetResult(true);
}
});
var queue = new EventQueue(machineStateManager);
var task = Task.Run(async() =>
{
var receivedEvent = await queue.ReceiveAsync(typeof(E1), typeof(E2));
Assert.IsType <E2>(receivedEvent);
Assert.Equal(0, queue.Size);
});
// Small delay to force ordering.
await Task.Delay(100);
var enqueueStatus = queue.Enqueue(new E2(), Guid.Empty, null);
Assert.Equal(EnqueueStatus.Received, enqueueStatus);
Assert.Equal(0, queue.Size);
await task;
var(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus);
Assert.Equal(0, queue.Size);
await Task.WhenAny(tcs.Task, Task.Delay(500));
Assert.True(tcs.Task.IsCompleted);
}
public void LogIgnoresTestBoundaryFailure()
{
// This test should not fail the test runner
var categoryName = Guid.NewGuid().ToString();
var config = new LoggingConfig {
IgnoreTestBoundaryException = true
};
var sut = new TestOutputLogger(categoryName, _output, config);
var task = new Task(async() =>
{
await Task.Delay(0).ConfigureAwait(false);
sut.LogCritical("message2");
});
task.Start();
}
public void WriteLogThrowsExceptionWhenIgnoreTestBoundaryExceptionDisabled()
{
var categoryName = Guid.NewGuid().ToString();
var message = Guid.NewGuid().ToString();
var config = new LoggingConfig
{
IgnoreTestBoundaryException = false
};
var output = Substitute.For <ITestOutputHelper>();
output.When(x => x.WriteLine(Arg.Any <string>())).Throw <InvalidOperationException>();
var sut = new TestOutputLogger(categoryName, output, config);
Action action = () => sut.LogInformation(message);
action.Should().Throw <InvalidOperationException>();
}
public void TestDequeueEvent()
{
var logger = new TestOutputLogger(this.TestOutput, false);
var mockActorManager = new MockActorManager(logger,
(notification, evt, _) => { });
using (var queue = new EventQueue(mockActorManager))
{
var(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus);
Assert.Equal(0, queue.Size);
queue.Enqueue(new E1(), Guid.Empty, null);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E1>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(0, queue.Size);
queue.Enqueue(new E3(), Guid.Empty, null);
queue.Enqueue(new E2(), Guid.Empty, null);
queue.Enqueue(new E1(), Guid.Empty, null);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E3>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(2, queue.Size);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E2>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(1, queue.Size);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E1>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(0, queue.Size);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus);
Assert.Equal(0, queue.Size);
}
}
public void TestEnqueueEvent()
{
var logger = new TestOutputLogger(this.TestOutput, false);
using var queue = new TestEventQueue(logger, (notification, evt, _) => { });
Assert.Equal(0, queue.Size);
var enqueueStatus = queue.Enqueue(new E1(), null, null);
Assert.Equal(1, queue.Size);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
enqueueStatus = queue.Enqueue(new E2(), null, null);
Assert.Equal(2, queue.Size);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
enqueueStatus = queue.Enqueue(new E3(), null, null);
Assert.Equal(3, queue.Size);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
}
private void TestWithError(Delegate test, Configuration configuration, string[] expectedErrors, bool replay)
{
configuration = configuration ?? GetConfiguration();
TextWriter logger;
if (configuration.IsVerbose)
{
logger = new TestOutputLogger(this.TestOutput, true);
}
else
{
logger = TextWriter.Null;
}
try
{
var engine = RunTest(test, configuration, logger);
CheckErrors(engine, expectedErrors);
if (replay)
{
configuration.SchedulingStrategy = "replay";
configuration.ScheduleTrace = engine.ReproducableTrace;
engine = RunTest(test, configuration, logger);
string replayError = (engine.Strategy as ReplayStrategy).ErrorText;
Assert.True(replayError.Length == 0, replayError);
CheckErrors(engine, expectedErrors);
}
}
catch (Exception ex)
{
Assert.False(true, ex.Message + "\n" + ex.StackTrace);
}
finally
{
logger.Dispose();
}
}
public void LogWritesExceptionTest()
{
var logLevel = LogLevel.Information;
var eventId = Model.Create <EventId>();
var state = Guid.NewGuid().ToString();
var message = Guid.NewGuid().ToString();
var exception = new ArgumentNullException(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
string Formatter(string logState, Exception?error) => message;
var categoryName = Guid.NewGuid().ToString();
var output = Substitute.For <ITestOutputHelper>();
var sut = new TestOutputLogger(categoryName, output);
sut.Log(logLevel, eventId, state, exception, Formatter);
output.Received(1).WriteLine(Arg.Any <string>());
output.Received()
.WriteLine(Arg.Is <string>(x => x.Contains(exception.ToString(), StringComparison.OrdinalIgnoreCase)));
}
public void WritesScopeMessagesWithStructuredDataUsingFormatter()
{
var logLevel = LogLevel.Error;
var eventId = Model.Create <EventId>();
var message = Guid.NewGuid().ToString();
var sensitiveValue = Guid.NewGuid().ToString();
var categoryName = Guid.NewGuid().ToString();
var config = new LoggingConfig().Set(x => x.SensitiveValues.Add(sensitiveValue));
var state = Model.Create <StructuredData>().Set(x => x.FirstName += " " + sensitiveValue);
var output = Substitute.For <ITestOutputHelper>();
var sut = new TestOutputLogger(categoryName, output, config);
using (sut.BeginScope(state))
{
sut.Log(logLevel, eventId, message);
}
output.DidNotReceive().WriteLine(Arg.Is <string>(x => x.Contains(sensitiveValue)));
}
public void TestDequeueEvent()
{
var logger = new TestOutputLogger(this.TestOutput, false);
using var queue = new TestEventQueue(logger, (notification, evt, _) => { });
var(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.Unavailable, deqeueStatus);
Assert.Equal(0, queue.Size);
queue.Enqueue(new E1(), null, null);
(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.IsType <E1>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(0, queue.Size);
queue.Enqueue(new E3(), null, null);
queue.Enqueue(new E2(), null, null);
queue.Enqueue(new E1(), null, null);
(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.IsType <E3>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(2, queue.Size);
(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.IsType <E2>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(1, queue.Size);
(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.IsType <E1>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(0, queue.Size);
(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.Unavailable, deqeueStatus);
Assert.Equal(0, queue.Size);
}
public void TestEnqueueEvent()
{
var logger = new TestOutputLogger(this.TestOutput, false);
var machineStateManager = new MockStateMachineManager(logger,
(notification, evt, _) => { });
using (var queue = new EventQueue(machineStateManager))
{
Assert.Equal(0, queue.Size);
var enqueueStatus = queue.Enqueue(new E1(), Guid.Empty, null);
Assert.Equal(1, queue.Size);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
enqueueStatus = queue.Enqueue(new E2(), Guid.Empty, null);
Assert.Equal(2, queue.Size);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
enqueueStatus = queue.Enqueue(new E3(), Guid.Empty, null);
Assert.Equal(3, queue.Size);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
}
}
public async SystemTasks.Task TestReceiveEvent()
{
int notificationCount = 0;
var tcs = new TaskCompletionSource <bool>();
var logger = new TestOutputLogger(this.TestOutput, false);
var mockActorManager = new MockActorManager(logger,
(notification, evt, _) =>
{
notificationCount++;
if (notificationCount == 2)
{
Assert.Equal(MockActorManager.Notification.ReceiveEvent, notification);
tcs.SetResult(true);
}
});
using (var queue = new EventQueue(mockActorManager))
{
var receivedEventTask = queue.ReceiveEventAsync(typeof(E1));
var enqueueStatus = queue.Enqueue(new E1(), Guid.Empty, null);
Assert.Equal(EnqueueStatus.Received, enqueueStatus);
Assert.Equal(0, queue.Size);
var receivedEvent = await receivedEventTask;
Assert.IsType <E1>(receivedEvent);
Assert.Equal(0, queue.Size);
var(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus);
Assert.Equal(0, queue.Size);
await Task.WhenAny(tcs.Task, Task.Delay(500));
Assert.True(tcs.Task.IsCompleted);
}
}
public void TransactionLogger_Redacts_Properly()
{
var testOutputLogger = new TestOutputLogger(this.outputHelper, nameof(LoggerTests));
var config = new TransactionConfigImmutable(
ExpirationTime: TimeSpan.FromMinutes(10),
CleanupLostAttempts: false,
CleanupClientAttempts: false,
CleanupWindow: TimeSpan.FromSeconds(10),
KeyValueTimeout: TimeSpan.FromSeconds(10),
DurabilityLevel: DurabilityLevel.Majority,
LoggerFactory: null,
MetadataCollection: null
);
var ctx = new TransactionContext(Guid.NewGuid().ToString(), DateTimeOffset.UtcNow, config, null);
var loggerFactory = new TransactionsLoggerFactory(new TestOutputLoggerFactory(this.outputHelper), ctx);
var transactionsLogger = loggerFactory.CreateLogger(nameof(TransactionLogger_Redacts_Properly));
var redactor = new TestRedactor();
transactionsLogger.LogDebug("Example UD: {id}", redactor.UserData("default:_default:_default" + Guid.NewGuid().ToString()));
var logs = ctx.Logs.ToList();
Assert.NotEmpty(logs);
Assert.Collection(logs, s => s.Contains("</ud>"));
}
public async Task TestReceiveEventMultipleTypes()
{
int notificationCount = 0;
var tcs = new TaskCompletionSource <bool>();
var logger = new TestOutputLogger(this.TestOutput, false);
using var queue = new TestEventQueue(logger, (notification, evt, _) =>
{
notificationCount++;
if (notificationCount is 2)
{
Assert.Equal(TestEventQueue.Notification.ReceiveEvent, notification);
tcs.SetResult(true);
}
});
var receivedEventTask = queue.ReceiveEventAsync(typeof(E1), typeof(E2));
var enqueueStatus = queue.Enqueue(new E2(), null, null);
Assert.Equal(EnqueueStatus.Received, enqueueStatus);
Assert.Equal(0, queue.Size);
var receivedEvent = await receivedEventTask;
Assert.IsType <E2>(receivedEvent);
Assert.Equal(0, queue.Size);
var(deqeueStatus, e, group, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.Unavailable, deqeueStatus);
Assert.Equal(0, queue.Size);
await Task.WhenAny(tcs.Task, Task.Delay(500));
Assert.True(tcs.Task.IsCompleted);
}
public static ITargetResult BuildScenario(string scenarioName, object properties = null, string target = "GetPackageContents", ITestOutputHelper output = null, LoggerVerbosity? verbosity = null)
{
var projectName = scenarioName;
if (scenarioName.StartsWith("given", StringComparison.OrdinalIgnoreCase))
projectName = string.Join("_", scenarioName.Split('_').Skip(2));
var scenarioDir = Path.Combine(ModuleInitializer.BaseDirectory, "Scenarios", scenarioName);
string projectOrSolution;
if (File.Exists(Path.Combine(scenarioDir, $"{projectName}.csproj")))
projectOrSolution = Path.Combine(scenarioDir, $"{projectName}.csproj");
else
projectOrSolution = Directory.EnumerateFiles(scenarioDir, "*.csproj").First();
var logger = default(ILogger);
if (output != null)
{
if (verbosity == null)
{
var data = Thread.GetNamedDataSlot(nameof(LoggerVerbosity));
if (data != null)
verbosity = (LoggerVerbosity?)Thread.GetData(data);
}
logger = new TestOutputLogger(output, verbosity);
}
if (properties != null)
return Build(projectOrSolution, target,
properties: properties.GetType().GetProperties().ToDictionary(prop => prop.Name, prop => prop.GetValue(properties).ToString()),
logger: logger)[target];
else
return Build(projectOrSolution, target, logger: logger)[target];
}
public ApiServerTest(ITestOutputHelper testOutputHelper)
{
TestOutputLogger.Configure(testOutputHelper);
}
private async Task RandomisedTest(RandomConfig config)
{
// ARRANGE
var testLogger = new TestOutputLogger();
var groupName = Guid.NewGuid().ToString();
await this.zkHelper.InitializeAsync("/rebalanser", TimeSpan.FromSeconds(20), TimeSpan.FromSeconds(30));
await this.zkHelper.PrepareResourceGroupAsync(groupName, "res", config.ResourceCount);
var resourceMonitor = new ResourceMonitor();
List <int> resSuffixes = new List <int>();
for (int i = 0; i < config.ResourceCount; i++)
{
resourceMonitor.CreateResource($"res{i}");
resSuffixes.Add(i);
}
var clientOptions = new ClientOptions()
{
AutoRecoveryOnError = true,
RestartDelay = TimeSpan.FromSeconds(10),
OnAssignmentDelay = config.OnAssignmentDelay
};
var clients = new List <TestClient>();
for (int i = 0; i < config.ClientCount; i++)
{
clients.Add(new TestClient(resourceMonitor,
groupName,
clientOptions,
config.OnStartEventHandlerTime,
config.OnStopEventHandlerTime,
config.RandomiseEventHandlerTimes));
}
for (int i = 0; i < config.ClientCount; i++)
{
if (config.StartUpClientInterval.TotalMilliseconds > 0)
{
await Task.Delay(config.StartUpClientInterval);
}
await clients[i].StartAsync(ZkHelper.ZooKeeperHosts,
"/rebalanser",
this.currentConfig.SessionTimeout,
this.currentConfig.ConnectTimeout,
this.currentConfig.minRebalancingInterval,
testLogger);
}
await Task.Delay(TimeSpan.FromSeconds(30));
// ACT
var sw = new Stopwatch();
sw.Start();
var rand = new Random(Guid.NewGuid().GetHashCode());
int testCounter = 0;
while (sw.Elapsed < config.TestDuration)
{
testLogger.Info("TEST RUNNER", "Test " + testCounter);
// action == 0 -> add/remove a client
// action == 1 -> add/remove a resource
var action = rand.Next(2);
if (action == 0)
{
var clientIndex = rand.Next(config.ClientCount);
await clients[clientIndex].PerformActionAsync(ZkHelper.ZooKeeperHosts,
"/rebalanser",
this.currentConfig.SessionTimeout,
this.currentConfig.ConnectTimeout,
this.currentConfig.minRebalancingInterval,
testLogger);
}
else
{
// resAction == 0 && resources exist -> remove a resource
// else add a resource
var resAction = rand.Next(2);
if (resAction == 0 || !resSuffixes.Any())
{
var resSuffix = resSuffixes.Any() ? resSuffixes.Max() + 1 : 0;
resSuffixes.Add(resSuffix);
resourceMonitor.AddResource($"res{resSuffix}");
testLogger.Info("TEST RUNNER", "Adding a resource");
await this.zkHelper.AddResourceAsync(groupName, $"res{resSuffix}");
testLogger.Info("TEST RUNNER", "Added a resource");
}
else
{
var index = rand.Next(resSuffixes.Count);
var resSuffix = resSuffixes[index];
resSuffixes.RemoveAt(index);
resourceMonitor.RemoveResource($"res{resSuffix}");
testLogger.Info("TEST RUNNER", "Removing a resource");
await this.zkHelper.DeleteResourceAsync(groupName, $"res{resSuffix}");
testLogger.Info("TEST RUNNER", "Removed a resource");
}
}
// wait for the configured period of time before making asserts
// this gives the necessary time for rebalancing
TimeSpan currentTestInterval;
if (config.RandomiseInterval)
{
currentTestInterval = TimeSpan.FromMilliseconds(rand.Next((int)config.MaxInterval.TotalMilliseconds));
}
else
{
currentTestInterval = config.MaxInterval;
}
await Task.Delay(currentTestInterval);
resourceMonitor.PrintEvents($"/home/jack/tmp/rebalanser-zk/test-{groupName}");
// check for double assignments. All test scenarios must check this. No matter
// what happens, we can never allow double assignments - ever
if (resourceMonitor.DoubleAssignmentsExist())
{
foreach (var violation in resourceMonitor.GetDoubleAssignments())
{
testLogger.Error("TEST RUNNER", violation.ToString());
}
}
Assert.False(resourceMonitor.DoubleAssignmentsExist());
// depending on the type of test, we'll ensure that all resources have been assigned
// some tests that have extremely short durations between events do not leave enough time
// for rebalancing and so do not perform this check. The conditional check will
// only perform this check when a long enough time period has been allowed for rebalancing to complete
if (config.CheckType == CheckType.FullCheck)
{
if (clients.Any(x => x.Started))
{
testLogger.Info("TEST RUNNER", "Perform all resources assigned check");
Assert.True(resourceMonitor.AllResourcesAssigned());
}
}
else if (config.CheckType == CheckType.ConditionalCheck)
{
if (testCounter % config.ConditionalCheckInterval == 0 && clients.Any(x => x.Started))
{
testLogger.Info("TEST RUNNER", "Grace period before all resources assigned check");
await Task.Delay(config.ConditionalCheckWaitPeriod);
testLogger.Info("TEST RUNNER", "Perform all resources assigned check");
Assert.True(resourceMonitor.AllResourcesAssigned());
}
}
testCounter++;
}
// clean up
for (int i = 0; i < config.ClientCount; i++)
{
await clients[i].StopAsync();
}
}
public void when_compiling_twice_then_does_not_cause_new_compilation()
{
var logger = new TestOutputLogger(output);
var targetDir = Path.Combine(ModuleInitializer.BaseDirectory, MethodBase.GetCurrentMethod().Name);
var targetFileName = Path.Combine(targetDir, "bin", "Debug",
Path.GetFileName(Assembly.GetExecutingAssembly().ManifestModule.FullyQualifiedName));
var componentFile = Path.Combine(targetDir, "Component.cs");
var firstBuild = BuildProject(logger, (project, properties) =>
{
if (!Directory.Exists(targetDir))
{
Directory.CreateDirectory(targetDir);
}
File.WriteAllText(componentFile, @"
using System;
using System.Reactive.Disposables;
using System.ComponentModel.Composition;
namespace Clide
{
[Component(CreationPolicy.Shared)]
public partial class Producer : IObservable<DerivedEvent>
{
public IDisposable Subscribe(IObserver<DerivedEvent> observer)
{
observer.OnNext(new DerivedEvent());
return Disposable.Empty;
}
}
public class BaseEvent { }
public class DerivedEvent : BaseEvent { }
}
");
project.AddItem("Compile", "Component.cs");
return("Build");
});
Assert.True(firstBuild.HasResultsForTarget("Build"));
Assert.Equal(TargetResultCode.Success, firstBuild.ResultsByTarget["Build"].ResultCode);
var firstPassTasks = logger.FinishedTasks.ToArray();
var firstTimestamp = File.GetLastWriteTime(targetFileName);
Assert.True(firstPassTasks.Any(e => e.TaskName == "FindComponents"));
Assert.True(firstPassTasks.Any(e => e.TaskName == "ExportComponents"));
var projectFile = Path.Combine(targetDir, "Test.csproj");
var request = new BuildRequestData(projectFile, new Dictionary <string, string>(), null, new[] { "Build" }, null);
var parameters = new BuildParameters
{
GlobalProperties = new Dictionary <string, string>(),
UseSynchronousLogging = true,
Loggers = new[] { logger }
};
logger.Reset();
var secondBuild = BuildManager.DefaultBuildManager.Build(parameters, request);
var secondPassTasks = logger.FinishedTasks.ToArray();
var secondTimestamp = File.GetLastWriteTime(targetFileName);
Assert.False(secondPassTasks.Any(e => e.TaskName == "FindComponents"), "FindComponents shouldn't have been executed on the second build.");
Assert.False(secondPassTasks.Any(e => e.TaskName == "ExportComponents"), "ExportComponents shouldn't have been executed on the second build.");
Assert.Equal(firstTimestamp, secondTimestamp);
File.SetLastWriteTime(componentFile, DateTime.Now);
logger.Reset();
var thirdBuild = BuildManager.DefaultBuildManager.Build(parameters, request);
var thirdPassTasks = logger.FinishedTasks.ToArray();
var thirdTimestamp = File.GetLastWriteTime(targetFileName);
Assert.True(thirdPassTasks.Any(e => e.TaskName == "FindComponents"));
Assert.True(thirdPassTasks.Any(e => e.TaskName == "ExportComponents"));
Assert.NotEqual(secondTimestamp, thirdTimestamp);
}
public void when_compiling_twice_then_does_not_cause_new_compilation()
{
var logger = new TestOutputLogger(output);
var targetDir = Path.Combine(ModuleInitializer.BaseDirectory, MethodBase.GetCurrentMethod().Name);
var targetFileName = Path.Combine(targetDir, "bin", "Debug",
Path.GetFileName(Assembly.GetExecutingAssembly().ManifestModule.FullyQualifiedName));
var componentFile = Path.Combine(targetDir, "Component.cs");
var firstBuild = BuildProject(logger, (project, properties) =>
{
if (!Directory.Exists(targetDir))
Directory.CreateDirectory(targetDir);
File.WriteAllText(componentFile, @"
using System;
using System.Reactive.Disposables;
using System.ComponentModel.Composition;
namespace Clide
{
[Component(CreationPolicy.Shared)]
public partial class Producer : IObservable<DerivedEvent>
{
public IDisposable Subscribe(IObserver<DerivedEvent> observer)
{
observer.OnNext(new DerivedEvent());
return Disposable.Empty;
}
}
public class BaseEvent { }
public class DerivedEvent : BaseEvent { }
}
");
project.AddItem("Compile", "Component.cs");
return "Build";
});
Assert.True(firstBuild.HasResultsForTarget("Build"));
Assert.Equal(TargetResultCode.Success, firstBuild.ResultsByTarget["Build"].ResultCode);
var firstPassTasks = logger.FinishedTasks.ToArray();
var firstTimestamp = File.GetLastWriteTime(targetFileName);
Assert.True(firstPassTasks.Any(e => e.TaskName == "FindComponents"));
Assert.True(firstPassTasks.Any(e => e.TaskName == "ExportComponents"));
var projectFile = Path.Combine(targetDir, "Test.csproj");
var request = new BuildRequestData(projectFile, new Dictionary<string, string>(), null, new[] { "Build" }, null);
var parameters = new BuildParameters
{
GlobalProperties = new Dictionary<string, string>(),
UseSynchronousLogging = true,
Loggers = new[] { logger }
};
logger.Reset();
var secondBuild = BuildManager.DefaultBuildManager.Build(parameters, request);
var secondPassTasks = logger.FinishedTasks.ToArray();
var secondTimestamp = File.GetLastWriteTime(targetFileName);
Assert.False(secondPassTasks.Any(e => e.TaskName == "FindComponents"), "FindComponents shouldn't have been executed on the second build.");
Assert.False(secondPassTasks.Any(e => e.TaskName == "ExportComponents"), "ExportComponents shouldn't have been executed on the second build.");
Assert.Equal(firstTimestamp, secondTimestamp);
File.SetLastWriteTime(componentFile, DateTime.Now);
logger.Reset();
var thirdBuild = BuildManager.DefaultBuildManager.Build(parameters, request);
var thirdPassTasks = logger.FinishedTasks.ToArray();
var thirdTimestamp = File.GetLastWriteTime(targetFileName);
Assert.True(thirdPassTasks.Any(e => e.TaskName == "FindComponents"));
Assert.True(thirdPassTasks.Any(e => e.TaskName == "ExportComponents"));
Assert.NotEqual(secondTimestamp, thirdTimestamp);
}
public ModulesProcessorTest(ITestOutputHelper testOutputHelper)
{
TestOutputLogger.Configure(testOutputHelper);
}
public static TargetResult BuildScenario(
string scenarioName,
object properties = null,
string projectName = null,
string target = "GetPackageContents",
ITestOutputHelper output = null,
LoggerVerbosity?verbosity = null)
{
var scenarioDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Scenarios", scenarioName);
if (projectName == null)
{
projectName = scenarioName;
if (scenarioName.StartsWith("given", StringComparison.OrdinalIgnoreCase))
{
projectName = string.Join("_", scenarioName.Split('_').Skip(2));
}
}
else if (!File.Exists(Path.Combine(scenarioDir, $"{projectName}.csproj")))
{
throw new FileNotFoundException($"Project '{projectName}' was not found under scenario path '{scenarioDir}'.", projectName);
}
string projectOrSolution;
if (File.Exists(Path.Combine(scenarioDir, $"{projectName}.csproj")))
{
projectOrSolution = Path.Combine(scenarioDir, $"{projectName}.csproj");
}
else
{
projectOrSolution = Directory.EnumerateFiles(scenarioDir, "*.*proj").FirstOrDefault();
}
var logger = default(TestOutputLogger);
if (output != null)
{
if (verbosity == null)
{
var data = Thread.GetNamedDataSlot(nameof(LoggerVerbosity));
if (data != null)
{
verbosity = (LoggerVerbosity?)Thread.GetData(data);
}
}
logger = new TestOutputLogger(output, verbosity);
}
else
{
logger = new TestOutputLogger(null);
}
var loggers = OpenBuildLogAttribute.IsActive ?
new ILogger[] { logger, new StructuredLogger {
Verbosity = verbosity.GetValueOrDefault(), Parameters = scenarioName + ".binlog"
} } :
new ILogger[] { logger };
var buildProps = properties?.GetType().GetProperties()
.ToDictionary(prop => prop.Name, prop => prop.GetValue(properties).ToString())
?? new Dictionary <string, string>();
buildProps[nameof(ThisAssembly.Project.Properties.NuGetRestoreTargets)] = ThisAssembly.Project.Properties.NuGetRestoreTargets;
buildProps[nameof(ThisAssembly.Project.Properties.NuGetTargets)] = ThisAssembly.Project.Properties.NuGetTargets;
var result = Build(projectOrSolution, target, buildProps, loggers);
if (OpenBuildLogAttribute.IsActive)
{
Process.Start(scenarioName + ".binlog");
}
return(new TargetResult(projectOrSolution, result, target, logger));
}
public TargetResult(string projectOrSolutionFile, BuildResult result, string target, TestOutputLogger logger)
{
ProjectOrSolutionFile = projectOrSolutionFile;
BuildResult = result;
Target = target;
Logger = logger;
}
public MessagePackMessageSerializerTest(ITestOutputHelper testOutputHelper)
{
TestOutputLogger.Configure(testOutputHelper);
}
public SettingsSerializerTest(ITestOutputHelper testOutputHelper)
{
_testFileManager = new TestFileManager(testOutputHelper);
TestOutputLogger.Configure(testOutputHelper);
}
public GitHubUpdateServiceTest(ITestOutputHelper testOutputHelper)
{
TestOutputLogger.Configure(testOutputHelper);
}
