public InvokeHandlerContext(MessageHandler handler, string messageId, string replyToAddress, Dictionary<string, string> headers, MessageMetadata messageMetadata, object messageBeingHandled, SynchronizedStorageSession storageSession, IBehaviorContext parentContext)
: base(messageId, replyToAddress, headers, parentContext)
{
MessageHandler = handler;
Headers = headers;
MessageBeingHandled = messageBeingHandled;
MessageMetadata = messageMetadata;
Set(storageSession);
}
public void Outgoing_databus_properties_should_be_dehydrated()
{
var metadata = new MessageMetadata();
var message = new LogicalMessage(metadata, new MessageWithDataBusProperty
{
DataBusProperty = new DataBusProperty<string>("test")
}, new Dictionary<string, string>(), null);
Invoke(message);
dataBus.AssertWasCalled(
x => x.Put(Arg<Stream>.Is.Anything, Arg<TimeSpan>.Is.Equal(TimeSpan.MaxValue)));
}
public void Time_to_live_should_be_passed_on_the_databus()
{
var metadata = new MessageMetadata(timeToBeReceived: TimeSpan.FromMinutes(1));
var message = new LogicalMessage(metadata, new MessageWithExplicitTimeToLive
{
DataBusProperty = new DataBusProperty<string>("test")
}, new Dictionary<string, string>(), null);
Invoke(message);
dataBus.AssertWasCalled(
x => x.Put(Arg<Stream>.Is.Anything, Arg<TimeSpan>.Is.Equal(TimeSpan.FromMinutes(1))));
}
public void Should_not_blow_up()
{
var metadata = new MessageMetadata(timeToBeReceived: TimeSpan.FromDays(1));
var message = new LogicalMessage(metadata, new MessageWithNullDataBusProperty(), new Dictionary<string, string>(), null);
var context = new OutgoingContext(null,new SendOptions(Address.Parse("MyEndpoint")), message);
using (var stream = new MemoryStream())
{
new BinaryFormatter().Serialize(stream, "test");
stream.Position = 0;
sendBehavior.Invoke(context, () => { });
}
}
public virtual void TestSetPropertiesKey()
{
var builder = new MessageMetadata();
builder.Properties.Add(new KeyValue {
Key = "key1", Value = "value1"
});
builder.Properties.Add(new KeyValue {
Key = "key2", Value = "value2"
});
builder.Properties.Add(new KeyValue {
Key = "key3", Value = "value3"
});
var payload = ReadOnlySequence <byte> .Empty;
var msg = Message <byte[]> .Create(builder, payload, ISchema <object> .Bytes);
Assert.Equal("value1", msg.GetProperty("key1"));
Assert.Equal("value3", msg.GetProperty("key3"));
}
internal MessageMetadata CreateMetadata(IBasicProperties properties, string topic, ISerializer serializer, ulong?deliveryTag = null)
{
MessageMetadata metadata = new MessageMetadata
{
ReplyTo = properties.ReplyTo,
MessageId = properties.CorrelationId,
Destination =
properties.IsHeadersPresent() &&
properties.Headers.ContainsKey(MessageMetadata.ResponseDestinationHeaderKey)
? serializer.ByteArrayToObject <string>(properties.Headers[MessageMetadata.ResponseDestinationHeaderKey] as byte[])
: null,
Topic = topic
};
if (deliveryTag != null)
{
metadata.DeliveryTag = deliveryTag.Value;
}
return(metadata);
}
public void SendMessage(byte[] body, IMessage message, MessageMetadata metadata)
{
if (!IsConnected)
{
return;
}
using (IModel channel = RabbitMqConnection.CreateChannel(this))
{
IBasicProperties basicProperties = RabbitMqConnection.CreateBasicProperties(channel, message, metadata);
string routingKey = string.IsNullOrEmpty(metadata.ReplyTo)
? string.IsNullOrEmpty(metadata.Topic) ? message.GetType().Name : metadata.Topic
: metadata.ReplyTo;
Logger.LogInformation($"Send message to {metadata.Destination} of type {message.GetType().Name} with routing key: {routingKey}");
RabbitMqConnection.PublishMessage(channel, metadata.Destination, basicProperties, body, routingKey);
}
}
private bool IsHaveResult(Subscription subscription, MessageMetadata message)
{
//search by query in service
var query = subscription.Query;// + "&informationResourceId=" + message.Id;
Log.Verbose($"Query for search: {query}");
try
{
var checkResult = _checkSubscriptionService.Check(message, query);
Log.Verbose($"Check result: {checkResult}");
return(checkResult);
}
catch (Exception e)
{
Log.Warning($"problem occured when check subscription id {subscription.SubscriptionId}", e);
return(false);
}
}
public byte[] Serialize(float data, bool isKey, MessageMetadata messageMetadata, TopicPartition destination)
{
if (BitConverter.IsLittleEndian)
{
unsafe
{
byte[] result = new byte[4];
byte * p = (byte *)(&data);
result[3] = *p++;
result[2] = *p++;
result[1] = *p++;
result[0] = *p++;
return(result);
}
}
else
{
return(BitConverter.GetBytes(data));
}
}
public async Task ProvidesDefaultSerializationComponents()
{
var serializer = new AsyncSchemaRegistrySerializer <int>(
RegistryClientMock.Object
);
var data = 4;
var encoding = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x04, 0x08 };
var metadata = new MessageMetadata();
var context = new SerializationContext(MessageComponentType.Key, "test_topic");
var subject = $"{context.Topic}-key";
RegistryClientMock
.Setup(c => c.GetLatestSchemaAsync(subject))
.ReturnsAsync(new Schema(subject, 1, 4, "\"int\""));
Assert.Equal(encoding,
await serializer.SerializeAsync(data, context)
);
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("MNMessagesSyncDeltaParticipantsAddedToGroupThread");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (MessageMetadata != null && __isset.MessageMetadata)
{
field.Name = "MessageMetadata";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
MessageMetadata.Write(oprot);
oprot.WriteFieldEnd();
}
if (AddedParticipants != null && __isset.AddedParticipants)
{
field.Name = "AddedParticipants";
field.Type = TType.List;
field.ID = 2;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, AddedParticipants.Count));
foreach (MNMessagesSyncParticipantInfo _iter66 in AddedParticipants)
{
_iter66.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
List <LogicalMessage> Extract(IncomingMessage physicalMessage)
{
if (physicalMessage.Body == null || physicalMessage.Body.Length == 0)
{
return(new List <LogicalMessage>());
}
string messageTypeIdentifier;
var messageMetadata = new List <MessageMetadata>();
if (physicalMessage.Headers.TryGetValue(Headers.EnclosedMessageTypes, out messageTypeIdentifier))
{
foreach (var messageTypeString in messageTypeIdentifier.Split(';'))
{
var typeString = messageTypeString;
MessageMetadata metadata = messageMetadataRegistry.GetMessageMetadata(typeString);
if (metadata == null)
{
continue;
}
messageMetadata.Add(metadata);
}
if (messageMetadata.Count == 0 && physicalMessage.GetMesssageIntent() != MessageIntentEnum.Publish)
{
logger.WarnFormat("Could not determine message type from message header '{0}'. MessageId: {1}", messageTypeIdentifier, physicalMessage.MessageId);
}
}
using (var stream = new MemoryStream(physicalMessage.Body))
{
IMessageSerializer messageSerializer = serializationMapper.GetSerializer(physicalMessage.Headers);
var messageTypes = messageMetadata.Select(metadata => metadata.MessageType).ToList();
return(messageSerializer.Deserialize(stream, messageTypes)
.Select(x => logicalMessageFactory.Create(x.GetType(), x))
.ToList());
}
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("MNMessagesSyncDeltaSentMessage");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (MessageMetadata != null && __isset.MessageMetadata)
{
field.Name = "MessageMetadata";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
MessageMetadata.Write(oprot);
oprot.WriteFieldEnd();
}
if (Attachments != null && __isset.Attachments)
{
field.Name = "Attachments";
field.Type = TType.List;
field.ID = 2;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, Attachments.Count));
foreach (MNMessagesSyncAttachment _iter102 in Attachments)
{
_iter102.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public async Task CachesGeneratedSerializers()
{
var serializer = new AsyncSchemaRegistrySerializer <object>(
RegistryClientMock.Object
);
var metadata = new MessageMetadata();
var context = new SerializationContext(MessageComponentType.Value, "test_topic");
var subject = $"{context.Topic}-value";
RegistryClientMock
.Setup(c => c.GetLatestSchemaAsync(subject))
.ReturnsAsync(new Schema(subject, 1, 12, "\"null\""));
await Task.WhenAll(Enumerable.Range(0, 5).Select(i =>
serializer.SerializeAsync(null, context)
));
RegistryClientMock
.Verify(c => c.GetLatestSchemaAsync(subject), Times.Once());
}
public async Task SendAsync_ShouldHaveDefaultMetadata_WhenMessageMetadataIsNull(
MessageWithMetadata message, string serialized, string typeId, MessageMetadata metadata)
{
message.Metadata = null;
_messageSerializer.Setup(x => x.Serialize(message.Message))
.Returns(serialized);
_messageTypeCache.Setup(x => x.GetTypeId(message.Message.GetType()))
.Returns(typeId);
_metadataFactory.Setup(x => x.CreateFor(message.Message))
.Returns(metadata);
await _sut.SendAsync(message, Cts.Token);
_connection.Verify(x => x.SendAsync(It.Is <MessageData>(msg =>
msg.Data == serialized &&
msg.TypeId == typeId &&
msg.Metadata == metadata), Cts.Token));
}
public async Task ReadFramesAsync_ShouldBreak_OnReaderCompletedAtLast(short messageId, params int[] framesLength)
{
var random = new Random();
var(decoder, pipe) = CreateConsumer();
var enumerator = decoder.ReadFramesAsync().GetAsyncEnumerator();
foreach (var len in framesLength)
{
var meta = new MessageMetadata(messageId, len);
var encoded = FrameProvider.GetRandomAsBuffer(messageId, len, random);
await pipe.Writer.WriteAsync(encoded).ConfigureAwait(false);
Assert.True(await enumerator.MoveNextAsync());
Assert.Equal(meta, enumerator.Current.Metadata);
Assert.Equal(encoded.Slice(_parser.GetLength(meta)).ToArray(),
enumerator.Current.Payload.ToArray());
}
pipe.Reader.Complete();
Assert.False(await enumerator.MoveNextAsync()); // will break since tryAdvance returns false whenever the pipe is completed (by throwing an InvalidOperationException)
}
/// <summary>
/// Serialize an instance of type <typeparamref name="T"/> to a byte array in Avro format. The serialized
/// data is preceeded by a "magic byte" (1 byte) and the id of the schema as registered
/// in Confluent's Schema Registry (4 bytes, network byte order). This call may block or throw
/// on first use for a particular topic during schema registration.
/// </summary>
/// <param name="value">
/// The value to serialize.
/// </param>
/// <param name="messageMetadata">
/// Properties of the message the data is associated with in
/// addition to the key or value.
/// </param>
/// <param name="destination">
/// The TopicPartition to which the message is to be sent
/// (partition may be Partition.Any).
/// </param>
/// <param name="isKey">
/// True if deserializing the message key, false if deserializing the
/// message value.
/// <returns>
/// A <see cref="System.Threading.Tasks.Task" /> that completes with
/// <paramref name="value" /> serialized as a byte array.
/// </returns>
public async Task <byte[]> SerializeAsync(T value, bool isKey, MessageMetadata messageMetadata, TopicPartition destination)
{
try
{
if (serializerImpl == null)
{
serializerImpl = typeof(T) == typeof(GenericRecord)
? (IAvroSerializerImpl <T>) new GenericSerializerImpl(schemaRegistryClient, autoRegisterSchema, initialBufferSize)
: new SpecificSerializerImpl <T>(schemaRegistryClient, autoRegisterSchema, initialBufferSize);
}
return(await serializerImpl.Serialize(destination.Topic, value, isKey));
}
catch (AggregateException e)
{
throw new SerializationException("Error occured serializing Avro data.", e.InnerException);
}
catch (Exception e)
{
throw new SerializationException("Error occured serializing Avro data.", e);
}
}
public void Aggregate_actor_produce_fault_with_processId_from_command()
{
var command = new GoSleepCommand(null, null).CloneForProcess(Guid.NewGuid().ToString());
var transport = Sys.InitLocalTransportExtension().Transport;
transport.Subscribe <MessageMetadataEnvelop <Fault <GoSleepCommand> > >(TestActor);
var handlersActor = Sys.ActorOf(Props.Create(() => new HandlersPipeActor(new HandlersDefaultProcessor(), TestActor)));
var actor = Sys.ActorOf(Props.Create(() => new AggregateActor <ProgrammerAggregate>(CommandAggregateHandler.New <ProgrammerAggregate>(null),
new SnapshotsPersistencePolicy(1, null, 5, null),
AggregateFactory.Default,
AggregateFactory.Default,
handlersActor)),
EntityActorName.New <ProgrammerAggregate>(command.Id).Name);
actor.Tell(new MessageMetadataEnvelop <ICommand>(command, MessageMetadata.New(command.Id, null, null)));
var fault = FishForMessage <MessageMetadataEnvelop>(m => m.Message is Fault <GoSleepCommand>).Message as IFault;
Assert.Equal(command.ProcessId, fault.ProcessId);
}
public async Task <ActionResult> PublishMessage([FromBody] SendMessageRequest request)
{
if (request.MessageContent.SimulateHeartBeat.HasValue && request.MessageContent.SetVisiblityTimeout < TimeSpan.FromSeconds(5))
{
return(BadRequest("If you want to simulate a heartbeat, you need to provide a value greater than 5 for setvisibilitytimeout as the heartbeat simulation sleeps for 5s"));
}
// The account ID should be present in the Identity Token
var account = User.GetAccountId();
var interactionGuid = request.InteractionGuid?.ToString() ?? string.Empty;
// The correlation id should be present in the HttpContent. We add one in, if missing.
var correlationId = Request.Headers.GetCorrelationId();
// Here we're demonstrating new'ing up a message n times and publishing each one
// as a load/perf test for SDK + AWS
for (var i = 0; i < request.NumberOfTimesToSend; i++)
{
// Build up a new message (metadata + content)
var debugData = new DebugData(Program.ServiceName, BuildInfo.Version)
{
// These 2 are optional, nor required. Although schema version at least is desired.
// Model/object/class version
MessageSchemaVersion = request.SchemaVersion,
// Any additional pertinent info you want to provide
AdditionalInfo = request.AdditionalDebugInfo
};
var metadata = new MessageMetadata(correlationId, debugData)
{
AccountId = (long)account,
InteractionGuid = interactionGuid
};
var newMessage = new Message(request.MessageContent, metadata);
await _messagePublisher.PublishAsync(newMessage);
}
return(Ok());
}
public override string ToString()
{
StringBuilder __sb = new StringBuilder("MNMessagesSyncDeltaP2PPaymentMessage(");
bool __first = true;
if (MessageMetadata != null && __isset.MessageMetadata)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("MessageMetadata: ");
__sb.Append(MessageMetadata == null ? "<null>" : MessageMetadata.ToString());
}
if (__isset.TransferId)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("TransferId: ");
__sb.Append(TransferId);
}
if (__isset.MessageType)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("MessageType: ");
__sb.Append(MessageType);
}
__sb.Append(")");
return(__sb.ToString());
}
public override string ToString()
{
StringBuilder __sb = new StringBuilder("MNMessagesSyncDeltaAdminTextMessage(");
bool __first = true;
if (MessageMetadata != null && __isset.MessageMetadata)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("MessageMetadata: ");
__sb.Append(MessageMetadata == null ? "<null>" : MessageMetadata.ToString());
}
if (Type != null && __isset.Type)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("Type: ");
__sb.Append(Type);
}
if (UntypedData != null && __isset.UntypedData)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("UntypedData: ");
__sb.Append(UntypedData);
}
__sb.Append(")");
return(__sb.ToString());
}
public override string ToString()
{
StringBuilder __sb = new StringBuilder("MNMessagesSyncDeltaPageAdminReply(");
bool __first = true;
if (MessageMetadata != null && __isset.MessageMetadata)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("MessageMetadata: ");
__sb.Append(MessageMetadata == null ? "<null>" : MessageMetadata.ToString());
}
if (ActivityToken != null && __isset.ActivityToken)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("ActivityToken: ");
__sb.Append(ActivityToken);
}
if (__isset.ReplyType)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("ReplyType: ");
__sb.Append(ReplyType);
}
__sb.Append(")");
return(__sb.ToString());
}
public Message Add(MessageIdData messageId, MessageMetadata metadata, ReadOnlySequence <byte> data)
{
if (_trackBatches)
{
_batches.AddLast(new Batch(messageId, metadata.NumMessagesInBatch));
}
long index = 0;
for (var i = 0; i < metadata.NumMessagesInBatch; ++i)
{
var singleMetadataSize = data.ReadUInt32(index, true);
index += 4;
var singleMetadata = Serializer.Deserialize <SingleMessageMetadata>(data.Slice(index, singleMetadataSize));
index += singleMetadataSize;
var singleMessageId = new MessageId(messageId.LedgerId, messageId.EntryId, messageId.Partition, i);
var message = new Message(singleMessageId, metadata, singleMetadata, data.Slice(index, singleMetadata.PayloadSize));
_messages.Enqueue(message);
index += (uint)singleMetadata.PayloadSize;
}
return(_messages.Dequeue());
}
public async ValueTask <MessageId> Send(MessageMetadata metadata, ReadOnlySequence <byte> data, CancellationToken cancellationToken)
{
ThrowIfDisposed();
var autoAssignSequenceId = metadata.SequenceId == 0;
if (autoAssignSequenceId)
{
metadata.SequenceId = _sequenceId.FetchNext();
}
try
{
return(await _executor.Execute(() => Send(metadata.Metadata, data, cancellationToken), cancellationToken).ConfigureAwait(false));
}
finally
{
if (autoAssignSequenceId)
{
metadata.SequenceId = 0;
}
}
}
public static Activity?StartProducerActivity(MessageMetadata metadata, string operationName, KeyValuePair <string, object?>[] tags)
{
if (!ActivitySource.HasListeners())
{
return(null);
}
var activity = ActivitySource.StartActivity(operationName, ActivityKind.Producer);
if (activity is not null && activity.IsAllDataRequested)
{
metadata[_traceParent] = activity.TraceId.ToHexString();
metadata[_traceState] = activity.TraceStateString;
for (var i = 0; i < tags.Length; ++i)
{
var tag = tags[i];
activity.SetTag(tag.Key, tag.Value);
}
}
return(activity);
}
public async Task UsesSubjectNameBuilder()
{
var version = GetType().Assembly.GetName().Version;
var serializer = new AsyncSchemaRegistrySerializer <int>(
RegistryClientMock.Object,
subjectNameBuilder: c => $"{c.Topic}-{version}-{c.Component.ToString().ToLowerInvariant()}"
);
var data = 2;
var encoding = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x08, 0x04 };
var metadata = new MessageMetadata();
var context = new SerializationContext(MessageComponentType.Key, "test_topic");
var subject = $"{context.Topic}-{version}-key";
RegistryClientMock
.Setup(c => c.GetLatestSchemaAsync(subject))
.ReturnsAsync(new Schema(subject, 2, 8, "\"int\""));
Assert.Equal(encoding,
await serializer.SerializeAsync(data, context)
);
}
public async Task When_execute_aggregate_command_with_fault_and_metadata()
{
var command = new BlowBalloonCommand(Guid.NewGuid().ToString());
var commandMetadata = MessageMetadata.New(command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(command, commandMetadata)
.Expect <Fault <BlowBalloonCommand> >()
.Execute(false);
// Result_contains_metadata()
var metadata = res.ReceivedMetadata;
Assert.NotNull(metadata);
// Result_contains_message()
var fault = res.Fault;
Assert.NotNull(fault);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <IFault <BlowBalloonCommand> >(fault);
//Result_message_has_expected_id()
Assert.Equal(command.Id, ((IFault <BlowBalloonCommand>)fault).Message.Id);
//Result_message_has_expected_value()
Assert.Equal(command.GetType(), fault.Message.GetType());
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal(command.Id, metadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(commandMetadata.CorrelationId, metadata.CorrelationId);
//Result_metadata_has_processed_history_filled_from_aggregate()
//Assert.Equal(1, metadata.History?.Steps.Count);
////Result_metadata_has_processed_correct_filled_history_step()
//var step = metadata.History.Steps.First();
//
//Assert.Equal(AggregateActorName.New<Balloon>(command.AggregateId).Name, step.Who);
//Assert.Equal(AggregateActorConstants.CommandRaisedAnError, step.Why);
//Assert.Equal(AggregateActorConstants.CommandExecutionFinished, step.What);
}
protected override void OnReceive(object message)
{
try
{
var messageWithMetadata = message as IMessageMetadataEnvelop;
if (messageWithMetadata != null)
{
_group.Project(messageWithMetadata.Message, messageWithMetadata.Metadata);
}
else
{
_group.Project(message, MessageMetadata.Empty());
}
}
catch (MessageProcessException ex)
{
_log.Error(ex, "Handler actor raised an error on message process: {@Message}", message);
var withMetadata = message as IMessageMetadataEnvelop;
if (withMetadata == null)
{
var fault = Fault.NewGeneric(message, ex.InnerException, ex.Type, GetSagaId(message));
_publisher.Publish(fault);
}
else
{
var fault = Fault.NewGeneric(withMetadata.Message, ex.InnerException, ex.Type, GetSagaId(message));
var metadata = withMetadata.Metadata.CreateChild(Guid.Empty,
new ProcessEntry(Self.Path.Name,
"publishing fault",
"message process casued an error"));
_publisher.Publish(fault, metadata);
}
}
}
public void When_child_revives_monitor_should_be_created_even_on_collision()
{
var ChildId = "testChild";
var create = new MessageMetadataEnvelop <ICommand>(new InflateNewBallonCommand(42, ChildId),
MessageMetadata.New(ChildId, null, null));
_hubRef.Tell(create);
Task.Run(async() =>
{
while (true)
{
var activate = new MessageMetadataEnvelop <ICommand>(new WriteTitleCommand(100, ChildId),
MessageMetadata.New(ChildId, null, null));
_hubRef.Tell(activate);
await Task.Delay(150);
}
});
EventFilter.Exception <InvalidActorNameException>()
.Expect(0, TimeSpan.FromSeconds(10), () => { });
}
public async Task Given_default_policy()
{
var startEvent = new GotTiredEvent(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var resTask = Node.NewDebugWaiter()
.Expect <ProcessReceivedMessage <SoftwareProgrammingState> >()
.Create()
.SendToProcessManagers(startEvent, MessageMetadata.New(startEvent.Id, null, null));
var processId = (await resTask).Message <ProcessReceivedMessage <SoftwareProgrammingState> >().SourceId;
var continueEvent = new CoffeMakeFailedEvent(processId, startEvent.PersonId, BusinessDateTime.UtcNow, processId);
//to avoid racy state receiving expected message from processing GotTiredEvent
await Node.NewDebugWaiter()
.Expect <ProcessReceivedMessage <SoftwareProgrammingState> >(e => e.MessageId == continueEvent.Id)
.Create()
.SendToProcessManagers(continueEvent, processId);
Log.Info("Testcase enforce additional snapshot save & delete, will kill process manager");
await Node.KillProcessManager <SoftwareProgrammingProcess, SoftwareProgrammingState>(processId);
var snapshots = await AggregateSnapshotRepository.New(AutoTestNodeDbConfiguration.Default.JournalConnectionString,
AggregateFactory.Default)
.Load <ProcessStateAggregate <SoftwareProgrammingState> >(processId);
//Snapshot_should_be_saved_one_time
Assert.Single(snapshots);
//Restored_process_state_should_have_correct_ids
Assert.True(snapshots.All(s => s.Payload.Id == processId));
//Snapshot_should_have_parameters_from_first_event = created event
Assert.Equal(nameof(SoftwareProgrammingProcess.Coding),
snapshots.First().Payload.State.CurrentStateName);
//All_snapshots_should_not_have_uncommited_events
Assert.Empty(snapshots.SelectMany(s => s.Payload.GetEvents()));
}
public void UserColorChangedRaisedTest()
{
var userMock = new Mock <IUser>();
userMock.Setup(u => u.BackColorArgb).Returns("#FFFF0000");
userMock.Setup(u => u.ForeColorArgb).Returns("#FF0000FF");
var messageMock = new Mock <ITwicasComment>();
var optionsMock = new Mock <ICommentOptions>();
var siteOptionsMock = new Mock <ITwicasSiteOptions>();
var message = messageMock.Object;
var options = optionsMock.Object;
var siteOptions = siteOptionsMock.Object;
var user = userMock.Object;
var metadata = new MessageMetadata(message, options, siteOptions, user, null, false);
var backColorRaised = false;
var foreColorRaised = false;
metadata.PropertyChanged += (s, e) =>
{
switch (e.PropertyName)
{
case nameof(metadata.BackColor):
backColorRaised = true;
break;
case nameof(metadata.ForeColor):
foreColorRaised = true;
break;
}
};
userMock.Raise(c => c.PropertyChanged += null, new PropertyChangedEventArgs(nameof(user.BackColorArgb)));
userMock.Raise(c => c.PropertyChanged += null, new PropertyChangedEventArgs(nameof(user.ForeColorArgb)));
Assert.IsTrue(backColorRaised);
Assert.IsTrue(foreColorRaised);
}
public async Task DoesNotCacheSchemaRegistryFailures()
{
var serializer = new AsyncSchemaRegistrySerializer <object>(
RegistryClientMock.Object
);
var metadata = new MessageMetadata();
var context = new SerializationContext(MessageComponentType.Value, "test_topic");
var subject = $"{context.Topic}-value";
RegistryClientMock
.Setup(c => c.GetLatestSchemaAsync(subject))
.ThrowsAsync(new HttpRequestException());
await Assert.ThrowsAsync <HttpRequestException>(() =>
serializer.SerializeAsync(null, context)
);
RegistryClientMock
.Setup(c => c.GetLatestSchemaAsync(subject))
.ReturnsAsync(new Schema(subject, 1, 12, "\"null\""));
await serializer.SerializeAsync(null, context);
}
/// <summary>
/// Create a new <see cref="LogicalMessage"/> instance containing a message object and it's corresponding <see cref="MessageMetadata"/>.
/// </summary>
public LogicalMessage(MessageMetadata metadata, object message)
{
Instance = message;
Metadata = metadata;
}
internal Message(string topic, MessageId messageId, MessageMetadata msgMetadata, ReadOnlySequence<byte> payload, Option<EncryptionContext> encryptionCtx, IActorRef cnx, ISchema<T> schema, int redeliveryCount, bool pooledMessage)
{
//_metadata = new MessageMetadata();
Init(this, topic, messageId, msgMetadata, payload, encryptionCtx, cnx, schema, redeliveryCount, pooledMessage);
}
internal Message(string topic, MessageId messageId, MessageMetadata msgMetadata, ReadOnlySequence<byte> payload, Option<EncryptionContext> encryptionCtx, IActorRef cnx, ISchema<T> schema) : this(topic, messageId, msgMetadata, payload, encryptionCtx, cnx, schema, 0, false)
{
}
public void Add(MessageMetadata metadata)
{
}
