public async Task TaskReturnsVoid_OrchestratorFails()
{
using (TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(false))
{
await host.StartAsync();
TaskActivity activity = TestOrchestrationHost.MakeActivity <int, Task>(
delegate(TaskContext ctx, int input)
{
return(null);
});
TestInstance <int> instance = await host.StartInlineOrchestration(
input : 123,
orchestrationName : "TestOrchestration",
implementation : (ctx, input) => ctx.ScheduleTask <int>("Activity", "", input),
activities : ("Activity", activity));
// The expectedOutput value is the string that's passed into the InvalidOperationException
await Task.WhenAll(instance.WaitForCompletion(
expectedStatus: OrchestrationStatus.Completed,
expectedOutput: 0));
await host.StopAsync();
}
}
public async Task ConcurrentOrchestrationStarts(bool useSameInstanceId)
{
using TestOrchestrationHost host = TestHelpers.GetTestOrchestrationHost(
enableExtendedSessions: false,
modifySettingsAction: settings => settings.ThrowExceptionOnInvalidDedupeStatus = false);
await host.StartAsync();
var results = new ConcurrentBag <string>();
// We want a number sufficiently high that it results in multiple message batches
const int MaxConcurrency = 40;
TaskActivity activity = TestOrchestrationHost.MakeActivity(
delegate(TaskContext ctx, string input)
{
string result = $"Hello, {input}!";
results.Add(result);
return(result);
});
// Use the same instance name for all instances
Func <int, string> instanceIdGenerator;
Func <int, string> inputGenerator;
if (useSameInstanceId)
{
instanceIdGenerator = _ => $"ConcurrentInstance_SINGLETON";
inputGenerator = _ => "World";
}
else
{
instanceIdGenerator = i => $"ConcurrentInstance_{i:00}";
inputGenerator = i => $"{i:00}";
}
List <TestInstance <string> > instances = await host.StartInlineOrchestrations(
MaxConcurrency,
instanceIdGenerator,
inputGenerator,
orchestrationName : "SayHelloOrchestration",
version : string.Empty,
implementation : (ctx, input) => ctx.ScheduleTask <string>("SayHello", "", input),
activities : ("SayHello", activity));
Assert.AreEqual(MaxConcurrency, instances.Count);
// All returned objects point to the same orchestration instance
OrchestrationState[] finalStates = await Task.WhenAll(instances.Select(
i => i.WaitForCompletion(timeout: TimeSpan.FromMinutes(2), expectedOutputRegex: @"Hello, \w+!")));
if (useSameInstanceId)
{
// Make sure each instance is exactly the same
string firstInstanceJson = JsonConvert.SerializeObject(finalStates[0]);
foreach (OrchestrationState state in finalStates.Skip(1))
{
string json = JsonConvert.SerializeObject(state);
Assert.AreEqual(firstInstanceJson, json, "Expected that all instances have the same data.");
}
}
else
{
// Make sure each instance is different
Assert.AreEqual(MaxConcurrency, finalStates.Select(s => s.OrchestrationInstance.InstanceId).Distinct().Count());
Assert.AreEqual(MaxConcurrency, finalStates.Select(s => s.OrchestrationInstance.ExecutionId).Distinct().Count());
Assert.AreEqual(MaxConcurrency, finalStates.Select(s => s.Input).Distinct().Count());
Assert.AreEqual(MaxConcurrency, finalStates.Select(s => s.Output).Distinct().Count());
}
await host.StopAsync();
}
