public async Task A_consumer_is_being_tested()
{
var builder = new ContainerBuilder();
builder.RegisterType <MyConsumer>();
builder.RegisterGeneric(typeof(ValidatorFilter <>));
builder.RegisterType <AValidator>()
.As <IValidator <A> >();
builder.RegisterType <ConsumerConfigurationObserver>()
.SingleInstance();
_container = builder.Build();
_observer = _container.Resolve <ConsumerConfigurationObserver>();
_harness = new InMemoryTestHarness();
_harness.OnConfigureBus += ConfigureBus;
_consumer = _harness.Consumer(new AutofacConsumerFactory <MyConsumer>(_container, "message"));
await _harness.Start();
Console.WriteLine(_harness.Bus.GetProbeResult().ToJsonString());
}
public async Task Should_publish_fileinfo_submitted_event()
{
// Arrange (Given)
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitFileInfoConsumer>();
await harness.Start();
try
{
var fileId = NewId.NextGuid();
await harness.InputQueueSendEndpoint.Send <SubmitFileInfo>(new
{
FileId = fileId,
InVar.Timestamp,
FileName = "filename.file",
Folder = "c:/folder/"
});
// Assert (Then)
Assert.True(harness.Published.Select <FileInfoSubmitted>().Any());
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_with_rejection_if_test_file()
{
// Arrange (Given)
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitFileInfoConsumer>();
await harness.Start();
try
{
var fileId = NewId.NextGuid();
var requestClient = await harness.ConnectRequestClient <SubmitFileInfo>();
// Act (When)
var response = await requestClient.GetResponse <FileInfoSubmissionRejected>(new
{
FileId = fileId,
InVar.Timestamp,
FileName = "TEST.file",
Folder = "c:/folder/"
});
// Assert (Then)
Assert.Equal <Guid>(response.Message.FileId, fileId);
Assert.True(consumer.Consumed.Select <SubmitFileInfo>().Any());
Assert.True(harness.Sent.Select <FileInfoSubmissionRejected>().Any());
}
finally
{
await harness.Stop();
}
}
public async Task Should_create_a_state_instance()
{
var orderStateMachine = new OrderStateMachine();
var harness = new InMemoryTestHarness();
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 = "12345"
});
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);
var instance = saga.Sagas.Contains(instanceId.Value);
Assert.That(instance.CustomerNumber, Is.EqualTo("12345"));
}
finally
{
await harness.Stop();
}
}
public async Task Should_consume_submit_fileinfo_commands()
{
// Arrange (Given)
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(5)
};
var consumer = harness.Consumer <SubmitFileInfoConsumer>();
await harness.Start();
try
{
var fileId = NewId.NextGuid();
// Act (When)
await harness.InputQueueSendEndpoint.Send <SubmitFileInfo>(new
{
FileId = fileId,
InVar.Timestamp,
FileName = "filename.file",
Folder = "c:/folder/"
});
// Assert (Then)
Assert.True(consumer.Consumed.Select <SubmitFileInfo>().Any());
Assert.False(harness.Sent.Select <FileInfoSubmissionAccepted>().Any());
Assert.False(harness.Sent.Select <FileInfoSubmissionRejected>().Any());
}
finally
{
await harness.Stop();
}
}
public async Task Should_keep_em_separated()
{
var internalHarness = new InMemoryTestHarness("internal");
var externalHarness = new InMemoryTestHarness("external");
ConsumerTestHarness <RelayConsumer> internalConsumer = internalHarness.Consumer(() => new RelayConsumer(externalHarness.Bus));
ConsumerTestHarness <RelayConsumer> externalConsumer = externalHarness.Consumer(() => new RelayConsumer(internalHarness.Bus));
var realConsumer = internalHarness.Consumer <RealConsumer>();
await internalHarness.Start();
try
{
await externalHarness.Start();
try
{
await externalHarness.Bus.Publish(new A());
realConsumer.Consumed.Select <A>().Any().ShouldBeTrue();
}
finally
{
await externalHarness.Stop();
}
}
finally
{
await internalHarness.Stop();
}
}
public async Task Should_respond_to_status_checks()
{
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);
var requestClient = await harness.ConnectRequestClient <CheckOrder>();
var response = await requestClient.GetResponse <OrderStatus>(new
{
OrderId = orderId
});
Assert.That(response.Message.State, Is.EqualTo(orderStateMachine.Submitted.Name));
}
finally
{
await harness.Stop();
}
}
public async Task Should_consume_submit_order_command()
{
var harness = new InMemoryTestHarness();
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",
});
Assert.That(consumer.Consumed.Select <SubmitOrder>().Any(), Is.True);
}
finally
{
await harness.Stop();
}
}
public async Task Should_Consume_AccountCheckCommand()
{
var harness = new InMemoryTestHarness();
var consumerHarness = harness.Consumer <ApprovalsSubscriptionsHandler>();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send(new AccountCheckCommand
{
Id = Guid.NewGuid().ToString(),
ProfileId = Guid.NewGuid().ToString()
});
// did the endpoint consume the message
Assert.True(await harness.Consumed.Any <AccountCheckCommand>());
// did the actual consumer consume the message
Assert.True(await consumerHarness.Consumed.Any <AccountCheckCommand>());
}
finally
{
await harness.Stop();
}
}
public async void InMemory()
{
var counter = new FaultCounter();
var harness = new InMemoryTestHarness();
try
{
harness.OnConfigureInMemoryBus += cfg =>
cfg.UseRetry(x =>
{
x.Immediate(1);
x.ConnectRetryObserver(new RetryObserver(counter));
});
harness.OnConfigureInMemoryReceiveEndpoint += cfg => harness.Handler <PingMessage>(cfg, ctx => throw new Exception());
await harness.Start();
var faultHandlerTask = harness.SubscribeHandler <Fault <PingMessage> >();
await harness.InputQueueSendEndpoint.Send(new PingMessage(), ctx =>
{
ctx.ResponseAddress = harness.BusAddress;
ctx.FaultAddress = harness.BusAddress;
});
await faultHandlerTask;
Assert.Equal(1, counter.Faults);
}
finally
{
await harness.Stop();
}
}
public async Task A_consumer_is_being_tested()
{
_loggerMock = new Mock <ILogger <SearchRequestConsumer> >();
_providerProfileMock = new Mock <IOptions <ProviderProfileOptions> >();
_retryConfigurationMock = new Mock <IOptions <RetryConfiguration> >();
_personSearchValidatorMock = new Mock <IValidator <Person> >();
_personSearchValidatorMock.Setup(x => x.Validate(It.Is <Person>(person => !string.IsNullOrEmpty(person.FirstName))))
.Returns(new ValidationResult(Enumerable.Empty <ValidationFailure>()));
_personSearchValidatorMock.Setup(x => x.Validate(It.Is <Person>(person => string.IsNullOrEmpty(person.FirstName))))
.Returns(new ValidationResult(new List <ValidationFailure>()
{
new ValidationFailure("firstName", "firstName is required.")
}));
_harness = new InMemoryTestHarness();
_sut = _harness.Consumer(() => new SearchRequestConsumer(_personSearchValidatorMock.Object, _providerProfileMock.Object, _retryConfigurationMock.Object, _loggerMock.Object));
await _harness.Start();
await _harness.BusControl.Publish <PersonSearchOrdered>(new PersonSearchOrderedTest()
{
SearchRequestId = validGuid,
TimeStamp = DateTime.Now,
Person = new Person()
{
FirstName = "firstName",
LastName = "lastName",
DateOfBirth = new DateTime(2001, 1, 1)
},
SearchRequestKey = "SearchRequestKey"
});
await _harness.BusControl.Publish <PersonSearchOrdered>(new PersonSearchOrderedTest()
{
SearchRequestId = validGuid,
TimeStamp = DateTime.Now,
Person = new Person()
{
FirstName = "exception",
LastName = "lastName",
DateOfBirth = new DateTime(2001, 1, 1)
},
SearchRequestKey = "SearchRequestKey"
});
await _harness.BusControl.Publish <PersonSearchOrdered>(new PersonSearchOrderedTest()
{
SearchRequestId = inValidGuid,
TimeStamp = DateTime.Now,
Person = new Person()
{
FirstName = "",
LastName = "lastName",
DateOfBirth = new DateTime(2001, 1, 1)
},
SearchRequestKey = "SearchRequestKey"
});
}
public InMemoryTestFixture(InMemoryTestHarness harness)
: base(harness)
{
InMemoryTestHarness = harness;
InMemoryTestHarness.OnConfigureInMemoryBus += ConfigureInMemoryBus;
InMemoryTestHarness.OnConfigureInMemoryReceiveEndpoint += ConfigureInMemoryReceiveEndpoint;
}
public async Task Should_Consume_TransactionIsCheckedEvent()
{
var harness = new InMemoryTestHarness();
var consumerHarness = harness.Consumer <TransactionsSubscriptionsHandler>();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send(new TransactionIsCheckedEvent
{
ProfileId = Guid.NewGuid().ToString()
});
// did the endpoint consume the message
Assert.True(await harness.Consumed.Any <TransactionIsCheckedEvent>());
// did the actual consumer consume the message
Assert.True(await consumerHarness.Consumed.Any <TransactionIsCheckedEvent>());
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_with_rejected_if_test()
{
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(3)
};
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
// use this for request/response scenarios
var requestClient = await harness.ConnectRequestClient <SubmitOrderCommand>();
var response = await requestClient.GetResponse <OrderSubmissionRejectedResponse>(new
{
OrderId = orderId,
InVar.Timestamp,
Customer = "TEST1234"
});
response.Message.OrderId.IsSameOrEqualTo(orderId);
consumer.Consumed.Select <SubmitOrderCommand>().Any().Should().BeTrue();
harness.Sent.Select <OrderSubmissionRejectedResponse>().Any().Should().BeTrue();
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_with_rejected_if_test()
{
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
var requestClient = await harness.ConnectRequestClient <SubmitOrder>();
var response = await requestClient.GetResponse <OrderSubmissionRejected>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "TEST123"
});
Assert.That(response.Message.OrderId, Is.EqualTo(orderId));
Assert.That(consumer.Consumed.Select <SubmitOrder>().Any(), Is.True);
Assert.That(harness.Sent.Select <OrderSubmissionRejected>().Any(), Is.True);
}
finally
{
await harness.Stop();
}
}
public async Task Should_consume_submit_order_commands()
{
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(5)
};
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "12345"
});
Assert.That(consumer.Consumed.Select <SubmitOrder>().Any(), Is.True);
Assert.That(harness.Sent.Select <OrderSubmissionAccepted>().Any(), Is.False);
Assert.That(harness.Sent.Select <OrderSubmissionRejected>().Any(), Is.False);
}
finally
{
await harness.Stop();
}
}
public async Task Should_not_timeout()
{
var harness = new InMemoryTestHarness();
var machine = new TestSagaStateMachine();
StateMachineSagaTestHarness <TestSaga, TestSagaStateMachine> sagaHarness = harness.StateMachineSaga <TestSaga, TestSagaStateMachine>(machine);
harness.TestTimeout = TimeSpan.FromSeconds(15);
harness.OnConfigureBus += x => BusTestFixture.ConfigureBusDiagnostics(x);
await harness.Start();
// Act
try
{
IRequestClient <StartCommand> client = harness.CreateRequestClient <StartCommand>();
Response <StartCommandResponse> response = await client.GetResponse <StartCommandResponse>(
new
{
CorrelationId = InVar.Id,
});
// Assert
// did the actual saga consume the message
Assert.True(await sagaHarness.Consumed.Any <StartCommand>());
}
finally
{
await harness.Stop();
}
}
public async Task Should_publish_order_submitted_event()
{
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "12345"
});
Assert.That(await harness.Published.Any <OrderSubmitted>(), Is.True);
}
finally
{
await harness.Stop();
}
}
public async Task Should_test_the_consumer()
{
var mockedReportService = new Mock <IReportService>();
var token = new CancellationTokenSource().Token;
mockedReportService.Setup(rs => rs.Save(token)).Returns(Task.CompletedTask);
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <PersonConsumer>(() => new PersonConsumer(mockedReportService.Object), null);
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send(new PersonDto()
{
Id = 1
});
// did the endpoint consume the message
Assert.True(harness.Consumed.Select <PersonDto>().Any());
// did the actual consumer consume the message
Assert.True(consumer.Consumed.Select <PersonDto>().Any());
}
finally
{
await harness.Stop();
}
}
public async Task Setup()
{
var collection = new ServiceCollection()
.AddSingleton <ILoggerFactory>(_ => BusTestFixture.LoggerFactory)
.AddSingleton(typeof(ILogger <>), typeof(Logger <>))
.AddMassTransitInMemoryTestHarness(cfg =>
{
_testFixtureConfigurator.ConfigureFutureSagaRepository(cfg);
cfg.SetKebabCaseEndpointNameFormatter();
ConfigureMassTransit(cfg);
})
.AddGenericRequestClient();
_testFixtureConfigurator.ConfigureServices(collection);
ConfigureServices(collection);
Provider = collection.BuildServiceProvider(true);
ConfigureLogging();
await _testFixtureConfigurator.OneTimeSetup(Provider);
TestHarness = Provider.GetRequiredService <InMemoryTestHarness>();
TestHarness.TestTimeout = TimeSpan.FromSeconds(5);
TestHarness.OnConfigureInMemoryBus += configurator =>
{
ConfigureInMemoryBus(configurator);
};
await TestHarness.Start();
}
public async Task Should_consume_submit_order_command()
{
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(3)
};
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
// use this to send commands not request/response
await harness.InputQueueSendEndpoint.Send <SubmitOrderCommand>(new
{
OrderId = orderId,
InVar.Timestamp,
Customer = "1234"
});
consumer.Consumed.Select <SubmitOrderCommand>().Any().Should().BeTrue();
harness.Sent.Select <OrderSubmissionAcceptedResponse>().Any().Should().BeFalse();
harness.Sent.Select <OrderSubmissionRejectedResponse>().Any().Should().BeFalse();
}
finally
{
await harness.Stop();
}
}
public async Task SubmitOrderConsumer_Accepted()
{
var harness = new InMemoryTestHarness();
harness.Consumer <SubmitOrderConsumer>();
try
{
await harness.Start();
var orderId = NewId.NextGuid();
var requestClientSubmitOrder = await harness.ConnectRequestClient <ISubmitOrder>();
var(accepted, rejected) =
await requestClientSubmitOrder.GetResponse <IOrderAccepted, IOrderRejected>(new
{
OrderId = orderId,
Amount = 900
});
harness.Consumed.Select <ISubmitOrder>().Any().Should().Be.True();
accepted.IsCompletedSuccessfully.Should().Be.True();
rejected.IsCompletedSuccessfully.Should().Be.False();
harness.Published.Select <IOrderAcceptedEvent>().Any().Should().Be.True();
}
finally
{
await harness.Stop();
}
}
public async Task Should_respond_with_acceptance_if_ok()
{
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
// use this for request/response scenarios
var requestClient = await harness.ConnectRequestClient <SubmitOrderCommand>();
var response = await requestClient.GetResponse <OrderSubmissionAcceptedResponse>(new
{
OrderId = orderId,
InVar.Timestamp,
Customer = "1234"
});
response.Message.OrderId.IsSameOrEqualTo(orderId);
consumer.Consumed.Select <SubmitOrderCommand>().Any().Should().BeTrue();
harness.Sent.Select <OrderSubmissionAcceptedResponse>().Any().Should().BeTrue();
// harness.Published.Select<OrderSubmittedEvent>().Any().Should().BeTrue();
}
finally
{
await harness.Stop();
}
}
public async Task A_consumer_is_being_tested()
{
_harness = new InMemoryTestHarness();
_fakeConsumerTestHarness = _harness.Consumer(() => new FakeFailureConsumer());
_personSearchObserver = new Mock <ILogger <PersonSearchObserver> >();
_providerProfileOptiosnMock = new Mock <IOptions <ProviderProfileOptions> >();
_providerProfileOptiosnMock.Setup(x => x.Value).Returns(new ProviderProfileOptions()
{
Name = "Adapter Tester"
});
await _harness.Start();
_harness.Bus.ConnectConsumeMessageObserver(new PersonSearchObserver(_providerProfileOptiosnMock.Object,
_personSearchObserver.Object));
await _harness.BusControl.Publish <PersonSearchOrdered>(new PersonSearchOrderedTest()
{
SearchRequestId = Guid.NewGuid(),
TimeStamp = DateTime.Now,
Person = new FakePerson()
{
FirstName = "",
LastName = "lastName",
DateOfBirth = new DateTime(2001, 1, 1)
}
});
}
public async Task Should_not_publish_order_submitted_event_when_rejected()
{
var harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(3)
};
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
await harness.InputQueueSendEndpoint.Send <SubmitOrderCommand>(new
{
OrderId = orderId,
InVar.Timestamp,
Customer = "TEST1234"
});
harness.Published.Select <OrderSubmittedEvent>().Any().Should().BeFalse();
}
finally
{
await harness.Stop();
}
}
public async Task If_transformation_success_AssetReady_event_is_success()
{
// Arrange
repositoryPackage.ArchiveRecordId = "113";
assetManager.Setup(e => e.ConvertPackage("113", AssetType.Gebrauchskopie, false, It.IsAny <RepositoryPackage>()))
.ReturnsAsync(new PackageConversionResult {
Valid = true, FileName = "113.zip"
});
cacheHelper.Setup(e => e.GetFtpUrl(It.IsAny <IBus>(), It.IsAny <CacheRetentionCategory>(), It.IsAny <string>()))
.ReturnsAsync("ftp://UsageCopyPublic:@someurl:9000/113");
cacheHelper.Setup(e => e.SaveToCache(It.IsAny <IBus>(), It.IsAny <CacheRetentionCategory>(), It.IsAny <string>()))
.ReturnsAsync(true);
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer(() => new TransformPackageConsumer(assetManager.Object, cacheHelper.Object, harness.Bus));
harness.Consumer(() => assetReady.Object);
await harness.Start();
try
{
// Act
await harness.InputQueueSendEndpoint.Send <ITransformAsset>(new TransformAsset
{
AssetType = AssetType.Gebrauchskopie,
RepositoryPackage = repositoryPackage,
CallerId = "2223",
RetentionCategory = CacheRetentionCategory.UsageCopyPublic
});
// did the endpoint consume the message
Assert.That(await harness.Consumed.Any <ITransformAsset>());
// did the actual consumer consume the message
Assert.That(await consumer.Consumed.Any <ITransformAsset>());
// the consumer publish the event
Assert.That(await harness.Published.Any <IAssetReady>());
// ensure that no faults were published by the consumer
Assert.That(await harness.Published.Any <Fault <IAssetReady> >(), Is.False);
// did the actual consumer consume the message
Assert.That(await harness.Consumed.Any <IAssetReady>());
var message = harness.Consumed.Select <IAssetReady>().FirstOrDefault();
// Assert
Assert.That(message != null);
message.Context.Message.ArchiveRecordId.Should().Be("113");
message.Context.Message.CallerId = "2223";
message.Context.Message.Valid.Should().Be(true);
}
finally
{
await harness.Stop();
}
}
public async Task A_consumer_is_being_tested()
{
_harness = new InMemoryTestHarness();
_batchConsumer = new TestBatchConsumer(_harness.GetTask <Batch <PingMessage> >());
_consumer = _harness.Consumer(() => _batchConsumer, c => c.Options <BatchOptions>(o => o.SetMessageLimit(2)));
await _harness.Start();
}
public async Task SetUp()
{
_harness = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(5)
};
_consumer = _harness.Consumer <SubmitOrderConsumer>();
await _harness.Start();
}
public async Task MassTransitInstrumentationConsumerAndHandlerTest()
{
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using (Sdk.CreateTracerProviderBuilder()
.AddProcessor(activityProcessor.Object)
.AddMassTransitInstrumentation()
.Build())
{
var harness = new InMemoryTestHarness();
var consumerHarness = harness.Consumer <TestConsumer>();
var handlerHarness = harness.Handler <TestMessage>();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send <TestMessage>(new
{
Text = "Hello, world!",
});
Assert.True(await harness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await consumerHarness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await handlerHarness.Consumed.SelectAsync().Any());
}
finally
{
await harness.Stop();
}
}
Assert.Equal(10, activityProcessor.Invocations.Count);
var sends = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Transport.Send);
var receives = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Transport.Receive);
var consumes = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Consumer.Consume);
var handles = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Consumer.Handle);
foreach (var activity in sends)
{
Assert.Equal("SEND /input_queue", activity.DisplayName);
}
foreach (var activity in receives)
{
Assert.Equal("RECV /input_queue", activity.DisplayName);
}
foreach (var activity in consumes)
{
Assert.Equal("CONSUME OpenTelemetry.Contrib.Instrumentation.MassTransit.Tests.TestConsumer", activity.DisplayName);
}
foreach (var activity in handles)
{
Assert.Equal("HANDLE TestMessage/OpenTelemetry.Contrib.Instrumentation.MassTransit.Tests", activity.DisplayName);
}
}
public BatchStateMachineTests()
{
_sagaRepository = new InMemorySagaRepository <BatchState>();
_stateMachine = new BatchStateMachine();
_testHarness = new InMemoryTestHarness();
_testHarness.OnConfigureInMemoryReceiveEndpoint += ConfigureInMemoryReceiveEndpoint;
_testHarness.OnConfigureInMemoryBus += ConfigureInMemoryBus;
}
