/// <summary>
/// Register for publishing messages to SNS
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public IHaveFulfilledPublishRequirements WithSnsMessagePublisher <T>() where T : Message
{
Log.Info("Adding SNS publisher");
_subscriptionConfig.Topic = GetMessageTypeName <T>();
var namingStrategy = GetNamingStrategy();
Bus.SerialisationRegister.AddSerialiser <T>(_serialisationFactory.GetSerialiser <T>());
var topicName = namingStrategy.GetTopicName(_subscriptionConfig.BaseTopicName, GetMessageTypeName <T>());
foreach (var region in Bus.Config.Regions)
{
var eventPublisher = new SnsTopicByName(
topicName,
_awsClientFactoryProxy.GetAwsClientFactory().GetSnsClient(RegionEndpoint.GetBySystemName(region)),
Bus.SerialisationRegister);
if (!eventPublisher.Exists())
{
eventPublisher.Create();
}
Bus.AddMessagePublisher <T>(eventPublisher, region);
}
Log.Info(string.Format("Created SNS topic publisher - Topic: {0}", _subscriptionConfig.Topic));
return(this);
}
private protected override async Task <SnsTopicByName> CreateSystemUnderTestAsync()
{
var topic = new SnsTopicByName("TopicName", Sns, _serializationRegister, Substitute.For <ILoggerFactory>(), new NonGenericMessageSubjectProvider());
await topic.ExistsAsync();
return(topic);
}
public SqsQueueByName VerifyOrCreateQueue(string region, IMessageSerialisationRegister serialisationRegister, SqsConfiguration queueConfig)
{
var sqsclient = AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint.GetBySystemName(region));
var snsclient = AWSClientFactory.CreateAmazonSimpleNotificationServiceClient(RegionEndpoint.GetBySystemName(region));
var queue = new SqsQueueByName(queueConfig.QueueName, sqsclient, queueConfig.RetryCountBeforeSendingToErrorQueue);
var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister);
if (!queue.Exists())
queue.Create(queueConfig.MessageRetentionSeconds, 0, queueConfig.VisibilityTimeoutSeconds, queueConfig.ErrorQueueOptOut, queueConfig.RetryCountBeforeSendingToErrorQueue);
//Create an error queue for existing queues if they don't already have one
if(queue.ErrorQueue != null && !queue.ErrorQueue.Exists())
queue.ErrorQueue.Create(JustSayingConstants.MAXIMUM_RETENTION_PERIOD, JustSayingConstants.DEFAULT_CREATE_REATTEMPT, JustSayingConstants.DEFAULT_VISIBILITY_TIMEOUT, errorQueueOptOut: true);
queue.UpdateRedrivePolicy(new RedrivePolicy(queueConfig.RetryCountBeforeSendingToErrorQueue, queue.ErrorQueue.Arn));
if (!eventTopic.Exists())
eventTopic.Create();
if (!eventTopic.IsSubscribed(queue))
eventTopic.Subscribe(queue);
if (!queue.HasPermission(eventTopic))
queue.AddPermission(eventTopic);
return queue;
}
/// <summary>
/// Register for publishing messages to SNS
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public IHaveFulfilledPublishRequirements WithSnsMessagePublisher <T>() where T : Message
{
_log.LogInformation("Adding SNS publisher");
_subscriptionConfig.Topic = GetMessageTypeName <T>();
var namingStrategy = GetNamingStrategy();
Bus.SerialisationRegister.AddSerialiser <T>(_serialisationFactory.GetSerialiser <T>());
var topicName = namingStrategy.GetTopicName(_subscriptionConfig.BaseTopicName, GetMessageTypeName <T>());
foreach (var region in Bus.Config.Regions)
{
// TODO pass region down into topic creation for when we have foreign topics so we can generate the arn
var eventPublisher = new SnsTopicByName(
topicName,
_awsClientFactoryProxy.GetAwsClientFactory().GetSnsClient(RegionEndpoint.GetBySystemName(region)),
Bus.SerialisationRegister,
_loggerFactory);
if (!eventPublisher.Exists())
{
eventPublisher.Create();
}
eventPublisher.EnsurePolicyIsUpdated(Bus.Config.AdditionalSubscriberAccounts);
Bus.AddMessagePublisher <T>(eventPublisher, region);
}
_log.LogInformation($"Created SNS topic publisher - Topic: {_subscriptionConfig.Topic}");
return(this);
}
public async Task <SqsQueueByName> EnsureTopicExistsWithQueueSubscribedAsync(string region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig, IMessageSubjectProvider messageSubjectProvider)
{
var regionEndpoint = RegionEndpoint.GetBySystemName(region);
var sqsClient = _awsClientFactory.GetAwsClientFactory().GetSqsClient(regionEndpoint);
var snsClient = _awsClientFactory.GetAwsClientFactory().GetSnsClient(regionEndpoint);
var queue = await EnsureQueueExistsAsync(region, queueConfig).ConfigureAwait(false);
if (TopicExistsInAnotherAccount(queueConfig))
{
var arnProvider = new ForeignTopicArnProvider(regionEndpoint, queueConfig.TopicSourceAccount, queueConfig.PublishEndpoint);
var topicArn = await arnProvider.GetArnAsync().ConfigureAwait(false);
await SubscribeQueueAndApplyFilterPolicyAsync(snsClient, topicArn, sqsClient, queue.Uri, queueConfig.FilterPolicy).ConfigureAwait(false);
}
else
{
var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsClient, serialisationRegister, _loggerFactory, messageSubjectProvider);
await eventTopic.CreateAsync().ConfigureAwait(false);
await SubscribeQueueAndApplyFilterPolicyAsync(snsClient, eventTopic.Arn, sqsClient, queue.Uri, queueConfig.FilterPolicy).ConfigureAwait(false);
await SqsPolicy.SaveAsync(eventTopic.Arn, queue.Arn, queue.Uri, sqsClient).ConfigureAwait(false);
}
return(queue);
}
public async Task Then_An_Exception_Is_Not_Thrown()
{
// Arrange
string topicName = Guid.NewGuid().ToString();
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var subjectProvider = new NonGenericMessageSubjectProvider();
var serializationRegister = new MessageSerializationRegister(subjectProvider);
var client = clientFactory.GetSnsClient(Region);
var topic = new SnsTopicByName(
topicName,
client,
serializationRegister,
loggerFactory,
subjectProvider);
// Act and Assert
(await topic.CreateAsync()).ShouldBeTrue();
(await topic.CreateAsync()).ShouldBeTrue();
topic.Arn.ShouldNotBeNull();
topic.Arn.ShouldEndWith(topic.TopicName);
}
/// <summary>
/// Register for publishing messages to SNS
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public IHaveFulfilledPublishRequirements WithSnsMessagePublisher <T>() where T : Message
{
Log.Info("Adding SNS publisher");
_subscriptionConfig.Topic = typeof(T).ToTopicName();
var publishEndpointProvider = CreatePublisherEndpointProvider(_subscriptionConfig);
Bus.SerialisationRegister.AddSerialiser <T>(_serialisationFactory.GetSerialiser <T>());
foreach (var region in Bus.Config.Regions)
{
var eventPublisher = new SnsTopicByName(
publishEndpointProvider.GetLocationName(),
AWSClientFactory.CreateAmazonSimpleNotificationServiceClient(RegionEndpoint.GetBySystemName(region)),
Bus.SerialisationRegister);
if (!eventPublisher.Exists())
{
eventPublisher.Create();
}
Bus.AddMessagePublisher <T>(eventPublisher, region);
}
Log.Info(string.Format("Created SNS topic publisher - Topic: {0}", _subscriptionConfig.Topic));
return(this);
}
/// <inheritdoc />
void IPublicationBuilder <T> .Configure(
JustSayingBus bus,
IAwsClientFactoryProxy proxy,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <TopicPublicationBuilder <T> >();
logger.LogInformation("Adding SNS publisher for message type '{MessageType}'.",
typeof(T));
var config = bus.Config;
var readConfiguration = new SqsReadConfiguration(SubscriptionType.ToTopic);
var writeConfiguration = new SnsWriteConfiguration();
ConfigureWrites?.Invoke(writeConfiguration);
readConfiguration.ApplyTopicNamingConvention <T>(config.TopicNamingConvention);
bus.SerializationRegister.AddSerializer <T>();
// TODO pass region down into topic creation for when we have foreign topics so we can generate the arn
var eventPublisher = new SnsTopicByName(
readConfiguration.TopicName,
proxy.GetAwsClientFactory().GetSnsClient(RegionEndpoint.GetBySystemName(config.Region)),
bus.SerializationRegister,
loggerFactory,
writeConfiguration,
config.MessageSubjectProvider)
{
MessageResponseLogger = config.MessageResponseLogger
};
async Task StartupTask()
{
if (writeConfiguration.Encryption != null)
{
await eventPublisher.CreateWithEncryptionAsync(writeConfiguration.Encryption)
.ConfigureAwait(false);
}
else
{
await eventPublisher.CreateAsync().ConfigureAwait(false);
}
await eventPublisher.EnsurePolicyIsUpdatedAsync(config.AdditionalSubscriberAccounts)
.ConfigureAwait(false);
}
bus.AddStartupTask(StartupTask());
bus.AddMessagePublisher <T>(eventPublisher);
logger.LogInformation(
"Created SNS topic publisher on topic '{TopicName}' for message type '{MessageType}'.",
readConfiguration.TopicName,
typeof(T));
}
private protected override Task <SnsTopicByName> CreateSystemUnderTestAsync()
{
var topicByName = new SnsTopicByName("TopicName", Sns, NullLoggerFactory.Instance)
{
Tags = _tags
};
return(Task.FromResult(topicByName));
}
private protected override Task <SnsTopicByName> CreateSystemUnderTestAsync()
{
var topicByName = new SnsTopicByName("TopicName", Sns, Substitute.For <IMessageSerializationRegister>(), Substitute.For <ILoggerFactory>(), new NonGenericMessageSubjectProvider())
{
Tags = _tags
};
return(Task.FromResult(topicByName));
}
public QueueWithAsyncStartup EnsureTopicExistsWithQueueSubscribed(
string region,
SqsReadConfiguration queueConfig)
{
var regionEndpoint = RegionEndpoint.GetBySystemName(region);
var sqsClient = _awsClientFactory.GetAwsClientFactory().GetSqsClient(regionEndpoint);
var snsClient = _awsClientFactory.GetAwsClientFactory().GetSnsClient(regionEndpoint);
var queueWithStartup = EnsureQueueExists(region, queueConfig);
async Task StartupTask(CancellationToken cancellationToken)
{
await queueWithStartup.StartupTask.Invoke(cancellationToken).ConfigureAwait(false);
var queue = queueWithStartup.Queue;
if (TopicExistsInAnotherAccount(queueConfig))
{
var arnProvider = new ForeignTopicArnProvider(regionEndpoint,
queueConfig.TopicSourceAccount,
queueConfig.PublishEndpoint);
var topicArn = await arnProvider.GetArnAsync().ConfigureAwait(false);
await SubscribeQueueAndApplyFilterPolicyAsync(snsClient,
topicArn,
sqsClient,
queue.Uri,
queueConfig.FilterPolicy).ConfigureAwait(false);
}
else
{
#pragma warning disable 618
var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsClient, _loggerFactory);
#pragma warning restore 618
await eventTopic.CreateAsync(cancellationToken).ConfigureAwait(false);
await SubscribeQueueAndApplyFilterPolicyAsync(snsClient,
eventTopic.Arn,
sqsClient,
queue.Uri,
queueConfig.FilterPolicy).ConfigureAwait(false);
var sqsDetails = new SqsPolicyDetails
{
SourceArn = eventTopic.Arn,
QueueArn = queue.Arn,
QueueUri = queue.Uri
};
await SqsPolicy
.SaveAsync(sqsDetails, sqsClient)
.ConfigureAwait(false);
}
}
return(new QueueWithAsyncStartup(StartupTask, queueWithStartup.Queue));
}
private static SnsTopicByName EnsureTopicExists(string region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig)
{
var snsclient = AWSClientFactory.CreateAmazonSimpleNotificationServiceClient(RegionEndpoint.GetBySystemName(region));
var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister);
if (!eventTopic.Exists())
eventTopic.Create();
return eventTopic;
}
public QueueWithAsyncStartup <SqsQueueByName> EnsureTopicExistsWithQueueSubscribed(
string region,
IMessageSerializationRegister serializationRegister,
SqsReadConfiguration queueConfig,
IMessageSubjectProvider messageSubjectProvider)
{
var regionEndpoint = RegionEndpoint.GetBySystemName(region);
var sqsClient = _awsClientFactory.GetAwsClientFactory().GetSqsClient(regionEndpoint);
var snsClient = _awsClientFactory.GetAwsClientFactory().GetSnsClient(regionEndpoint);
var queueWithStartup = EnsureQueueExists(region, queueConfig);
async Task StartupTask()
{
await queueWithStartup.StartupTask.ConfigureAwait(false);
var queue = queueWithStartup.Queue;
if (TopicExistsInAnotherAccount(queueConfig))
{
var arnProvider = new ForeignTopicArnProvider(regionEndpoint,
queueConfig.TopicSourceAccount,
queueConfig.PublishEndpoint);
var topicArn = await arnProvider.GetArnAsync().ConfigureAwait(false);
await SubscribeQueueAndApplyFilterPolicyAsync(snsClient,
topicArn,
sqsClient,
queue.Uri,
queueConfig.FilterPolicy).ConfigureAwait(false);
}
else
{
var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint,
snsClient,
serializationRegister,
_loggerFactory,
messageSubjectProvider);
await eventTopic.CreateAsync().ConfigureAwait(false);
await SubscribeQueueAndApplyFilterPolicyAsync(snsClient,
eventTopic.Arn,
sqsClient,
queue.Uri,
queueConfig.FilterPolicy).ConfigureAwait(false);
await SqsPolicy
.SaveAsync(eventTopic.Arn, queue.Arn, queue.Uri, sqsClient)
.ConfigureAwait(false);
}
}
// This StartupTask is intentionally not awaited, as it will be run when the bus is started.
return(new QueueWithAsyncStartup <SqsQueueByName>(StartupTask(), queueWithStartup.Queue));
}
private static void CreatePublisher(SnsTopicByName eventPublisher, SnsWriteConfiguration snsWriteConfig)
{
if (snsWriteConfig.Encryption != null)
{
eventPublisher.CreateWithEncryptionAsync(snsWriteConfig.Encryption).GetAwaiter().GetResult();
}
else
{
eventPublisher.CreateAsync().GetAwaiter().GetResult();
}
}
protected override async Task <SnsTopicByName> CreateSystemUnderTestAsync()
{
var topic = new SnsTopicByName("TopicName", Sns, _serializationRegister, Substitute.For <ILoggerFactory>(), new SnsWriteConfiguration
{
HandleException = (ex, m) => false
}, Substitute.For <IMessageSubjectProvider>());
await topic.ExistsAsync();
return(topic);
}
protected override async Task When()
{
_topic = new SnsTopicByName(
UniqueName,
Client,
new MessageSerialisationRegister(new NonGenericMessageSubjectProvider()),
LoggerFactory,
new NonGenericMessageSubjectProvider());
_createWasSuccessful = await _topic.CreateAsync();
}
private static void EnsureQueueIsSubscribedToTopic(SnsTopicByName eventTopic, SqsQueueByName queue)
{
if (!eventTopic.IsSubscribed(queue))
{
eventTopic.Subscribe(queue);
}
if (!queue.HasPermission(eventTopic))
{
queue.AddPermission(eventTopic);
}
}
private static SnsTopicByName EnsureTopicExists(string region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig)
{
var snsclient = AWSClientFactory.CreateAmazonSimpleNotificationServiceClient(RegionEndpoint.GetBySystemName(region));
var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister);
if (!eventTopic.Exists())
{
eventTopic.Create();
}
return(eventTopic);
}
protected override async Task When()
{
var snsClient = new NoTopicCreationAwsClientFactory().GetSnsClient(Region);
_topic = new SnsTopicByName(
UniqueName,
snsClient,
new MessageSerializationRegister(new NonGenericMessageSubjectProvider()),
LoggerFactory,
new NonGenericMessageSubjectProvider());
_createWasSuccessful = await _topic.CreateAsync();
}
private protected override async Task <SnsTopicByName> CreateSystemUnderTestAsync()
{
var topic = new SnsTopicByName("TopicName", Sns, _serializationRegister, Substitute.For <ILoggerFactory>(), Substitute.For <SnsWriteConfiguration>(), Substitute.For <IMessageSubjectProvider>())
{
MessageResponseLogger = (r, m) =>
{
_response = r;
_message = m;
}
};
await topic.ExistsAsync();
return(topic);
}
private SnsTopicByName EnsureTopicExists(RegionEndpoint region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig)
{
var snsclient = _awsClientFactory.GetAwsClientFactory().GetSnsClient(region);
var eventTopic = _topicCache.TryGetFromCache(region.SystemName, queueConfig.PublishEndpoint);
if (eventTopic != null)
return eventTopic;
eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister);
_topicCache.AddToCache(region.SystemName, queueConfig.PublishEndpoint, eventTopic);
if (!eventTopic.Exists())
eventTopic.Create();
return eventTopic;
}
public async Task Cannot_Create_Topic_Because_Not_Authorized()
{
// Arrange
string topicName = Guid.NewGuid().ToString();
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAmazonSimpleNotificationService client = CreateSnsClient(exists: false);
var topic = new SnsTopicByName(
topicName,
client,
loggerFactory);
// Act and Assert
await Assert.ThrowsAsync <InvalidOperationException>(() => topic.CreateAsync(CancellationToken.None));
}
public async Task Can_Create_Topic_With_Encryption()
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSnsClient(Region);
var topic = new SnsTopicByName(
UniqueName,
client,
loggerFactory);
// Act
await topic.CreateWithEncryptionAsync(new ServerSideEncryption { KmsMasterKeyId = JustSayingConstants.DefaultSnsAttributeEncryptionKeyId }, CancellationToken.None);
// Assert
topic.ServerSideEncryption.KmsMasterKeyId.ShouldBe(JustSayingConstants.DefaultSnsAttributeEncryptionKeyId);
}
public async Task Arn_Still_Retrieved_When_It_Already_Exists()
{
// Arrange
string topicName = Guid.NewGuid().ToString();
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAmazonSimpleNotificationService client = CreateSnsClient(exists: true);
var topic = new SnsTopicByName(
topicName,
client,
loggerFactory);
// Act
await topic.CreateAsync(CancellationToken.None);
// Assert
topic.Arn.ShouldNotBeNull();
}
private IHaveFulfilledPublishRequirements AddSnsMessagePublisher <T>(Action <SnsWriteConfiguration> configBuilder) where T : Message
{
_log.LogInformation("Adding SNS publisher for message type '{MessageType}'.",
typeof(T));
var snsWriteConfig = new SnsWriteConfiguration();
configBuilder?.Invoke(snsWriteConfig);
_subscriptionConfig.Topic = typeof(T).ToTopicName();
var namingStrategy = GetNamingStrategy();
Bus.SerializationRegister.AddSerializer <T>(_serializationFactory.GetSerializer <T>());
var topicName = namingStrategy.GetTopicName(_subscriptionConfig.BaseTopicName, typeof(T));
foreach (var region in Bus.Config.Regions)
{
// TODO pass region down into topic creation for when we have foreign topics so we can generate the arn
var eventPublisher = new SnsTopicByName(
topicName,
_awsClientFactoryProxy.GetAwsClientFactory().GetSnsClient(RegionEndpoint.GetBySystemName(region)),
Bus.SerializationRegister,
_loggerFactory, snsWriteConfig,
Bus.Config.MessageSubjectProvider)
{
MessageResponseLogger = Bus.Config.MessageResponseLogger
};
eventPublisher.CreateAsync().GetAwaiter().GetResult();
eventPublisher.EnsurePolicyIsUpdatedAsync(Bus.Config.AdditionalSubscriberAccounts).GetAwaiter().GetResult();
Bus.AddMessagePublisher <T>(eventPublisher, region);
}
_log.LogInformation("Created SNS topic publisher on topic '{TopicName}' for message type '{MessageType}'.",
_subscriptionConfig.Topic, typeof(T));
return(this);
}
private SnsTopicByName EnsureTopicExists(RegionEndpoint region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig)
{
var snsclient = _awsClientFactory.GetAwsClientFactory().GetSnsClient(region);
var eventTopic = _topicCache.TryGetFromCache(region.SystemName, queueConfig.PublishEndpoint);
if (eventTopic != null)
{
return(eventTopic);
}
eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister);
_topicCache.AddToCache(region.SystemName, queueConfig.PublishEndpoint, eventTopic);
if (!eventTopic.Exists())
{
eventTopic.Create();
}
return(eventTopic);
}
public async Task Cannot_Create_Topic_Because_Not_Authorized()
{
// Arrange
string topicName = Guid.NewGuid().ToString();
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
var subjectProvider = new NonGenericMessageSubjectProvider();
var serializationRegister = new MessageSerializationRegister(subjectProvider);
IAmazonSimpleNotificationService client = CreateSnsClient(exists: false);
var topic = new SnsTopicByName(
topicName,
client,
serializationRegister,
loggerFactory,
subjectProvider);
// Act and Assert
await Assert.ThrowsAsync <InvalidOperationException>(() => topic.CreateAsync());
}
public async Task Then_An_Exception_Is_Not_Thrown()
{
// Arrange
string topicName = Guid.NewGuid().ToString();
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSnsClient(Region);
var topic = new SnsTopicByName(
topicName,
client,
loggerFactory);
// Shouldn't throw
await topic.CreateAsync(CancellationToken.None);
await topic.CreateAsync(CancellationToken.None);
topic.Arn.ShouldNotBeNull();
topic.Arn.ShouldEndWith(topic.TopicName);
}
public async Task Can_Update_Encryption_For_Existing_Topic()
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSnsClient(Region);
var topic = new SnsTopicByName(
UniqueName,
client,
null,
loggerFactory,
null);
await topic.CreateWithEncryptionAsync(new ServerSideEncryption { KmsMasterKeyId = "previousKeyId" });
// Act
await topic.CreateWithEncryptionAsync(new ServerSideEncryption { KmsMasterKeyId = JustSayingConstants.DefaultSnsAttributeEncryptionKeyId });
// Assert
topic.ServerSideEncryption.KmsMasterKeyId.ShouldBe(JustSayingConstants.DefaultSnsAttributeEncryptionKeyId);
}
public async Task Can_Remove_Encryption()
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSnsClient(Region);
var topic = new SnsTopicByName(
UniqueName,
client,
null,
loggerFactory,
null);
await topic.CreateWithEncryptionAsync(new ServerSideEncryption { KmsMasterKeyId = JustSayingConstants.DefaultSnsAttributeEncryptionKeyId });
// Act
await topic.CreateWithEncryptionAsync(new ServerSideEncryption { KmsMasterKeyId = String.Empty });
// Assert
topic.ServerSideEncryption.ShouldBeNull();
}
private void EnsureQueueIsSubscribedToTopic(RegionEndpoint region, SnsTopicByName eventTopic, SqsQueueByName queue)
{
var sqsclient = _awsClientFactory.GetAwsClientFactory().GetSqsClient(region);
eventTopic.Subscribe(sqsclient, queue);
}
protected override void When()
{
_topic = new SnsTopicByName(UniqueName, Bus, new MessageSerialisationRegister(new NonGenericMessageSubjectProvider()), new LoggerFactory(), new NonGenericMessageSubjectProvider());
_createWasSuccessful = _topic.CreateAsync().GetAwaiter().GetResult();
}
private async Task <bool> EnsureQueueIsSubscribedToTopic(SnsTopicByName eventTopic, SqsQueueByName queue)
{
return(await eventTopic.SubscribeAsync(queue).ConfigureAwait(false));
}
private void EnsureQueueIsSubscribedToTopic(RegionEndpoint region, SnsTopicByName eventTopic, SqsQueueByName queue)
{
var sqsclient = _awsClientFactory.GetAwsClientFactory().GetSqsClient(region);
eventTopic.Subscribe(sqsclient, queue);
}
private static void EnsureQueueIsSubscribedToTopic(string region, SnsTopicByName eventTopic, SqsQueueByName queue)
{
var sqsclient = AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint.GetBySystemName(region));
eventTopic.Subscribe(sqsclient, queue);
}
