public void CaptureMessageBody()
{
var trackingStream = new TrackingStream(FakeTextStream.Create(1024 * 1024));
var messageMock = new Unit.Message.Mock <IBaseMessage> {
DefaultValue = DefaultValue.Mock
};
messageMock.Object.BodyPart.Data = trackingStream;
SsoSettingsReaderMock
.Setup(ssr => ssr.ReadString(BizTalkFactorySettings.APPLICATION_NAME, BizTalkFactorySettings.CLAIM_STORE_CHECK_IN_DIRECTORY_PROPERTY_NAME))
.Returns(Path.GetTempPath());
SsoSettingsReaderMock
.Setup(ssr => ssr.ReadString(BizTalkFactorySettings.APPLICATION_NAME, BizTalkFactorySettings.CLAIM_STORE_CHECK_OUT_DIRECTORY_PROPERTY_NAME))
.Returns(@"\\network\share");
ClaimStore.Instance.SetupMessageBodyCapture(trackingStream, ActivityTrackingModes.Body, null);
messageMock.Object.BodyPart.Data.Drain();
// payload is claimed to disk and file extension is .trk
var captureDescriptor = trackingStream.CaptureDescriptor;
Assert.That(captureDescriptor.CaptureMode, Is.EqualTo(MessageBodyCaptureMode.Claimed));
Assert.That(captureDescriptor.Data, Does.StartWith(DateTime.Today.ToString(@"yyyyMMdd\\")));
Assert.That(File.Exists(Path.Combine(Path.GetTempPath(), captureDescriptor.Data.Replace("\\", "") + ".trk")), Is.True);
}
public void CaptureMessageBody()
{
var trackingStream = new TrackingStream(TextStreamDummy.Create(1024 * 1024));
var messageMock = new Unit.Message.Mock <IBaseMessage> {
DefaultValue = DefaultValue.Mock
};
messageMock.Object.BodyPart.Data = trackingStream;
using (var configurationReaderMockInjectionScope = new SsoConfigurationReaderMockInjectionScope())
{
configurationReaderMockInjectionScope.Mock
.Setup(ssr => ssr.Read(ClaimStoreSsoSettings.AFFILIATE_APPLICATION_NAME, nameof(ClaimStoreSsoSettings.ClaimStoreCheckInDirectory)))
.Returns(Path.GetTempPath());
configurationReaderMockInjectionScope.Mock
.Setup(ssr => ssr.Read(ClaimStoreSsoSettings.AFFILIATE_APPLICATION_NAME, nameof(ClaimStoreSsoSettings.ClaimStoreCheckOutDirectory)))
.Returns(@"\\server\share");
ClaimStore.Instance.SetupMessageBodyCapture(trackingStream, ActivityTrackingModes.Body, null);
messageMock.Object.BodyPart.Data.Drain();
// payload is claimed to disk and file extension is .trk
var captureDescriptor = trackingStream.CaptureDescriptor;
captureDescriptor.CaptureMode.Should().Be(MessageBodyCaptureMode.Claimed);
captureDescriptor.Data.Should().StartWith(DateTime.Today.ToString(@"yyyyMMdd\\"));
File.Exists(Path.Combine(Path.GetTempPath(), captureDescriptor.Data.Replace("\\", "") + ".trk")).Should().BeTrue();
}
}
public void ProcessPropertiesAreTracked()
{
var interchangeId = Guid.NewGuid();
var message = new Unit.Message.Mock <IBaseMessage>();
message.Setup(m => m.GetProperty(BtsProperties.InterchangeID)).Returns(interchangeId.ToString());
message.Setup(m => m.GetProperty(TrackingProperties.Value1)).Returns("value-1");
message.Setup(m => m.GetProperty(TrackingProperties.Value2)).Returns("value-2");
message.Setup(m => m.GetProperty(TrackingProperties.Value3)).Returns("value-3");
message.Setup(m => m.GetProperty(ErrorReportProperties.ErrorType)).Returns(TrackingStatus.FailedMessage);
var eventStream = new Mock <EventStream>();
var pipelineContext = new Mock <IPipelineContext>();
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var sut = new Process(pipelineContext.Object, message.Object, "process-name");
Dictionary <string, object> data = null;
eventStream
.Setup(es => es.UpdateActivity(nameof(Process), It.Is <string>(id => id == sut.ActivityId), 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();
sut.TrackActivity();
eventStream.Verify();
var expectedData = new Dictionary <string, object> {
{ nameof(Process.InterchangeID), interchangeId.AsNormalizedActivityId() },
public void ExecuteWhenMicroComponentEnumerableIsEmpty()
{
var messageMock = new Unit.Message.Mock <IBaseMessage>();
var sut = new MicroPipeline();
sut.Execute(new Mock <IPipelineContext>().Object, messageMock.Object).Should().BeSameAs(messageMock.Object);
}
public void CreateProcessReturnsRegularProcess()
{
var messageMock = new Unit.Message.Mock <IBaseMessage>();
var factory = new ActivityFactory(PipelineContextMock.Object);
Assert.That(factory.CreateProcess(messageMock.Object, "name"), Is.TypeOf <Process>());
}
public void ExecuteRunsThroughMicroComponentEnumerable()
{
var pipelineContextMock = new Mock <IPipelineContext>();
var messageMock1 = new Unit.Message.Mock <IBaseMessage>();
var messageMock2 = new Unit.Message.Mock <IBaseMessage>();
var messageMock3 = new Unit.Message.Mock <IBaseMessage>();
var microComponentMockOne = new Mock <IMicroComponent>();
microComponentMockOne
.Setup(mc => mc.Execute(pipelineContextMock.Object, messageMock1.Object)).Returns(messageMock2.Object)
.Verifiable();
var microComponentMockTwo = new Mock <IMicroComponent>();
microComponentMockTwo
.Setup(mc => mc.Execute(pipelineContextMock.Object, messageMock2.Object)).Returns(messageMock3.Object)
.Verifiable();
var sut = new MicroPipeline {
Components = new[] {
microComponentMockOne.Object,
microComponentMockTwo.Object
}
};
sut.Execute(pipelineContextMock.Object, messageMock1.Object).Should().BeSameAs(messageMock3.Object);
microComponentMockOne.Verify();
microComponentMockTwo.Verify();
}
public void CreateMessagingStepReturnsRegularMessagingStep()
{
var messageMock = new Unit.Message.Mock <IBaseMessage>();
var factory = new ActivityFactory(PipelineContextMock.Object);
Assert.That(factory.CreateMessagingStep(messageMock.Object), Is.TypeOf <MessagingStep>());
}
public void ExecuteMicroComponents()
{
var pipelineContextMock = new Mock <IPipelineContext>();
var messageMock1 = new Unit.Message.Mock <IBaseMessage>();
var messageMock2 = new Unit.Message.Mock <IBaseMessage>();
var messageMock3 = new Unit.Message.Mock <IBaseMessage>();
var microComponentMockOne = new Mock <IMicroPipelineComponent>();
microComponentMockOne
.Setup(mc => mc.Execute(pipelineContextMock.Object, messageMock1.Object)).Returns(messageMock2.Object)
.Verifiable();
var microComponentMockTwo = new Mock <IMicroPipelineComponent>();
microComponentMockTwo
.Setup(mc => mc.Execute(pipelineContextMock.Object, messageMock2.Object)).Returns(messageMock3.Object)
.Verifiable();
var sut = new MicroPipelineComponent {
Components = new[] {
microComponentMockOne.Object,
microComponentMockTwo.Object
}
};
Assert.That(sut.Execute(pipelineContextMock.Object, messageMock1.Object), Is.SameAs(messageMock3.Object));
microComponentMockOne.VerifyAll();
microComponentMockTwo.VerifyAll();
}
public void CreateProcessReturnsRegularProcess()
{
var messageMock = new Unit.Message.Mock <IBaseMessage>();
var factory = new ActivityFactory(PipelineContextMock.Object);
factory.CreateProcess(messageMock.Object, "name").Should().BeOfType <Process>();
}
public void CreateMessagingStepReturnsRegularMessagingStep()
{
var messageMock = new Unit.Message.Mock <IBaseMessage>();
var factory = new ActivityFactory(PipelineContextMock.Object);
factory.CreateMessagingStep(messageMock.Object).Should().BeOfType <MessagingStep>();
}
public void GetTrackingContextForMessagingStepThrowsOnEmpty()
{
var message = new Unit.Message.Mock <IBaseMessage>();
Assert.That(
() => message.Object.GetTrackingContext(true),
Throws.InvalidOperationException.With.Message.EqualTo("Invalid TrackingContext: None of its discrete activity Ids are set."));
}
public void GetTrackingContextForMessagingStepThrowsOnEmpty()
{
var message = new Unit.Message.Mock <IBaseMessage>();
Invoking(() => message.Object.GetTrackingContext(true))
.Should().Throw <InvalidOperationException>()
.WithMessage("Invalid TrackingContext: None of its discrete activity Ids are set.");
}
public void ExecuteNoMicroComponents()
{
var messageMock = new Unit.Message.Mock <IBaseMessage>();
var sut = new MicroPipelineComponent();
Assert.That(sut.Execute(new Mock <IPipelineContext>().Object, messageMock.Object), Is.SameAs(messageMock.Object));
}
public void ValueWrittenViaContextIsVerifiableViaMessage()
{
var message = new Unit.Message.Mock <IBaseMessage>();
var sut = new Context(message.Object.Context);
sut.Write(TrackingProperties.ProcessName.QName, "process-name");
message.Verify(m => m.SetProperty(TrackingProperties.ProcessName, "process-name"));
}
public void ValueWrittenViaContextIsNotReadableViaMessage()
{
var message = new Unit.Message.Mock <IBaseMessage>();
var sut = new Context(message.Object.Context);
sut.Write(TrackingProperties.ProcessName.QName, "process-name");
Assert.That(message.Object.GetProperty(TrackingProperties.ProcessName), Is.Null);
}
public ClaimStoreFixture()
{
// reset ClaimStore's cached value
ClaimStore.CheckInDirectory = null;
ClaimStore.CheckOutDirectory = null;
MessageMock = new Unit.Message.Mock <IBaseMessage> {
DefaultValue = DefaultValue.Mock
};
ResourceTrackerMock = new Mock <IResourceTracker>();
}
private void SetupCommonFailedProperties(Unit.Message.Mock <IBaseMessage> message)
{
_failedMessageId = Guid.NewGuid();
_failureTime = DateTime.UtcNow;
message.Setup(m => m.GetProperty(ErrorReportProperties.FailureMessageID)).Returns(_failedMessageId.ToString());
message.Setup(m => m.GetProperty(ErrorReportProperties.MessageType)).Returns("failed-message-type");
message.Setup(m => m.GetProperty(ErrorReportProperties.ErrorType)).Returns(TrackingStatus.FailedMessage);
message.Setup(m => m.GetProperty(ErrorReportProperties.FailureCode)).Returns("failure-code");
message.Setup(m => m.GetProperty(ErrorReportProperties.Description)).Returns("failure-description");
message.Setup(m => m.GetProperty(ErrorReportProperties.ProcessingServer)).Returns("failing-machine");
message.Setup(m => m.GetProperty(ErrorReportProperties.FailureTime)).Returns(_failureTime);
}
private void SetupCommonProperties(Unit.Message.Mock <IBaseMessage> message)
{
_interchangeId = Guid.NewGuid();
message.Setup(m => m.GetProperty(BtsProperties.InterchangeID)).Returns(_interchangeId.ToString());
_messageId = Guid.NewGuid();
message.Setup(m => m.MessageID).Returns(_messageId);
message.Setup(m => m.GetProperty(BtsProperties.MessageType)).Returns("message-type");
message.Setup(m => m.GetProperty(BtsProperties.ActualRetryCount)).Returns(3);
message.Setup(m => m.GetProperty(TrackingProperties.Value1)).Returns("value-1");
message.Setup(m => m.GetProperty(TrackingProperties.Value2)).Returns("value-2");
message.Setup(m => m.GetProperty(TrackingProperties.Value3)).Returns("value-3");
}
public void ActivityIsBegunAndActivityIdWrittenInMessageContext()
{
var eventStream = new Mock <EventStream>();
var pipelineContext = new Mock <IPipelineContext>();
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var message = new Unit.Message.Mock <IBaseMessage>();
var sut = new Process(pipelineContext.Object, message.Object, "process-name");
var activityId = sut.ActivityId;
message.Verify(m => m.SetProperty(TrackingProperties.ProcessActivityId, activityId), Times.Once());
eventStream.Verify(s => s.BeginActivity(nameof(Process), activityId), Times.Once());
}
public void SetUp()
{
// reset ClaimStore's cached value
ClaimStore.CheckInDirectory = null;
ClaimStore.CheckOutDirectory = null;
MessageMock = new Unit.Message.Mock <IBaseMessage> {
DefaultValue = DefaultValue.Mock
};
ResourceTrackerMock = new Mock <IResourceTracker>();
_ssoSettingsReaderInstance = SsoSettingsReader.Instance;
SsoSettingsReaderMock = new Mock <ISsoSettingsReader>();
SsoSettingsReader.Instance = SsoSettingsReaderMock.Object;
}
public void SetUp()
{
_claimStoreInstance = ClaimStore.Instance;
ClaimStoreMock = new Mock <ClaimStore>();
ClaimStore.Instance = ClaimStoreMock.Object;
MessageMock = new Unit.Message.Mock <IBaseMessage>();
MessageMock.Setup(m => m.GetProperty(BtsProperties.InboundTransportLocation)).Returns("inbound-transport-location");
PipelineContextMock = new Mock <IPipelineContext>();
PipelineContextMock.Setup(pc => pc.ResourceTracker).Returns(new Mock <IResourceTracker>().Object);
_trackingResolverFactory = TrackingResolver.Factory;
TrackingResolverMock = new Mock <TrackingResolver>(MessageMock.Object);
TrackingResolver.Factory = message => TrackingResolverMock.Object;
}
public void SetUp()
{
MessageMock = new Unit.Message.Mock <IBaseMessage>();
MessageMock.Setup(m => m.GetProperty(TrackingProperties.MessagingStepActivityId)).Returns(ActivityId.NewActivityId());
PipelineContextMock = new Mock <IPipelineContext>();
ProcessMock = new Mock <BatchReleaseProcess>("pseudo-process-activity-id", new Mock <EventStream>().Object);
ActivityFactory = new Mock <IBatchProcessActivityFactory>();
ActivityFactory.Setup(af => af.CreateProcess(It.IsAny <IBaseMessage>(), It.IsAny <string>())).Returns(ProcessMock.Object);
ActivityFactory.Setup(af => af.FindProcess(It.IsAny <string>())).Returns(ProcessMock.Object);
_activityFactoryFactory = PipelineContextExtensions.ActivityFactoryFactory;
PipelineContextExtensions.ActivityFactoryFactory = pipelineContext => ActivityFactory.As <IActivityFactory>().Object;
}
public void ProcessPropertiesAreTracked()
{
var interchangeId = Guid.NewGuid();
var message = new Unit.Message.Mock <IBaseMessage>();
message.Setup(m => m.GetProperty(BtsProperties.InterchangeID)).Returns(interchangeId.ToString());
message.Setup(m => m.GetProperty(TrackingProperties.Value1)).Returns("value-1");
message.Setup(m => m.GetProperty(TrackingProperties.Value2)).Returns("value-2");
message.Setup(m => m.GetProperty(TrackingProperties.Value3)).Returns("value-3");
message.Setup(m => m.GetProperty(ErrorReportProperties.ErrorType)).Returns(TrackingStatus.FailedMessage);
var eventStream = new Mock <EventStream>();
var pipelineContext = new Mock <IPipelineContext>();
pipelineContext.Setup(pc => pc.GetEventStream()).Returns(eventStream.Object);
var sut = new Process(pipelineContext.Object, message.Object, "process-name");
Dictionary <string, object> data = null;
eventStream
.Setup(es => es.UpdateActivity(Process.ActivityName, It.Is <string>(id => id == sut.ActivityId), 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();
sut.TrackActivity();
eventStream.Verify();
var expectedData = new Dictionary <string, object> {
{ Process.InterchangeIDFieldName, interchangeId.AsNormalizedActivityId() },
{ Process.ProcessNameFieldName, "process-name" },
{ Process.StatusFieldName, TrackingStatus.Failed },
{ Process.Value1FieldName, "value-1" },
{ Process.Value2FieldName, "value-2" },
{ Process.Value3FieldName, "value-3" },
// ReSharper disable PossibleInvalidOperationException
{ Process.BeginTimeFieldName, sut.BeginTime.Value },
{ Process.EndTimeFieldName, sut.EndTime.Value }
// ReSharper restore PossibleInvalidOperationException
};
Assert.That(data, Is.EquivalentTo(expectedData));
}
public void SetTrackingContextForMessagingStep()
{
var message = new Unit.Message.Mock <IBaseMessage>();
var tp = message.Object.SetTrackingContext(CreateTrackingContext());
// processing step activity id is propagated
message.Verify(
m => m.SetProperty(TrackingProperties.ProcessingStepActivityId, tp.ProcessingStepActivityId),
Times.Once());
// and all other tracking properties also are
message.Verify(
m => m.SetProperty(TrackingProperties.ProcessActivityId, tp.ProcessActivityId),
Times.Once());
message.Verify(
m => m.SetProperty(TrackingProperties.MessagingStepActivityId, tp.MessagingStepActivityId),
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 Unit.Message.Mock <IBaseMessage>();
var sut = new Process(pipelineContext.Object, message.Object, "process-name");
var activityId = sut.ActivityId;
sut.TrackActivity();
eventStream.Verify(s => s.UpdateActivity(nameof(Process), activityId, It.IsAny <object[]>()), Times.Once());
eventStream.Verify(s => s.Flush(), Times.Once());
eventStream.Verify(s => s.EndActivity(nameof(Process), 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 GetTrackingContextForMessagingStep()
{
var message = new Unit.Message.Mock <IBaseMessage>(MockBehavior.Strict);
message
.Setup(m => m.GetProperty(TrackingProperties.ProcessActivityId))
.Returns(It.IsAny <string>())
.Verifiable();
message
.Setup(m => m.GetProperty(TrackingProperties.ProcessingStepActivityId))
.Returns(It.IsAny <string>())
.Verifiable();
message
.Setup(m => m.GetProperty(TrackingProperties.MessagingStepActivityId))
.Returns(It.IsAny <string>())
.Verifiable();
message.Object.GetTrackingContext();
message.Verify();
}
public void SetUp()
{
MessageMock = new Unit.Message.Mock <IBaseMessage>();
MessageMock.Setup(m => m.GetProperty(BtsProperties.InboundTransportLocation)).Returns("inbound-transport-location");
PipelineContextMock = new Mock <IPipelineContext>();
ProcessMock = new Mock <Process>("pseudo-process-activity-id", new Mock <EventStream>().Object);
InitiatingMessagingStepMock = new Mock <MessagingStep>("pseudo-initiating-activity-id", new Mock <EventStream>().Object);
MessagingStepMock = new Mock <MessagingStep>("pseudo-activity-id", new Mock <EventStream>().Object);
ActivityFactory = new Mock <IActivityFactory>();
ActivityFactory.Setup(af => af.CreateProcess(It.IsAny <IBaseMessage>(), It.IsAny <string>())).Returns(ProcessMock.Object);
ActivityFactory.Setup(af => af.FindProcess(It.IsAny <TrackingContext>())).Returns(ProcessMock.Object);
ActivityFactory.Setup(af => af.CreateMessagingStep(It.IsAny <IBaseMessage>())).Returns(MessagingStepMock.Object);
ActivityFactory.Setup(af => af.FindMessagingStep(It.IsAny <TrackingContext>())).Returns(InitiatingMessagingStepMock.Object);
_activityFactoryFactory = PipelineContextExtensions.ActivityFactoryFactory;
PipelineContextExtensions.ActivityFactoryFactory = pipelineContext => ActivityFactory.Object;
_trackingResolverFactory = TrackingResolver.Factory;
TrackingResolverMock = new Mock <TrackingResolver>(MessageMock.Object);
TrackingResolver.Factory = message => TrackingResolverMock.Object;
}
private static void SetupOutboundSuccessfulProperties(Unit.Message.Mock <IBaseMessage> message)
{
message.Setup(m => m.GetProperty(BtsProperties.SendPortName)).Returns("send-port-name");
message.Setup(m => m.GetProperty(BtsProperties.OutboundTransportLocation)).Returns("outbound-transport-location");
message.Setup(m => m.GetProperty(BtsProperties.OutboundTransportType)).Returns("outbound-transport-type");
}
private void SetupInboundSuccessfulProperties(Unit.Message.Mock <IBaseMessage> message)
{
message.Setup(m => m.GetProperty(BtsProperties.ReceiveLocationName)).Returns("receive-location-name");
message.Setup(m => m.GetProperty(BtsProperties.InboundTransportLocation)).Returns("inbound-transport-location");
message.Setup(m => m.GetProperty(BtsProperties.InboundTransportType)).Returns("inbound-transport-type");
}
