public RabbitMQMessagePublisher(IRabbitMQConnectionFactory connectionFactory,
IOptions <RabbitMQPublisherOptions <T> > config, ICloudEventFormatter cloudEventFormatter)
{
_connectionFactory = connectionFactory;
_cloudEventFormatter = cloudEventFormatter;
_options = config.Value;
}
public void UpdateAndExtractCloudEvent_V0_6_0Header_ExtensionsAddedToCloudEvent()
{
var channel = _fixture.Connection.CreateModel();
var basicProperties = channel.CreateBasicProperties();
var publisherOptions = new RabbitMQPublisherOptions <byte[]>();
var content = new byte[] { 1, 2, 3 };
var inputCloudEvent = MotorCloudEvent.CreateTestCloudEvent(content);
var mockedApplicationNameService = Mock.Of <IApplicationNameService>();
basicProperties.SetPriority(inputCloudEvent, publisherOptions);
basicProperties.WriteCloudEventIntoHeader(inputCloudEvent);
// manipulate basic properties to simulate outdated version
basicProperties.Headers.Remove($"{BasicPropertiesExtensions.CloudEventPrefix}{MotorVersionExtension.MotorVersionAttribute.Name}");
basicProperties.ContentEncoding = null;
basicProperties.Headers.Add(
$"{BasicPropertiesExtensions.CloudEventPrefix}{CloudEventsSpecVersion.V1_0.DataContentTypeAttribute.Name}",
Encoding.UTF8.GetBytes($"{basicProperties.ContentType}"));
foreach (var(key, value) in basicProperties.Headers)
{
if (value is byte[] byteValue)
{
basicProperties.Headers[key] = EscapeWithQuotes(byteValue);
}
}
var outputCloudEvent = basicProperties.ExtractCloudEvent(mockedApplicationNameService,
new ReadOnlyMemory <byte>(content));
Assert.Equal(MotorCloudEventInfo.RequiredAttributes(Version.Parse("0.6.0.0")).Count(),
outputCloudEvent.GetPopulatedAttributes().Count());
foreach (var requiredAttribute in MotorCloudEventInfo.RequiredAttributes(Version.Parse("0.6.0.0")))
{
Assert.Equal(inputCloudEvent[requiredAttribute], outputCloudEvent[requiredAttribute]);
}
}
public static void Update <T>(this IBasicProperties self, MotorCloudEvent <byte[]> cloudEvent,
RabbitMQPublisherOptions <T> options, ICloudEventFormatter cloudEventFormatter)
{
var messagePriority = cloudEvent.Extension <RabbitMQPriorityExtension>()?.Priority ??
options.DefaultPriority;
if (messagePriority.HasValue)
{
self.Priority = messagePriority.Value;
}
var dictionary = new Dictionary <string, object>();
foreach (var attr in cloudEvent.GetAttributes())
{
if (string.Equals(attr.Key, CloudEventAttributes.DataAttributeName(cloudEvent.SpecVersion)) ||
string.Equals(attr.Key,
CloudEventAttributes.DataContentTypeAttributeName(cloudEvent.SpecVersion)) ||
string.Equals(attr.Key, RabbitMQPriorityExtension.PriorityAttributeName) ||
string.Equals(attr.Key, RabbitMQBindingExtension.ExchangeAttributeName) ||
string.Equals(attr.Key, RabbitMQBindingExtension.RoutingKeyAttributeName))
{
continue;
}
dictionary.Add($"{CloudEventPrefix}{attr.Key}",
cloudEventFormatter.EncodeAttribute(cloudEvent.SpecVersion, attr.Key, attr.Value,
cloudEvent.GetExtensions().Values));
}
self.Headers = dictionary;
}
public void Update_NoExtensions_OnlyRequiredAttributesInHeader()
{
var channel = _fixture.Connection.CreateModel();
var basicProperties = channel.CreateBasicProperties();
var publisherOptions = new RabbitMQPublisherOptions <byte[]>();
var cloudEvent = MotorCloudEvent.CreateTestCloudEvent(Array.Empty <byte>());
basicProperties.SetPriority(cloudEvent, publisherOptions);
basicProperties.WriteCloudEventIntoHeader(cloudEvent);
VerifyPresenceOfRequiredAttributes(basicProperties, cloudEvent);
}
public RabbitMQMessagePublisher(
IRabbitMQConnectionFactory <TOutput> connectionFactory,
IOptions <RabbitMQPublisherOptions <TOutput> > config,
IOptions <PublisherOptions> publisherOptions,
CloudEventFormatter cloudEventFormatter
)
{
ConnectionFactory = connectionFactory;
_options = config.Value;
_publisherOptions = publisherOptions.Value;
_cloudEventFormatter = cloudEventFormatter;
}
public void BindPublisherOptions_ConfigWithTarget_ContainsPublishingTarget()
{
var options = GetJsonOptions("publisher-with-target");
var publisherOptions = new RabbitMQPublisherOptions <string>();
options.Bind(publisherOptions);
Assert.NotNull(publisherOptions.PublishingTarget);
Assert.Equal("exchange", publisherOptions.PublishingTarget.Exchange);
Assert.Equal("routing", publisherOptions.PublishingTarget.RoutingKey);
Assert.Equal("teststring", publisherOptions.PublishingTarget.Arguments["string"]);
}
private ITypedMessagePublisher <byte[]> GetPublisher(
IRabbitMQConnectionFactory connectionFactory = null,
RabbitMQPublisherOptions <string> options = null)
{
connectionFactory ??= GetDefaultConnectionFactoryMock().Object;
options ??= GetConfig();
var configMock = new Mock <IOptions <RabbitMQPublisherOptions <string> > >();
configMock.Setup(x => x.Value).Returns(options);
return(new RabbitMQMessagePublisher <string>(connectionFactory, configMock.Object, new JsonEventFormatter()));
}
public void BindPublisherOptions_ConfigWithoutQueue_ContainsAllValues()
{
var config = GetJsonOptions("publisher-no-target");
var publisherConfig = new RabbitMQPublisherOptions <string>();
config.Bind(publisherConfig);
Assert.Equal("hostname", publisherConfig.Host);
Assert.Equal(10000, publisherConfig.Port);
Assert.Equal("username", publisherConfig.User);
Assert.Equal("password", publisherConfig.Password);
Assert.Equal("vhost", publisherConfig.VirtualHost);
}
public void FromPublisherConfig_NullPublishingTarget_Throws()
{
var factory = new RabbitMQConnectionFactory();
var cfg = new RabbitMQPublisherOptions<string>
{
Host = "host",
User = "******",
Password = "******",
VirtualHost = "vHost",
PublishingTarget = null
};
Assert.Throws<ArgumentException>(() => factory.From(cfg));
}
public void Update_EncodingExtension_EncodingNotInHeaderInProperties()
{
var channel = _fixture.Connection.CreateModel();
var basicProperties = channel.CreateBasicProperties();
var publisherOptions = new RabbitMQPublisherOptions <byte[]>();
var cloudEvent = MotorCloudEvent.CreateTestCloudEvent(Array.Empty <byte>());
const string encoding = "someEncoding";
cloudEvent.SetEncoding(encoding);
basicProperties.SetPriority(cloudEvent, publisherOptions);
basicProperties.WriteCloudEventIntoHeader(cloudEvent);
Assert.Equal(encoding, basicProperties.ContentEncoding);
VerifyPresenceOfRequiredAttributes(basicProperties, cloudEvent);
}
public void UpdateAndExtractCloudEvent_NoExtensions_CloudEventWithRequiredExtensions()
{
var channel = _fixture.Connection.CreateModel();
var basicProperties = channel.CreateBasicProperties();
var publisherOptions = new RabbitMQPublisherOptions <byte[]>();
var content = new byte[] { 1, 2, 3 };
var inputCloudEvent = MotorCloudEvent.CreateTestCloudEvent(content);
var mockedApplicationNameService = Mock.Of <IApplicationNameService>();
basicProperties.SetPriority(inputCloudEvent, publisherOptions);
basicProperties.WriteCloudEventIntoHeader(inputCloudEvent);
var outputCloudEvent = basicProperties.ExtractCloudEvent(mockedApplicationNameService,
new ReadOnlyMemory <byte>(content));
foreach (var requiredAttribute in MotorCloudEventInfo.RequiredAttributes(CurrentMotorVersion))
{
Assert.Equal(inputCloudEvent[requiredAttribute], outputCloudEvent[requiredAttribute]);
}
}
private IRawMessagePublisher <string> GetPublisher(
IRabbitMQConnectionFactory <string>?factory = null,
RabbitMQPublisherOptions <string>?options = null,
bool overwriteExchange = false,
CloudEventFormat cloudEventFormat = CloudEventFormat.Protocol)
{
options ??= GetConfig(overwriteExchange);
factory ??= GetDefaultConnectionFactoryMock <string>().Object;
var optionsMock = Options.Create(options);
return(new RabbitMQMessagePublisher <string>(
factory,
optionsMock,
Options.Create(new PublisherOptions {
CloudEventFormat = cloudEventFormat
}),
new JsonEventFormatter()
));
}
public void UpdateAndExtractCloudEvent_NoExtensions_CloudEventWithoutSpecificExtensions()
{
var channel = _fixture.Connection.CreateModel();
var basicProperties = channel.CreateBasicProperties();
var publisherOptions = new RabbitMQPublisherOptions <byte[]>();
var content = new byte[] { 1, 2, 3 };
var inputCloudEvent = MotorCloudEvent.CreateTestCloudEvent(content);
var mockedApplicationNameService = Mock.Of <IApplicationNameService>();
basicProperties.SetPriority(inputCloudEvent, publisherOptions);
basicProperties.WriteCloudEventIntoHeader(inputCloudEvent);
var outputCloudEvent = basicProperties.ExtractCloudEvent(mockedApplicationNameService,
new ReadOnlyMemory <byte>(content));
var rabbitSpecificAttributes =
RabbitMQBindingExtension.AllAttributes.Concat(RabbitMQPriorityExtension.AllAttributes);
foreach (var rabbitSpecificAttribute in rabbitSpecificAttributes)
{
Assert.DoesNotContain(rabbitSpecificAttribute, outputCloudEvent.GetPopulatedAttributes().Select(a => a.Key));
}
}
private void ThrowIfConfigInvalid <T>(RabbitMQPublisherOptions <T> options)
{
ThrowIfInvalid(options);
ThrowIfInvalid(options.PublishingTarget);
}
public IConnectionFactory From <T>(RabbitMQPublisherOptions <T> publisherOptions)
{
ThrowIfConfigInvalid(publisherOptions);
return(FromConfig(publisherOptions));
}
