public void Should_generate_unique_identifiers_with_each_invocation()
{
NewId.Next();
Stopwatch timer = Stopwatch.StartNew();
int limit = 1024*1024;
var ids = new NewId[limit];
for (int i = 0; i < limit; i++)
{
ids[i] = NewId.Next();
}
timer.Stop();
for (int i = 0; i < limit - 1; i++)
{
Assert.AreNotEqual(ids[i], ids[i + 1]);
string end = ids[i].ToString().Substring(32, 4);
if (end == "0000")
{
Console.WriteLine("{0}", ids[i].ToString());
}
}
Console.WriteLine("Generated {0} ids in {1}ms ({2}/ms)", limit, timer.ElapsedMilliseconds,
limit/timer.ElapsedMilliseconds);
}
public void Should_be_completely_thread_safe_to_avoid_duplicates()
{
NewId.Next();
Stopwatch timer = Stopwatch.StartNew();
int threadCount = 20;
int workerThreads, complete;
ThreadPool.GetMinThreads(out workerThreads, out complete);
ThreadPool.SetMinThreads(workerThreads + threadCount, complete);
var loopCount = 1024 * 1024;
int limit = loopCount * threadCount;
var ids = new NewId[limit];
var tasks = new List<Task>();
var begin = new TaskCompletionSource<bool>();
for (int threadId = 0; threadId < threadCount; threadId++)
{
var start = threadId * loopCount;
var end = start + loopCount;
var task = Task.Factory.StartNew(() =>
{
//begin.Task.Wait();
for (int i = start; i < end; i++)
ids[i] = NewId.Next();
});
tasks.Add(task);
}
//begin.SetResult(true);
Task.WaitAll(tasks.ToArray());
timer.Stop();
Console.WriteLine("Generated {0} ids in {1}ms ({2}/ms)", limit, timer.ElapsedMilliseconds,
limit / timer.ElapsedMilliseconds);
Console.WriteLine("Distinct: {0}", ids.Distinct().Count());
var duplicates = ids.GroupBy(x => x).Where(x => x.Count() > 1).ToArray();
Console.WriteLine("Duplicates: {0}", duplicates.Count());
foreach (var newId in duplicates)
{
Console.WriteLine("{0} {1}", newId.Key, newId.Count());
}
}
public void Should_convert_using_the_optimized_human_readable_formatter()
{
var n = new NewId("F6B27C7C-8AB8-4498-AC97-3A6107A21320");
var formatter = new ZBase32Formatter(true);
string ns = n.ToString(formatter);
Assert.AreEqual("6438A9RKZBNJTMRZ8JOOXEOUBY", ns);
}
public void Should_make_the_round_trip_successfully_via_bytes()
{
Guid g = Guid.NewGuid();
var n = new NewId(g.ToByteArray());
var gn = new Guid(n.ToByteArray());
Assert.AreEqual(g, gn);
}
public void Should_convert_using_standard_base32_formatting_characters()
{
var n = new NewId("F6B27C7C-8AB8-4498-AC97-3A6107A21320");
var formatter = new Base32Formatter(true);
string ns = n.ToString(formatter);
Assert.AreEqual("62ZHY7EKXBCJRLEXHJQQPIQTBA", ns);
}
public void Should_convert_using_custom_base32_formatting_characters()
{
var n = new NewId("F6B27C7C-8AB8-4498-AC97-3A6107A21320");
var formatter = new Base32Formatter("0123456789ABCDEFGHIJKLMNOPQRSTUV");
string ns = n.ToString(formatter);
Assert.AreEqual("UQP7OV4AN129HB4N79GGF8GJ10", ns);
}
public void Should_work_from_guid_to_newid_to_guid()
{
Guid g = Guid.NewGuid();
var n = new NewId(g.ToByteArray());
string gs = g.ToString("d");
string ns = n.ToString("d");
Assert.AreEqual(gs, ns);
}
public void Should_match_string_output_n()
{
var bytes = new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 12, 14, 15};
var g = new Guid(bytes);
var n = new NewId(bytes);
string gs = g.ToString("N");
string ns = n.ToString("N");
Assert.AreEqual(gs, ns);
}
public void Should_work_from_newid_to_guid_to_newid()
{
NewId n = NewId.Next();
var g = new Guid(n.ToByteArray());
var ng = new NewId(g.ToByteArray());
Console.WriteLine(g.ToString("D"));
Assert.AreEqual(n, ng);
}
public void Should_convert_back_using_standard_parser()
{
var n = new NewId("F6B27C7C-8AB8-4498-AC97-3A6107A21320");
var formatter = new Base32Formatter(true);
string ns = n.ToString(formatter);
var parser = new Base32Parser();
NewId newId = parser.Parse(ns);
Assert.AreEqual(n, newId);
}
public void Should_generate_sequential_ids_quickly()
{
NewId.SetTickProvider(new StopwatchTickProvider());
NewId.Next();
int limit = 10;
var ids = new NewId[limit];
for (int i = 0; i < limit; i++)
ids[i] = NewId.Next();
for (int i = 0; i < limit - 1; i++)
{
Assert.AreNotEqual(ids[i], ids[i + 1]);
Console.WriteLine(ids[i]);
}
}
public void Should_keep_them_ordered_for_sql_server()
{
var generator = new NewIdGenerator(new TimeLapseTickProvider(), new NetworkAddressWorkerIdProvider());
generator.Next();
int limit = 1024;
var ids = new NewId[limit];
for (int i = 0; i < limit; i++)
{
ids[i] = generator.Next();
}
for (int i = 0; i < limit - 1; i++)
{
Assert.AreNotEqual(ids[i], ids[i + 1]);
Assert.Less(ids[i], ids[i + 1]);
if (i%16 == 0)
Console.WriteLine(ids[i]);
}
}
public void Should_keep_them_ordered_for_sql_server()
{
var generator = new NewIdGenerator(new TimeLapseTickProvider(), new NetworkAddressWorkerIdProvider());
generator.Next();
int limit = 1024;
var ids = new NewId[limit];
for (int i = 0; i < limit; i++)
ids[i] = generator.Next();
for (int i = 0; i < limit - 1; i++)
{
Assert.AreNotEqual(ids[i], ids[i + 1]);
SqlGuid left = ids[i].ToGuid();
SqlGuid right = ids[i + 1].ToGuid();
Assert.Less(left, right);
if (i % 128 == 0)
Console.WriteLine("Normal: {0} Sql: {1}", left, ids[i].ToSequentialGuid());
}
}
public void GetWhereStatementAndParametersFromExpression_HandlesMultipleValues()
{
// Arrange
var sagaId = NewId.NextGuid();
Expression <Func <SimpleSaga, bool> > filter = x => x.CorrelationId == sagaId && x.Completed && x.CorrelateBySomething == "Kebabsvarv";
// Act
var(whereStatement, dynamicParameters) = WhereStatementHelper.GetWhereStatementAndParametersFromExpression(filter);
// Assert
Assert.That(whereStatement, Is.EqualTo($"WHERE CorrelationId = @value0 AND Completed = @value1 AND CorrelateBySomething = @value2"));
var sagaIdParameter = dynamicParameters.Get <Guid>("value0");
Assert.That(sagaIdParameter, Is.EqualTo(sagaId));
var completedParameter = dynamicParameters.Get <object>("value1");
Assert.That(completedParameter, Is.True);
var correlateBySomethingParameter = dynamicParameters.Get <string>("value2");
Assert.That(correlateBySomethingParameter, Is.EqualTo("Kebabsvarv"));
}
public async Task Consume(ConsumeContext <FullfillOrderMessage> context)
{
var Baskets = dbContext.OrderItems.Where(x => x.OrderId == context.Message.OrderId)
.Select(p => new { ProductId = p.ProductId, Count = p.Count }).ToList();
logger.LogInformation($"Fullfilled order {context.Message.OrderId}");
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var submitOrderUrl = QueueNames.GetActivityUri(nameof(SubmitOrderActivity));
builder.AddActivity("SubmitOrder", submitOrderUrl, new
{
context.Message.OrderId
});;
builder.AddActivity("Payment", QueueNames.GetActivityUri(nameof(PaymentActivity)), new {
context.Message.OrderId,
context.Message.CustomerId,
context.Message.Credit
});
builder.AddActivity("TakeProduct", QueueNames.GetActivityUri(nameof(TakeProductActivity)), new
{
context.Message.OrderId,
Baskets
});
builder.AddVariable("OrderId", context.Message.OrderId);
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental,
RoutingSlipEventContents.None, x => x.Send <OrderFulfillFaulted>(new { context.Message.OrderId }));
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental,
RoutingSlipEventContents.None, x => x.Send <OrderFullfillCompleted>(new { context.Message.OrderId }));
var routingSlip = builder.Build();
await context.Execute(routingSlip).ConfigureAwait(false);
}
public async Task Should_work_as_expected()
{
Task <ConsumeContext <TestStarted> > started = ConnectPublishHandler <TestStarted>();
Task <ConsumeContext <TestUpdated> > updated = ConnectPublishHandler <TestUpdated>();
var correlationId = NewId.NextGuid();
var testKey = NewId.NextGuid().ToString();
await InputQueueSendEndpoint.Send(new StartTest
{
CorrelationId = correlationId,
TestKey = testKey
});
await started;
await InputQueueSendEndpoint.Send(new UpdateTest
{
TestId = correlationId,
TestKey = testKey
});
await updated;
}
public override string CreateTemporaryQueueName(string prefix)
{
var sb = new StringBuilder(prefix);
var host = HostMetadataCache.Host;
foreach (var c in host.MachineName)
{
if (char.IsLetterOrDigit(c))
{
sb.Append(c);
}
else if (c == '_' || c == '-')
{
sb.Append(c);
}
}
sb.Append('-');
foreach (var c in host.ProcessName)
{
if (char.IsLetterOrDigit(c))
{
sb.Append(c);
}
else if (c == '_' || c == '-')
{
sb.Append(c);
}
}
sb.Append('-');
sb.Append(NewId.Next().ToString(Formatter));
return(sb.ToString());
}
public async Task Should_load_the_data_from_the_repository()
{
string data = NewId.NextGuid().ToString();
Uri dataAddress;
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(data), false))
{
dataAddress = await _messageDataRepository.Put(stream);
}
var message = new SendMessageWithBigData {
Body = new ConstantMessageData <string>(dataAddress, data)
};
await InputQueueSendEndpoint.Send(message);
ConsumeContext <MessageWithBigData> received = await _received;
string value = await received.Message.Body.Value;
value.ShouldBe(data);
Console.WriteLine(value);
}
public async Task Should_have_a_subscription_for_the_third_saga_message()
{
var sagaId = NewId.NextGuid();
var message = new FirstSagaMessage {
CorrelationId = sagaId
};
await InputQueueSendEndpoint.Send(message);
Guid?foundId = await GetSagaRepository <SimpleSaga>().ShouldContainSaga(message.CorrelationId, TestTimeout);
foundId.HasValue.ShouldBe(true);
var nextMessage = new ThirdSagaMessage {
CorrelationId = sagaId
};
await InputQueueSendEndpoint.Send(nextMessage);
foundId = await GetSagaRepository <SimpleSaga>().ShouldContainSaga(x => x.CorrelationId == sagaId && x.Third.IsCompleted, TestTimeout);
foundId.HasValue.ShouldBe(true);
}
public async Task Should_complete()
{
var orderId = NewId.NextGuid();
var fryId = NewId.NextGuid();
var burgerId = NewId.NextGuid();
using var scope = Provider.CreateScope();
var client = scope.ServiceProvider.GetRequiredService <IRequestClient <SubmitOrder> >();
Response <OrderCompleted, OrderFaulted> response = await client.GetResponse <OrderCompleted, OrderFaulted>(new
{
OrderId = orderId,
Fries = new[]
{
new
{
FryId = fryId,
Size = Size.Large
}
},
Burgers = new[]
{
new Burger
{
BurgerId = burgerId,
Weight = 1.0m,
Cheese = true,
}
},
Shakes = default(Shake[]),
FryShakes = default(FryShake[])
});
Assert.That(response.Is(out Response <OrderCompleted> completed), "Order did not complete");
}
public TrashRemovalStateMachine()
{
InstanceState(instance => instance.CurrentState, Requested);
Event(() => TrashRemovalRequested, x =>
{
x.CorrelateBy(instance => instance.BinNumber, context => context.Message.BinNumber);
x.SelectId(context => NewId.NextGuid());
});
Initially(
When(TrashRemovalRequested)
.Then(x =>
{
x.Instance.BinNumber = x.Data.BinNumber;
x.Instance.RequestTimestamp = x.GetPayload <ConsumeContext>().SentTime ?? DateTime.UtcNow;
})
.PublishAsync(x => x.Init <EmptyTrashBin>(new { x.Data.BinNumber }))
.TransitionTo(Requested));
During(Requested,
When(TrashRemovalRequested)
.PublishAsync(x => x.Init <EmptyTrashBin>(new { x.Data.BinNumber })));
}
public async Task Should_accept_when_order_is_accepted()
{
var harness = new InMemoryTestHarness();
var orderStateMachine = new OrderStateMachine();
var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine);
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.Bus.Publish <OrderSubmitted>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = customerNumber
});
Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True);
var instanceId = await saga.Exists(orderId, x => x.Submitted);
Assert.That(instanceId, Is.Not.Null);
await harness.Bus.Publish <OrderAccepted>(new
{
OrderId = orderId, Timestamp = InVar.Timestamp
});
instanceId = await saga.Exists(orderId, x => x.Accepted);
Assert.That(instanceId, Is.Not.Null);
}
finally
{
await harness.Stop();
}
}
public HostExecuteContext(HostInfo host, Uri compensationAddress, ConsumeContext <RoutingSlip> context)
: base(new PayloadCacheScope(context), context.CancellationToken)
{
_host = host;
_compensationAddress = compensationAddress;
_context = context;
_timer = Stopwatch.StartNew();
var newId = NewId.Next();
_executionId = newId.ToGuid();
_timestamp = newId.Timestamp;
_routingSlip = new SanitizedRoutingSlip(context);
if (_routingSlip.Itinerary.Count == 0)
{
throw new ArgumentException("The routingSlip must contain at least one activity");
}
_activity = _routingSlip.Itinerary[0];
_arguments = _routingSlip.GetActivityArguments <TArguments>();
_publisher = new RoutingSlipEventPublisher(this, _routingSlip);
}
public async Task Should_publish_OrderSubmitted_event()
{
// 이 테스트는 "어떤 메시지는 절대 오지 않아"를 테스트 하므로, Timeout 문제가 발생한다.
// 따라서, 테스트를 빨리 진행하기 위해, timeout 을 지정해 준다.
var harness = new InMemoryTestHarness()
{
TestTimeout = TimeSpan.FromSeconds(5)
};
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
// 메시지를 Publish 하고, Response가 필요없는 경우, 그냥 직접 InputQueue 에 메시지를 전송해볼 수 있다.
// --> 그러면, 정상적인 경우? 라면 등록된 Consumer 가 메시지를 수신하겠지?
await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new
{
OrderId = orderId,
Timestamp = InVar.Timestamp,
CustomerNumber = "12345",
});
// consumer가 메시지 수신하고...
Assert.That(consumer.Consumed.Select <SubmitOrder>().Any(), Is.True);
// OrderSubmitted 가 Publish 된다..를 테스트
Assert.That(harness.Published.Select <OrderSubmitted>().Any(), Is.True);
}
finally
{
await harness.Stop();
}
}
public async Task Should_publish_the_completed_event()
{
_completed = SubscribeHandler <RoutingSlipCompleted>();
_activityCompleted = SubscribeHandler <RoutingSlipActivityCompleted>();
_trackingNumber = NewId.NextGuid();
var builder = new RoutingSlipBuilder(_trackingNumber);
builder.AddSubscription(Bus.Address, RoutingSlipEvents.All);
ActivityTestContext testActivity = GetActivityContext <SetVariableActivity>();
builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new
{
Key = "Test",
Value = "Used",
});
builder.AddVariable("Value", "Ignored");
await Bus.Execute(builder.Build());
await _completed;
}
public void Apply(IBusBuilder builder)
{
var receiveEndpointBuilder = new HttpReceiveEndpointBuilder(_host, CreateConsumePipe(builder), builder);
var receivePipe = CreateReceivePipe(receiveEndpointBuilder);
_sendEndpointProvider = CreateSendEndpointProvider(receiveEndpointBuilder);
_publishEndpointProvider = CreatePublishEndpointProvider(receiveEndpointBuilder);
var sendPipe = builder.CreateSendPipe();
var receiveSettings = new Settings(_pathMatch, receiveEndpointBuilder.MessageSerializer, _sendEndpointProvider, _publishEndpointProvider);
var transport = new HttpReceiveTransport(_host, receiveSettings, sendPipe);
var httpHost = _host as HttpHost;
if (httpHost == null)
{
throw new ConfigurationException("Must be a HttpHost");
}
httpHost.ReceiveEndpoints.Add(NewId.Next().ToString(), new ReceiveEndpoint(transport, receivePipe));
}
public void Should_be_completely_thread_safe_to_avoid_duplicates()
{
NewId.Next();
Stopwatch timer = Stopwatch.StartNew();
int threadCount = 20;
var loopCount = 1024 * 1024;
int limit = loopCount * threadCount;
var ids = new NewId[limit];
ParallelEnumerable
.Range(0, limit)
.WithDegreeOfParallelism(8)
.WithExecutionMode(ParallelExecutionMode.ForceParallelism)
.ForAll(x => { ids[x] = NewId.Next(); });
timer.Stop();
Console.WriteLine("Generated {0} ids in {1}ms ({2}/ms)", limit, timer.ElapsedMilliseconds,
limit / timer.ElapsedMilliseconds);
Console.WriteLine("Distinct: {0}", ids.Distinct().Count());
var duplicates = ids.GroupBy(x => x).Where(x => x.Count() > 1).ToArray();
Console.WriteLine("Duplicates: {0}", duplicates.Count());
foreach (var newId in duplicates)
{
Console.WriteLine("{0} {1}", newId.Key, newId.Count());
}
}
public async Task Should_complete()
{
var orderId = NewId.NextGuid();
var orderLineId = NewId.NextGuid();
var startedAt = DateTime.UtcNow;
var scope = Provider.CreateScope();
var client = scope.ServiceProvider.GetRequiredService <IRequestClient <OrderFry> >();
Response <FryCompleted> response = await client.GetResponse <FryCompleted>(new
{
OrderId = orderId,
OrderLineId = orderLineId,
Size = Size.Medium
});
Assert.That(response.Message.OrderId, Is.EqualTo(orderId));
Assert.That(response.Message.OrderLineId, Is.EqualTo(orderLineId));
Assert.That(response.Message.Size, Is.EqualTo(Size.Medium));
Assert.That(response.Message.Created, Is.GreaterThan(startedAt));
Assert.That(response.Message.Completed, Is.GreaterThan(response.Message.Created));
}
public async Task Consume(ConsumeContext <FulfillOrder> context)
{
if (context.Message.CustomerNumber.StartsWith("INVALID"))
{
throw new InvalidOperationException("We tried, but the customer is invalid");
}
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity("AllocateInventory", new Uri("queue:allocate-inventory_execute"), new // AllocateInventory_execute
{
ItemNumber = "ITEM123",
Quantity = 10.0m
});
//builder.AddActivity("PaymentActivity", new Uri("queue:payment_execute"),
// new
// {
// CardNumber = context.Message.PaymentCardNumber ?? "5999-1234-5678-9012",
// Amount = 99.95m
// });
builder.AddVariable("OrderId", context.Message.OrderId);
//await builder.AddSubscription(context.SourceAddress,
// RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental,
// RoutingSlipEventContents.None, x => x.Send<OrderFulfillmentFaulted>(new { context.Message.OrderId }));
//await builder.AddSubscription(context.SourceAddress,
// RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental,
// RoutingSlipEventContents.None, x => x.Send<OrderFulfillmentCompleted>(new { context.Message.OrderId }));
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
public async Task An_observed_message_should_find_and_update_the_correct_saga()
{
Guid sagaId = NewId.NextGuid();
var message = new InitiateSimpleSaga(sagaId)
{
Name = "MySimpleSaga"
};
await InputQueueSendEndpoint.Send(message);
Guid?found = await _sagaRepository.Value.ShouldContainSaga(message.CorrelationId, TestTimeout);
found.ShouldBe(sagaId);
var nextMessage = new ObservableSagaMessage {
Name = "MySimpleSaga"
};
await InputQueueSendEndpoint.Send(nextMessage);
found = await _sagaRepository.Value.ShouldContainSaga(x => x.CorrelationId == sagaId && x.Observed, TestTimeout);
found.ShouldBe(sagaId);
}
public async Task Should_receive_one_batch_per_group()
{
var correlation1 = NewId.NextGuid();
var correlation2 = NewId.NextGuid();
await InputQueueSendEndpoint.Send(new PingMessage());
await InputQueueSendEndpoint.Send(new PingMessage(), Pipe.Execute <SendContext>(ctx => ctx.CorrelationId = correlation1));
await InputQueueSendEndpoint.Send(new PingMessage(), Pipe.Execute <SendContext>(ctx => ctx.CorrelationId = correlation1));
await InputQueueSendEndpoint.Send(new PingMessage(), Pipe.Execute <SendContext>(ctx => ctx.CorrelationId = correlation2));
await InputQueueSendEndpoint.Send(new PingMessage(), Pipe.Execute <SendContext>(ctx => ctx.CorrelationId = correlation2));
await InputQueueSendEndpoint.Send(new PingMessage(), Pipe.Execute <SendContext>(ctx => ctx.CorrelationId = correlation2));
await InactivityTask;
var count = await BusTestHarness.Consumed.SelectAsync <PingMessage>().Take(6).Count();
Assert.That(count, Is.EqualTo(6));
Assert.That(_batches.Select(x => x.Length), Is.EquivalentTo(new[] { 1, 2, 3 }));
}
internal static AuditDocument Create <T>(T message, string messageType, MessageAuditMetadata metadata)
where T : class
{
return(new AuditDocument
{
AuditId = NewId.NextGuid().ToString("N"),
ContextType = metadata.ContextType,
MessageId = metadata.MessageId.ToString(),
ConversationId = metadata.ConversationId.ToString(),
CorrelationId = metadata.CorrelationId.ToString(),
InitiatorId = metadata.InitiatorId.ToString(),
RequestId = metadata.RequestId.ToString(),
SentTime = metadata.SentTime,
SourceAddress = metadata.SourceAddress,
DestinationAddress = metadata.DestinationAddress,
ResponseAddress = metadata.ResponseAddress,
InputAddress = metadata.InputAddress,
FaultAddress = metadata.FaultAddress,
Message = JsonConvert.SerializeObject(message),
MessageType = messageType,
Headers = AuditHeaders.FromDictionary(metadata.Headers),
Custom = AuditHeaders.FromDictionary(metadata.Custom)
});
}
public void Should_support_the_same_constructor()
{
var guid = new Guid(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
var newid = new NewId(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
Assert.AreEqual(guid.ToString(), newid.ToString());
}
public void Should_format_just_like_a_narrow_guid_formatter()
{
var newId = new NewId();
Assert.AreEqual("00000000000000000000000000000000", newId.ToString("N"));
}
public void Should_format_just_like_a_parenthesis_guid_formatter()
{
var newId = new NewId();
Assert.AreEqual("(00000000-0000-0000-0000-000000000000)", newId.ToString("P"));
}
public void Should_format_just_like_a_default_guid_formatter()
{
var newId = new NewId();
Assert.AreEqual("00000000-0000-0000-0000-000000000000", newId.ToString());
}
public void Should_format_just_like_a_fancy_guid_formatter()
{
var newId = new NewId();
Assert.AreEqual("{00000000-0000-0000-0000-000000000000}", newId.ToString("B"));
}
public async Task Should_produce()
{
TaskCompletionSource <ConsumeContext <KafkaMessage> > taskCompletionSource = GetTask <ConsumeContext <KafkaMessage> >();
var services = new ServiceCollection();
services.AddSingleton(taskCompletionSource);
services.TryAddSingleton <ILoggerFactory>(LoggerFactory);
services.TryAddSingleton(typeof(ILogger <>), typeof(Logger <>));
services.AddMassTransit(x =>
{
x.UsingInMemory((context, cfg) => cfg.ConfigureEndpoints(context));
x.AddRider(rider =>
{
rider.AddConsumer <KafkaMessageConsumer>();
rider.AddProducer <KafkaMessage>(Topic);
rider.UsingKafka((context, k) =>
{
k.Host("localhost:9092");
k.TopicEndpoint <KafkaMessage>(Topic, nameof(Producer_Specs), c =>
{
c.AutoOffsetReset = AutoOffsetReset.Earliest;
c.ConfigureConsumer <KafkaMessageConsumer>(context);
});
});
});
});
var provider = services.BuildServiceProvider(true);
var busControl = provider.GetRequiredService <IBusControl>();
await busControl.StartAsync(TestCancellationToken);
var serviceScope = provider.CreateScope();
var producer = serviceScope.ServiceProvider.GetRequiredService <ITopicProducer <KafkaMessage> >();
try
{
var correlationId = NewId.NextGuid();
var conversationId = NewId.NextGuid();
var initiatorId = NewId.NextGuid();
var messageId = NewId.NextGuid();
await producer.Produce(new { Text = "text" }, Pipe.Execute <SendContext>(context =>
{
context.CorrelationId = correlationId;
context.MessageId = messageId;
context.InitiatorId = initiatorId;
context.ConversationId = conversationId;
context.Headers.Set("Special", new
{
Key = "Hello",
Value = "World"
});
}),
TestCancellationToken);
ConsumeContext <KafkaMessage> result = await taskCompletionSource.Task;
Assert.AreEqual("text", result.Message.Text);
Assert.That(result.SourceAddress, Is.EqualTo(new Uri("loopback://localhost/")));
Assert.That(result.DestinationAddress, Is.EqualTo(new Uri($"loopback://localhost/{KafkaTopicAddress.PathPrefix}/{Topic}")));
Assert.That(result.MessageId, Is.EqualTo(messageId));
Assert.That(result.CorrelationId, Is.EqualTo(correlationId));
Assert.That(result.InitiatorId, Is.EqualTo(initiatorId));
Assert.That(result.ConversationId, Is.EqualTo(conversationId));
var headerType = result.Headers.Get <HeaderType>("Special");
Assert.That(headerType, Is.Not.Null);
Assert.That(headerType.Key, Is.EqualTo("Hello"));
Assert.That(headerType.Value, Is.EqualTo("World"));
}
finally
{
serviceScope.Dispose();
await busControl.StopAsync(TestCancellationToken);
await provider.DisposeAsync();
}
}
public SnapshotResultImpl(FakeHareDuSnapshot1 snapshot)
{
Identifier = NewId.NextGuid().ToString();
Snapshot = snapshot;
Timestamp = DateTimeOffset.Now;
}
public void Should_properly_handle_string_passthrough()
{
NewId n = NewId.Next();
var ns = n.ToString("D");
var g = new Guid(ns);
var nn = new NewId(g.ToString("D"));
Assert.AreEqual(n, nn);
}
public void Should_translate_often_transposed_characters_to_proper_values()
{
var n = new NewId("F6B27C7C-8AB8-4498-AC97-3A6107A21320");
string ns = "6438A9RK2BNJTMRZ8J0OXE0UBY";
var parser = new ZBase32Parser(true);
NewId newId = parser.Parse(ns);
Assert.AreEqual(n, newId);
}
public async Task Should_load_the_data_from_the_repository()
{
Guid nextGuid = NewId.NextGuid();
string data = nextGuid.ToString();
Uri dataAddress;
using (var stream = new MemoryStream(nextGuid.ToByteArray(), false))
{
dataAddress = await _messageDataRepository.Put(stream);
}
var message = new MessageWithByteArrayImpl {Bytes = new ConstantMessageData<byte[]>(dataAddress, nextGuid.ToByteArray())};
await InputQueueSendEndpoint.Send(message);
ConsumeContext<MessageWithByteArray> received = await _received;
byte[] value = await received.Message.Bytes.Value;
var newId = new NewId(value);
newId.ToString().ShouldBe(data);
Console.WriteLine(value);
}
public async Task Consume(ConsumeContext <ParseFile> context)
{
var blob = await _blobStorage.GetFileAsync(context.Message.BlobId, context.Message.Bucket);
switch (blob.Info.FileName.ToLower())
{
case "13csample.jdx":
await context.Publish <FileParseFailed>(new
{
Id = context.Message.Id,
UserId = context.Message.UserId,
TimeStamp = DateTimeOffset.UtcNow,
CorrelationId = context.Message.CorrelationId,
Message = $"Cannot parse spectra file {blob.Info.FileName}."
});
break;
case "2-methyl-1-propanol.jdx":
var blobId = Guid.NewGuid();
await _blobStorage.AddFileAsync(blobId, $"{blobId}.jdx", blob.GetContentAsStream(), "chemical/x-jcamp-dx", context.Message.Bucket);
var fields = new Field[] {
new Field("Field1", "Value1"),
new Field("Field2", "Value2")
};
await context.Publish <RecordParsed>(new
{
Id = NewId.NextGuid(),
FileId = context.Message.Id,
Bucket = context.Message.Bucket,
BlobId = blobId,
Index = 0,
Fields = fields,
UserId = context.Message.UserId,
TimeStamp = DateTimeOffset.UtcNow,
CorrelationId = context.Message.CorrelationId
});
await context.Publish <FileParsed>(new
{
Id = context.Message.Id,
TotalRecords = 1,
Fields = fields.Select(f => f.Name),
UserId = context.Message.UserId,
TimeStamp = DateTimeOffset.UtcNow,
CorrelationId = context.Message.CorrelationId
});
break;
default:
await context.Publish <FileParseFailed>(new
{
Id = context.Message.Id,
UserId = context.Message.UserId,
TimeStamp = DateTimeOffset.UtcNow,
CorrelationId = context.Message.CorrelationId,
Message = $"Cannot parse spectra file {blob.Info.FileName}. Format is not supported."
});
break;
}
}
public TestStateMachine(RequestSettings settings)
{
Event(() => Register, x =>
{
x.CorrelateBy(p => p.MemberNumber, p => p.Message.MemberNumber);
x.SelectId(context => NewId.NextGuid());
});
Request(() => ValidateAddress, x => x.ValidateAddressRequestId, settings);
Request(() => ValidateName, x => x.ValidateNameRequestId, cfg =>
{
cfg.SchedulingServiceAddress = settings.SchedulingServiceAddress;
cfg.Timeout = settings.Timeout;
});
Initially(When(Register)
.Then(context =>
{
Console.WriteLine("Registration received: {0}", context.Data.MemberNumber);
Console.WriteLine("TestState ID: {0}", context.Instance.CorrelationId);
context.Instance.Name = context.Data.Name;
context.Instance.Address = context.Data.Address;
context.Instance.MemberNumber = context.Data.MemberNumber;
})
.Request(ValidateAddress, x => ValidateAddress.Settings.ServiceAddress, x => x.Init <ValidateAddress>(x.Instance))
.TransitionTo(ValidateAddress.Pending));
During(ValidateAddress.Pending,
When(ValidateAddress.Completed)
.ThenAsync(async context =>
{
await Console.Out.WriteLineAsync("Request Completed!");
context.Instance.Address = context.Data.Address;
})
.Request(ValidateName, context => context.Init <ValidateName>(context.Instance))
.TransitionTo(ValidateName.Pending),
When(ValidateAddress.Faulted)
.ThenAsync(async context => await Console.Out.WriteLineAsync("Request Faulted"))
.TransitionTo(AddressValidationFaulted),
When(ValidateAddress.TimeoutExpired)
.ThenAsync(async context => await Console.Out.WriteLineAsync("Request timed out"))
.TransitionTo(AddressValidationTimeout));
During(ValidateName.Pending,
When(ValidateName.Completed)
.ThenAsync(async context =>
{
await Console.Out.WriteLineAsync("Request Completed!");
context.Instance.Name = context.Data.Name;
})
.PublishAsync(context => context.Init <MemberRegistered>(context.Instance))
.TransitionTo(Registered),
When(ValidateName.Faulted)
.ThenAsync(async context => await Console.Out.WriteLineAsync("Request Faulted"))
.TransitionTo(NameValidationFaulted),
When(ValidateName.TimeoutExpired)
.ThenAsync(async context => await Console.Out.WriteLineAsync("Request timed out"))
.TransitionTo(NameValidationTimeout));
}
public async Task <ScheduledMessage <T> > ScheduleSend <T>(Uri destinationAddress, DateTime scheduledTime, Task <T> message, IPipe <SendContext <T> > pipe,
CancellationToken cancellationToken)
where T : class
{
var scheduleMessagePipe = new ActiveMqScheduleMessagePipe <T>(scheduledTime, pipe);
var payload = await message.ConfigureAwait(false);
var endpoint = await _sendEndpointProvider.GetSendEndpoint(destinationAddress).ConfigureAwait(false);
await endpoint.Send(payload, scheduleMessagePipe, cancellationToken).ConfigureAwait(false);
return(new ScheduledMessageHandle <T>(scheduleMessagePipe.ScheduledMessageId ?? NewId.NextGuid(), scheduledTime, destinationAddress, payload));
}
public async Task Setup()
{
_sagaId = NewId.NextGuid();
await InputQueueSendEndpoint.Send(new A { CorrelationId = _sagaId });
}
public void Should_be_completely_thread_safe_to_avoid_duplicates()
{
NewId.Next();
Stopwatch timer = Stopwatch.StartNew();
int threadCount = 20;
int workerThreads, complete;
ThreadPool.GetMinThreads(out workerThreads, out complete);
ThreadPool.SetMinThreads(workerThreads + threadCount, complete);
var loopCount = 1024 * 1024;
int limit = loopCount * threadCount;
var ids = new NewId[limit];
var tasks = new List <Task>();
var begin = new TaskCompletionSource <bool>();
for (int threadId = 0; threadId < threadCount; threadId++)
{
var start = threadId * loopCount;
var end = start + loopCount;
var task = Task.Factory.StartNew(() =>
{
//begin.Task.Wait();
for (int i = start; i < end; i++)
{
ids[i] = NewId.Next();
}
});
tasks.Add(task);
}
//begin.SetResult(true);
Task.WaitAll(tasks.ToArray());
timer.Stop();
Console.WriteLine("Generated {0} ids in {1}ms ({2}/ms)", limit, timer.ElapsedMilliseconds,
limit / timer.ElapsedMilliseconds);
Console.WriteLine("Distinct: {0}", ids.Distinct().Count());
var duplicates = ids.GroupBy(x => x).Where(x => x.Count() > 1).ToArray();
Console.WriteLine("Duplicates: {0}", duplicates.Count());
foreach (var newId in duplicates)
{
Console.WriteLine("{0} {1}", newId.Key, newId.Count());
}
}
public void Setup()
{
_jobId = NewId.NextGuid();
}
static string GenerateBusQueueName()
{
return(NewId.Next().ToString("NS"));
}
public ActiveMqEndpointAddress(Uri hostAddress, Uri address)
{
Scheme = default;
Host = default;
Port = default;
VirtualHost = default;
Durable = true;
AutoDelete = false;
Type = AddressType.Queue;
var scheme = address.Scheme.ToLowerInvariant();
if (scheme.EndsWith("s"))
Port = 5671;
switch (scheme)
{
case ActiveMqHostAddress.ActiveMqScheme:
Scheme = address.Scheme;
Host = address.Host;
Port = address.IsDefaultPort
? 61616
: address.Port;
address.ParseHostPathAndEntityName(out VirtualHost, out Name);
break;
case "queue":
ParseLeft(hostAddress, out Scheme, out Host, out Port, out VirtualHost);
Name = address.AbsolutePath;
break;
case "topic":
ParseLeft(hostAddress, out Scheme, out Host, out Port, out VirtualHost);
Name = address.AbsolutePath;
Type = AddressType.Topic;
break;
default:
throw new ArgumentException($"The address scheme is not supported: {address.Scheme}", nameof(address));
}
if (Name == "*")
Name = NewId.Next().ToString("NS");
ActiveMqEntityNameValidator.Validator.ThrowIfInvalidEntityName(Name);
foreach ((string key, string value) in address.SplitQueryString())
{
switch (key)
{
case TemporaryKey when bool.TryParse(value, out bool result):
AutoDelete = result;
Durable = !result;
break;
case DurableKey when bool.TryParse(value, out bool result):
Durable = result;
break;
case AutoDeleteKey when bool.TryParse(value, out bool result):
AutoDelete = result;
break;
case TypeKey when _parseConverter.TryConvert(value, out AddressType result):
Type = result;
break;
}
}
}
public async Task Consume(ConsumeContext <ProcessBatchJob> context)
{
using (_log.BeginScope("ProcessBatchJob {BatchJobId}, {OrderId}", context.Message.BatchJobId, context.Message.OrderId))
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
switch (context.Message.Action)
{
case BatchAction.CancelOrders:
builder.AddActivity(
"CancelOrder",
new Uri("queue:cancel-order_execute"),
new
{
context.Message.OrderId,
Reason = "Product discontinued"
});
await builder.AddSubscription(
context.SourceAddress,
RoutingSlipEvents.ActivityFaulted,
RoutingSlipEventContents.None,
"CancelOrder",
x => x.Send <BatchJobFailed>(new
{
context.Message.BatchJobId,
context.Message.BatchId,
context.Message.OrderId
}));
break;
case BatchAction.SuspendOrders:
builder.AddActivity(
"SuspendOrder",
new Uri("queue:suspend-order_execute"),
new { context.Message.OrderId });
await builder.AddSubscription(
context.SourceAddress,
RoutingSlipEvents.ActivityFaulted,
RoutingSlipEventContents.None,
"SuspendOrder",
x => x.Send <BatchJobFailed>(new
{
context.Message.BatchJobId,
context.Message.BatchId,
context.Message.OrderId
}));
break;
}
await builder.AddSubscription(
context.SourceAddress,
RoutingSlipEvents.Completed,
x => x.Send <BatchJobCompleted>(new
{
context.Message.BatchJobId,
context.Message.BatchId
}));
await context.Execute(builder.Build());
}
}
public InMemoryMessageDataId()
{
_id = NewId.Next();
}
