private static async Task <ActivityResult <ProducerResult> > RunProducerActivityAsync <T>(
string functionName,
T item,
IDurableOrchestrationContext context,
ILogger log)
{
try
{
ProducerResult result = await context
.CallActivityWithRetryAsync <ProducerResult>(functionName, RetryOptions, item);
log.LogTrace(string.Format(ConstantStrings.EventCreated, context.InstanceId, functionName, result.Message.Body.Count));
return(new ActivityResult <ProducerResult>
{
Item = result
});
}
catch (FunctionFailedException ex)
{
log.LogError(string.Format(ConstantStrings.FunctionFailed, functionName, ex.Message));
return(new ActivityResult <ProducerResult>
{
Valid = false,
Item = Activator.CreateInstance <ProducerResult>(),
ExceptionMessage = ex.Message
});
}
}
public async Task Command_should_be_produced_by_valid_ingestion_service()
{
var messagesCollectorMock = new Mock <IAsyncCollector <EventData> >();
var loggerMock = new Mock <ILogger>();
messagesCollectorMock
.Setup(x => x.AddAsync(It.IsAny <EventData>(), default))
.Returns(
Task.CompletedTask
);
var command = new DefaultCommand
{
Header = new MessageHeader(Guid.NewGuid().ToString(), nameof(DefaultCommand), nameof(Sources.Orchestrator)),
};
Producer producer = new Producer(messagesCollectorMock.Object, loggerMock.Object);
ProducerResult result = await producer.ProduceCommandWithRetryAsync(command);
ICommandContainer commandContainer = DeserializeEventData(result.Message);
MessageHeader header = GetCommandHeader(commandContainer);
Assert.True(result.Valid);
Assert.NotEqual(header.MessageId, command.Header.MessageId);
Assert.NotEqual(header.CreationDate, command.Header.CreationDate);
Assert.Equal(header.TransactionId, command.Header.TransactionId);
Assert.Equal(header.MessageType, command.Header.MessageType);
Assert.Equal(header.Source, command.Header.Source);
}
public static async Task <ProducerResult> AccountValidationEventProducer(
[EventHub("AccountValidationEventProducerHub", Connection = "EventHubConnectionAppSetting")] IAsyncCollector <string> outputEvents,
[ActivityTrigger] CommandProducer command, ILogger log)
{
ProducerResult result = new ProducerResult();
var commandString = JsonConvert.SerializeObject(command);
byte[] messageBytes = Encoding.UTF8.GetBytes(commandString);
await outputEvents.AddAsync(JsonConvert.SerializeObject(messageBytes));
return(result);
}
public async Task Command_should_not_be_produced_by_invalid_ingestion_service()
{
IAsyncCollector <EventData> messagesCollector = null;
var loggerMock = new Mock <ILogger>();
var command = new DefaultCommand
{
Header = new MessageHeader(Guid.NewGuid().ToString(), nameof(DefaultCommand), nameof(Sources.Orchestrator)),
};
Producer producer = new Producer(messagesCollector, loggerMock.Object);
ProducerResult result = await producer.ProduceCommandWithRetryAsync(command);
Assert.NotNull(result);
Assert.False(result.Valid);
}
public ProducerResult Send(int key, string message)
{
using (var producer = new Producer <int, string>(GetConfig(), new IntSerializer(), new StringSerializer(Encoding.UTF8)))
{
var ret = producer.ProduceAsync(ConfigHelper.Configuration.GetValue <string>("Karafka:topicName"), key, message).Result;
if (ret.Error.HasError)
{
return(ProducerResult.GetError($"Error Code:{ret.Error.Code} Reason: {ret.Error.Reason}"));
}
producer.Flush(TimeSpan.FromSeconds(10));
}
return(ProducerResult.Sucess);
}
public async Task Command_should_not_be_produced_by_unavailable_ingestion_service()
{
var messagesCollectorMock = new Mock <IAsyncCollector <EventData> >();
var loggerMock = new Mock <ILogger>();
var command = new DefaultCommand
{
Header = new MessageHeader(Guid.NewGuid().ToString(), nameof(DefaultCommand), nameof(Sources.Orchestrator)),
};
messagesCollectorMock
.Setup(x => x.AddAsync(It.IsAny <EventData>(), default))
.Returns(
Task.FromException(new Exception())
);
Producer producer = new Producer(messagesCollectorMock.Object, loggerMock.Object);
ProducerResult result = await producer.ProduceCommandWithRetryAsync(command);
Assert.NotNull(result);
Assert.False(result.Valid);
}
