public void MessageBodyIsTracked()
{
var message = new MessageMock();
message.Setup(m => m.GetProperty(BtsProperties.InboundTransportLocation)).Returns("inbound-transport-location");
var eventStream = new Mock <EventStream>();
var pipelineContext = new Mock <IPipelineContext> {
DefaultValue = DefaultValue.Mock
};
pipelineContext
.Setup(pc => pc.GetEventStream())
.Returns(eventStream.Object);
var sut = new MessagingStep(pipelineContext.Object, message.Object);
using (var trackingStream = new TrackingStream(new MemoryStream(_content), new MessageBodyCaptureDescriptor("data", MessageBodyCaptureMode.Claimed)))
{
// TrackActivity is supposed to occur at stream's end
trackingStream.Drain();
sut.TrackActivity(ActivityTrackingModes.Body, trackingStream);
}
eventStream.Verify(
es => es.AddReference(
nameof(MessagingStep),
sut.ActivityId,
MessageBodyCaptureMode.Claimed.ToString(),
MessagingStep.MESSAGE_BODY_REFERENCE_NAME,
It.IsAny <string>(),
It.IsAny <string>()),
Times.Once());
}
public override void AddStep(MessagingStep messagingStep)
{
// A ProcessReference denotes an ongoing *non* messaging-only process; whereas a MessagingStepReference denotes
// the initiating message of a messaging-only flow...
if (messagingStep is MessagingStepReference)
{
throw new NotSupportedException();
}
base.AddStep(messagingStep);
}
public void InboundSuccessfulPropertiesForSolicitResponsePortAreTracked()
{
var message = new MessageMock();
SetupCommonProperties(message);
// no ReceiveLocationName on the inbound of a solicit-response port but a ReceivePortName
message.Setup(m => m.GetProperty(BtsProperties.ReceivePortName)).Returns("receive-port-name");
message.Setup(m => m.GetProperty(BtsProperties.InboundTransportLocation)).Returns("inbound-transport-location");
message.Setup(m => m.GetProperty(BtsProperties.InboundTransportType)).Returns("inbound-transport-type");
var activityId = string.Empty;
Dictionary <string, object> data = null;
var eventStream = new Mock <EventStream>();
eventStream
.Setup(es => es.UpdateActivity(nameof(MessagingStep), It.Is <string>(id => id == activityId), It.IsAny <object[]>()))
.Callback <string, string, object[]>((n, id, d) => data = ToDictionary(d))
.Verifiable();
var pipelineContext = new Mock <IPipelineContext> {
DefaultValue = DefaultValue.Mock
};
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var sut = new MessagingStep(pipelineContext.Object, message.Object);
activityId = sut.ActivityId;
using (var trackingStream = new TrackingStream(new MemoryStream(_content)))
{
// TrackActivity is supposed to occur at stream's end
trackingStream.Drain();
sut.TrackActivity(ActivityTrackingModes.Step, trackingStream);
}
eventStream.Verify();
var expectedData = new Dictionary <string, object> {
{ nameof(MessagingStep.MessageID), _messageId.AsNormalizedActivityId() },
{ nameof(MessagingStep.MessageType), "message-type" },
{ nameof(MessagingStep.PortName), "receive-port-name" },
{ nameof(MessagingStep.TransportLocation), "inbound-transport-location" },
{ nameof(MessagingStep.TransportType), "inbound-transport-type" },
{ nameof(MessagingStep.Status), TrackingStatus.Received },
{ nameof(MessagingStep.MachineName), Environment.MachineName },
{ nameof(MessagingStep.Time), sut.Time }
}
.Union(ExpectedCommonData, new LambdaComparer <KeyValuePair <string, object> >((kvp1, kvp2) => kvp1.Key == kvp2.Key))
.OrderBy(kvp => kvp.Key).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
data.Should().BeEquivalentTo(expectedData);
}
public void OutboundSuccessfulPropertiesAreTrackedAtStreamExhaustion()
{
var message = new MessageMock();
SetupCommonProperties(message);
SetupInboundSuccessfulProperties(message);
SetupOutboundSuccessfulProperties(message);
var activityId = string.Empty;
Dictionary <string, object> data = null;
var eventStream = new Mock <EventStream>();
eventStream
.Setup(es => es.UpdateActivity(nameof(MessagingStep), It.Is <string>(id => id == activityId), It.IsAny <object[]>()))
.Callback <string, string, object[]>((n, id, d) => data = ToDictionary(d))
.Verifiable();
var pipelineContext = new Mock <IPipelineContext> {
DefaultValue = DefaultValue.Mock
};
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var sut = new MessagingStep(pipelineContext.Object, message.Object);
activityId = sut.ActivityId;
using (var trackingStream = new TrackingStream(new MemoryStream(_content)))
{
// TrackActivity is supposed to occur at stream's end
trackingStream.Drain();
sut.TrackActivity(ActivityTrackingModes.Step, trackingStream);
}
eventStream.Verify();
var expectedData = new Dictionary <string, object> {
{ nameof(MessagingStep.MessageID), _messageId.AsNormalizedActivityId() },
{ nameof(MessagingStep.PortName), "send-port-name" },
{ nameof(MessagingStep.TransportLocation), "outbound-transport-location" },
{ nameof(MessagingStep.TransportType), "outbound-transport-type" },
{ nameof(MessagingStep.Status), TrackingStatus.Sent },
{ nameof(MessagingStep.MachineName), Environment.MachineName },
{ nameof(MessagingStep.Time), sut.Time }
}
.Union(ExpectedCommonData)
.OrderBy(kvp => kvp.Key).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
data.Should().BeEquivalentTo(expectedData);
sut.MessageType.Should().Be("message-type");
}
public void OutboundFailedPropertiesAreTracked()
{
var message = new MessageMock();
SetupCommonProperties(message);
SetupInboundSuccessfulProperties(message);
SetupOutboundSuccessfulProperties(message);
SetupCommonFailedProperties(message);
message.Setup(m => m.GetProperty(ErrorReportProperties.SendPortName)).Returns("failed-send-port-name");
message.Setup(m => m.GetProperty(ErrorReportProperties.OutboundTransportLocation)).Returns("failed-outbound-transport-location");
var activityId = string.Empty;
Dictionary <string, object> data = null;
var eventStream = new Mock <EventStream>();
eventStream
.Setup(es => es.UpdateActivity(nameof(MessagingStep), It.Is <string>(id => id == activityId), It.IsAny <object[]>()))
.Callback <string, string, object[]>((n, id, d) => data = ToDictionary(d))
.Verifiable();
var pipelineContext = new Mock <IPipelineContext> {
DefaultValue = DefaultValue.Mock
};
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var sut = new MessagingStep(pipelineContext.Object, message.Object);
activityId = sut.ActivityId;
using (var trackingStream = new TrackingStream(new MemoryStream(_content)))
{
// TrackActivity is supposed to occur at stream's end
trackingStream.Drain();
sut.TrackActivity(ActivityTrackingModes.Step, trackingStream);
}
eventStream.Verify();
var expectedData = new Dictionary <string, object> {
{ nameof(MessagingStep.TransportType), "outbound-transport-type" },
{ nameof(MessagingStep.PortName), "failed-send-port-name" },
{ nameof(MessagingStep.TransportLocation), "failed-outbound-transport-location" }
}
.Union(ExpectedCommonFailedData, new LambdaComparer <KeyValuePair <string, object> >((kvp1, kvp2) => kvp1.Key == kvp2.Key))
.Union(ExpectedCommonData, new LambdaComparer <KeyValuePair <string, object> >((kvp1, kvp2) => kvp1.Key == kvp2.Key))
.OrderBy(kvp => kvp.Key).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
data.Should().BeEquivalentTo(expectedData);
sut.MessageType.Should().Be("failed-message-type");
}
public void ActivityIsBegunAndActivityIdWrittenInMessageContext()
{
var eventStream = new Mock <EventStream>();
var pipelineContext = new Mock <IPipelineContext>();
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var message = new MessageMock();
message.Setup(m => m.GetProperty(BtsProperties.InboundTransportLocation)).Returns("inbound-transport-location");
var sut = new MessagingStep(pipelineContext.Object, message.Object);
var activityId = sut.ActivityId;
message.Verify(m => m.SetProperty(TrackingProperties.MessagingStepActivityId, activityId), Times.Once());
eventStream.Verify(s => s.BeginActivity(nameof(MessagingStep), activityId), Times.Once());
}
public void MessagingStepIsAffiliatedToProcess()
{
Dictionary <string, object> data = null;
var processMessagingStepActivityId = string.Empty;
var eventStream = new Mock <EventStream>();
eventStream
.Setup(e => e.BeginActivity(nameof(ProcessMessagingStep), It.IsAny <string>()))
.Callback <string, string>((n, i) => processMessagingStepActivityId = i);
eventStream
.Setup(es => es.UpdateActivity(nameof(ProcessMessagingStep), It.Is <string>(id => id == processMessagingStepActivityId), It.IsAny <object[]>()))
.Callback <string, string, object[]>((n, id, d) => data = Enumerable.Range(0, d.Length / 2).ToDictionary(i => (string)d[i * 2], i => d[i * 2 + 1]))
.Verifiable();
var pipelineContext = new Mock <IPipelineContext>();
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var message = new Unit.Message.Mock <IBaseMessage>();
message.Setup(m => m.GetProperty(ErrorReportProperties.ErrorType)).Returns(TrackingStatus.FailedMessage);
var processActivityId = ActivityId.NewActivityId();
var sut = new Process(processActivityId, eventStream.Object);
var messagingStep = new MessagingStep(pipelineContext.Object, message.Object);
var messagingStepActivityId = messagingStep.ActivityId;
sut.AddStep(messagingStep);
eventStream.Verify();
eventStream.Verify(s => s.BeginActivity(nameof(ProcessMessagingStep), processMessagingStepActivityId), Times.Once());
eventStream.Verify(s => s.UpdateActivity(nameof(ProcessMessagingStep), processMessagingStepActivityId, It.IsAny <object[]>()), Times.Once());
eventStream.Verify(s => s.Flush(), Times.Once());
eventStream.Verify(s => s.EndActivity(nameof(ProcessMessagingStep), processMessagingStepActivityId), Times.Once());
var expectedData = new Dictionary <string, object> {
{ nameof(ProcessMessagingStep.MessagingStepActivityID), messagingStepActivityId },
// capture of Status is what distinguishes affiliation of a MessagingStep from affiliation of a MessagingStepReference
{ nameof(ProcessMessagingStep.MessagingStepStatus), TrackingStatus.FailedMessage },
{ nameof(ProcessMessagingStep.ProcessActivityID), processActivityId }
};
data.Should().BeEquivalentTo(expectedData);
}
public void MessageContextIsTracked()
{
var ns = BtsProperties.MessageType.Namespace;
var name = BtsProperties.MessageType.Name;
var message = new MessageMock();
message.Setup(m => m.GetProperty(BtsProperties.InboundTransportLocation)).Returns("inbound-transport-location");
message.Setup(m => m.Context.CountProperties).Returns(1);
message.Setup(m => m.Context.ReadAt(0, out name, out ns)).Returns("message-type");
message.Setup(m => m.Context.IsPromoted(name, ns)).Returns(false);
var eventStream = new Mock <EventStream>();
var pipelineContext = new Mock <IPipelineContext> {
DefaultValue = DefaultValue.Mock
};
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var sut = new MessagingStep(pipelineContext.Object, message.Object);
using (var trackingStream = new TrackingStream(new MemoryStream(_content)))
{
// TrackActivity is supposed to occur at stream's end
trackingStream.Drain();
sut.TrackActivity(ActivityTrackingModes.Context, trackingStream);
}
eventStream.Verify(
es => es.AddReference(
nameof(MessagingStep),
sut.ActivityId,
MessagingStep.MESSAGE_CONTEXT_REFERENCE_TYPE,
MessagingStep.MESSAGE_CONTEXT_REFERENCE_NAME,
It.IsAny <string>(),
message.Object.Context.ToXml()),
Times.Once());
}
public void ActivityIsCommittedAndEnded()
{
var eventStream = new Mock <EventStream>();
var pipelineContext = new Mock <IPipelineContext>();
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var message = new MessageMock();
message.Setup(m => m.GetProperty(BtsProperties.InboundTransportLocation)).Returns("inbound-transport-location");
var sut = new MessagingStep(pipelineContext.Object, message.Object);
using (var trackingStream = new TrackingStream(new MemoryStream(_content)))
{
// TrackActivity is supposed to occur at stream's end
trackingStream.Drain();
sut.TrackActivity(ActivityTrackingModes.Step, trackingStream);
}
eventStream.Verify(s => s.UpdateActivity(nameof(MessagingStep), sut.ActivityId, It.IsAny <object[]>()), Times.Once());
eventStream.Verify(s => s.Flush(), Times.Once());
eventStream.Verify(s => s.EndActivity(nameof(MessagingStep), sut.ActivityId), Times.Once());
}
public void MessagingStepIsAffiliatedToProcess()
{
var processMessagingStepActivityId = string.Empty;
Dictionary <string, object> data = null;
var eventStream = new Mock <EventStream>();
eventStream
.Setup(e => e.BeginActivity(nameof(ProcessMessagingStep), It.IsAny <string>()))
.Callback <string, string>((_, i) => processMessagingStepActivityId = i);
eventStream
.Setup(es => es.UpdateActivity(nameof(ProcessMessagingStep), It.Is <string>(id => id == processMessagingStepActivityId), It.IsAny <object[]>()))
.Callback <string, string, object[]>((_, _, d) => data = Enumerable.Range(0, d.Length / 2).ToDictionary(i => (string)d[i * 2], i => d[i * 2 + 1]));
var pipelineContext = new Mock <IPipelineContext>();
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var message = new MessageMock();
var messagingStep = new MessagingStep(pipelineContext.Object, message.Object);
var processActivityId = ActivityId.NewActivityId();
var sut = new ProcessReference(processActivityId, eventStream.Object);
sut.AddStep(messagingStep);
eventStream.Verify(s => s.BeginActivity(nameof(ProcessMessagingStep), processMessagingStepActivityId), Times.Once());
eventStream.Verify(s => s.UpdateActivity(nameof(ProcessMessagingStep), processMessagingStepActivityId, It.IsAny <object[]>()), Times.Once());
eventStream.Verify(s => s.Flush(), Times.Once());
eventStream.Verify(s => s.EndActivity(nameof(ProcessMessagingStep), processMessagingStepActivityId), Times.Once());
var expectedData = new Dictionary <string, object> {
{ nameof(ProcessMessagingStep.MessagingStepActivityID), messagingStep.ActivityId },
{ nameof(ProcessMessagingStep.ProcessActivityID), processActivityId }
};
data.Should().BeEquivalentTo(expectedData);
}
public override void AddStep(MessagingStep messagingStep)
{
throw new NotSupportedException();
}
