public void Duplicates_should_not_be_generated_for_interface_inheritance_chains()
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Init();
storage.Subscribe(TestClients.ClientA, new[]
{
new MessageType(typeof(ISomeInterface))
});
storage.Subscribe(TestClients.ClientA, new[]
{
new MessageType(typeof(ISomeInterface2))
});
storage.Subscribe(TestClients.ClientA, new[]
{
new MessageType(typeof(ISomeInterface3))
});
var subscriptionsForMessageType = storage.GetSubscriberAddressesForMessage(new[]
{
new MessageType(typeof(ISomeInterface)),
new MessageType(typeof(ISomeInterface2)),
new MessageType(typeof(ISomeInterface3))
});
Assert.AreEqual(1, subscriptionsForMessageType.Count());
}
public async Task No_subscribers_should_be_returned()
{
var persister = new SubscriptionPersister(store);
var subscriptionsForMessageType = await persister.GetSubscriberAddressesForMessage(new[] { MessageTypes.MessageA }, new ContextBag());
Assert.AreEqual(0, subscriptionsForMessageType.Count());
}
public void shouldnt_create_additional_db_rows()
{
using (var store = DocumentStoreBuilder.Build())
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Subscribe(new Address("testEndPoint", "localhost"), new List <MessageType>
{
new MessageType("SomeMessageType", "1.0.0.0")
});
storage.Subscribe(new Address("testEndPoint", "localhost"), new List <MessageType>
{
new MessageType("SomeMessageType", "1.0.0.0")
});
using (var session = store.OpenSession())
{
var subscriptions = session
.Query <Subscription>()
.Customize(c => c.WaitForNonStaleResults())
.Count();
Assert.AreEqual(1, subscriptions);
}
}
}
public void A_subscription_entry_should_be_added_to_the_database()
{
var clientEndpoint = Address.Parse("TestEndpoint");
var messageTypes = new[]
{
new MessageType("MessageType1", "1.0.0.0"),
new MessageType("MessageType2", "1.0.0.0")
};
using (var store = DocumentStoreBuilder.Build())
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
using (var transaction = new TransactionScope())
{
storage.Subscribe(clientEndpoint, messageTypes);
transaction.Complete();
}
using (var session = store.OpenSession())
{
var subscriptions = session
.Query <Subscription>()
.Customize(c => c.WaitForNonStaleResults())
.Count();
Assert.AreEqual(2, subscriptions);
}
}
}
public void Duplicates_should_not_be_generated_for_interface_inheritance_chains()
{
using (var store = DocumentStoreBuilder.Build())
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Init();
storage.Subscribe(TestClients.ClientA, new[]
{
new MessageType(typeof(ISomeInterface))
});
storage.Subscribe(TestClients.ClientA, new[]
{
new MessageType(typeof(ISomeInterface2))
});
storage.Subscribe(TestClients.ClientA, new[]
{
new MessageType(typeof(ISomeInterface3))
});
var subscriptionsForMessageType = storage.GetSubscriberAddressesForMessage(new[]
{
new MessageType(typeof(ISomeInterface)),
new MessageType(typeof(ISomeInterface2)),
new MessageType(typeof(ISomeInterface3))
});
Assert.AreEqual(1, subscriptionsForMessageType.Count());
}
}
public async Task should_ignore_message_version()
{
var subscriberAddress_v1 = "v1@localhost";
var subscriberAddress_v2 = "v2@localhost";
var messageType_v1 = new MessageType("SomeMessageType", "1.0.0.0");
var messageType_v2 = new MessageType("SomeMessageType", "2.0.0.0");
var subscriber_v1 = new Subscriber(subscriberAddress_v1, "some_endpoint_name");
var subscriber_v2 = new Subscriber(subscriberAddress_v2, "another_endpoint_name");
var storage = new SubscriptionPersister(store);
storage.DisableAggressiveCaching = true;
await storage.Subscribe(subscriber_v1, messageType_v1, new ContextBag());
await storage.Subscribe(subscriber_v2, messageType_v2, new ContextBag());
var subscribers_looked_up_by_v1 = (await storage.GetSubscriberAddressesForMessage(new[]
{
messageType_v1
}, new ContextBag())).ToArray();
var subscribers_looked_up_by_v2 = (await storage.GetSubscriberAddressesForMessage(new[]
{
messageType_v2
}, new ContextBag())).ToArray();
Assert.AreEqual(2, subscribers_looked_up_by_v1.Length);
Assert.AreEqual(2, subscribers_looked_up_by_v2.Length);
}
public async Task No_subscribers_should_be_returned()
{
var persister = new SubscriptionPersister(store);
var subscriptionsForMessageType = await persister.GetSubscriberAddressesForMessage(new []{ MessageTypes.MessageA }, new ContextBag());
Assert.AreEqual(0, subscriptionsForMessageType.Count());
}
public async Task At_unsubscribe_time_should_ignore_message_version()
{
var subscriberAddress = "subscriber@localhost";
var endpointName = "endpoint_name";
var messageType_v1 = new MessageType("SomeMessageType", "1.0.0.0");
var messageType_v2 = new MessageType("SomeMessageType", "2.0.0.0");
var subscriber_v1 = new Subscriber(subscriberAddress, endpointName);
var subscriber_v2 = new Subscriber(subscriberAddress, endpointName);
var storage = new SubscriptionPersister(store);
storage.DisableAggressiveCaching = true;
await storage.Subscribe(subscriber_v1, messageType_v1, new ContextBag());
var subscribers = (await storage.GetSubscriberAddressesForMessage(new[]
{
messageType_v1
}, new ContextBag())).ToArray();
Assert.AreEqual(1, subscribers.Length);
await storage.Unsubscribe(subscriber_v2, messageType_v2, new ContextBag());
var subscribers_looked_up_by_v1 = (await storage.GetSubscriberAddressesForMessage(new[]
{
messageType_v1
}, new ContextBag())).ToArray();
Assert.AreEqual(0, subscribers_looked_up_by_v1.Length);
}
public void shouldnt_create_additional_db_rows()
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Subscribe(new Address("testEndPoint", "localhost"), new List<MessageType>
{
new MessageType("SomeMessageType", "1.0.0.0")
});
storage.Subscribe(new Address("testEndPoint", "localhost"), new List<MessageType>
{
new MessageType("SomeMessageType", "1.0.0.0")
});
using (var session = store.OpenSession())
{
var subscriptions = session
.Query<Subscription>()
.Customize(c => c.WaitForNonStaleResults())
.Count();
Assert.AreEqual(1, subscriptions);
}
}
public void A_subscription_entry_should_be_added_to_the_database()
{
var clientEndpoint = Address.Parse("TestEndpoint");
var messageTypes = new[]
{
new MessageType("MessageType1", "1.0.0.0"),
new MessageType("MessageType2", "1.0.0.0")
};
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Subscribe(clientEndpoint, messageTypes);
using (var session = store.OpenSession())
{
var subscriptions = session
.Query<Subscription>()
.Customize(c => c.WaitForNonStaleResults())
.Count();
Assert.AreEqual(2, subscriptions);
}
}
public void SetupContext()
{
var connectionString = ConfigurationManager.ConnectionStrings["MongoDB"].ConnectionString;
_client = new MongoClient(connectionString);
_database = _client.GetDatabase(_databaseName);
_storage = new SubscriptionPersister(_database);
}
public override void SetUp()
{
base.SetUp();
store.Listeners.RegisterListener(new FakeSubscriptionClrType());
store.Listeners.RegisterListener(new SubscriptionV1toV2Converter());
persister = new SubscriptionPersister(store);
}
public void OneTimeSetUp()
{
DatabaseName = "Test_" + DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture);
var subscriptionCollection = ClientProvider.Client.GetDatabase(DatabaseName, MongoPersistence.DefaultDatabaseSettings).GetCollection <EventSubscription>("eventsubscriptions");
var subscriptionPersister = new SubscriptionPersister(subscriptionCollection);
subscriptionPersister.CreateIndexes();
storage = subscriptionPersister;
}
public void SetupContext()
{
var connectionString = AppConfig.MongoDB;
_client = new MongoClient(connectionString);
_database = _client.GetDatabase(_databaseName);
_storage = new SubscriptionPersister(_database);
((IInitializableSubscriptionStorage)_storage).Init();
}
public SubscriptionPersisterTests(BuildSqlVarient sqlVarient)
{
this.sqlVarient = sqlVarient;
dbConnection = GetConnection();
persister = new SubscriptionPersister(
connectionBuilder: dbConnection,
tablePrefix: $"{nameof(SubscriptionPersisterTests)}_",
sqlVarient: sqlVarient.Convert()
);
}
public override void SetUp()
{
base.SetUp();
store.Listeners.RegisterListener(new SubscriptionV1toV2Converter());
persister = new SubscriptionPersister(store);
msgType = new MessageType(typeof(MessageA));
docId = new VersionedSubscriptionIdFormatter().FormatId(msgType);
}
protected override void Setup(FeatureConfigurationContext context)
{
var settings = context.Settings;
settings.EnableFeature<StorageType.Subscriptions>();
var connectionBuilder = settings.GetConnectionBuilder<StorageType.Subscriptions>();
var endpointName = settings.GetTablePrefix<StorageType.Subscriptions>();
var sqlVarient = settings.GetSqlVarient();
var persister = new SubscriptionPersister(connectionBuilder, endpointName, sqlVarient);
context.Container.RegisterSingleton(typeof (ISubscriptionStorage), persister);
}
public void No_subscribers_should_be_returned()
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Init();
var subscriptionsForMessageType = storage.GetSubscriberAddressesForMessage(MessageTypes.MessageA);
Assert.AreEqual(0, subscriptionsForMessageType.Count());
}
public SubscriptionPersisterTests()
{
_dbContext = new TestDbContext();
_mockDbContextFactory = new Mock <INServiceBusDbContextFactory>();
_mockDbContextFactory.Setup(m => m.CreateSubscriptionDbContext()).Returns(new TestDbContext());
_persister = new SubscriptionPersister(_mockDbContextFactory.Object);
_dbContext.Subscriptions.RemoveRange(_dbContext.Subscriptions);
_dbContext.SaveChanges();
}
protected override void Setup(FeatureConfigurationContext context)
{
var settings = context.Settings;
var connectionBuilder = settings.GetConnectionBuilder();
var tablePrefix = settings.GetTablePrefix();
var sqlDialect = settings.GetSqlDialect();
var cacheFor = SubscriptionSettings.GetCacheFor(settings);
var persister = new SubscriptionPersister(connectionBuilder, tablePrefix, sqlDialect, cacheFor);
sqlDialect.ValidateTablePrefix(tablePrefix);
context.Container.RegisterSingleton(typeof(ISubscriptionStorage), persister);
}
public void All_subscription_entries_for_specified_message_types_should_be_removed()
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Subscribe(TestClients.ClientA, MessageTypes.All);
storage.Unsubscribe(TestClients.ClientA, MessageTypes.All);
var clients = storage.GetSubscriberAddressesForMessage(MessageTypes.All);
Assert.IsFalse(clients.Any(a => a == TestClients.ClientA));
}
public void No_subscribers_should_be_returned()
{
using (var store = DocumentStoreBuilder.Build())
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Init();
var subscriptionsForMessageType = storage.GetSubscriberAddressesForMessage(MessageTypes.MessageA);
Assert.AreEqual(0, subscriptionsForMessageType.Count());
}
}
protected override void Setup(FeatureConfigurationContext context)
{
var settings = context.Settings;
settings.EnableFeature <StorageType.Subscriptions>();
var connectionBuilder = settings.GetConnectionBuilder();
var tablePrefix = settings.GetTablePrefix();
var sqlVariant = settings.GetSqlVariant();
var schema = settings.GetSchema();
var cacheFor = SubscriptionSettings.GetCacheFor(settings);
var persister = new SubscriptionPersister(connectionBuilder, tablePrefix, sqlVariant, schema, cacheFor);
ConfigValidation.ValidateTableSettings(sqlVariant, tablePrefix, schema);
context.Container.RegisterSingleton(typeof(ISubscriptionStorage), persister);
}
public async Task All_subscription_entries_for_specified_message_types_should_be_removed()
{
var storage = new SubscriptionPersister(store);
var context = new ContextBag();
await storage.Subscribe(TestClients.ClientA, MessageTypes.MessageA, context);
await storage.Subscribe(TestClients.ClientA, MessageTypes.MessageB, context);
await storage.Unsubscribe(TestClients.ClientA, MessageTypes.MessageA, context);
await storage.Unsubscribe(TestClients.ClientA, MessageTypes.MessageB, context);
var clients = await storage.GetSubscriberAddressesForMessage(new [] { MessageTypes.MessageA, MessageTypes.MessageB }, context);
Assert.IsEmpty(clients);
}
public void All_subscription_entries_for_specified_message_types_should_be_removed()
{
using (var store = DocumentStoreBuilder.Build())
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Subscribe(TestClients.ClientA, MessageTypes.All);
storage.Unsubscribe(TestClients.ClientA, MessageTypes.All);
var clients = storage.GetSubscriberAddressesForMessage(MessageTypes.All);
Assert.IsFalse(clients.Any(a => a == TestClients.ClientA));
}
}
public void The_names_of_all_subscribers_should_be_returned()
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Subscribe(TestClients.ClientA, MessageTypes.MessageA);
storage.Subscribe(TestClients.ClientA, MessageTypes.MessageB);
storage.Subscribe(TestClients.ClientB, MessageTypes.MessageA);
storage.Subscribe(TestClients.ClientA, MessageTypes.MessageAv2);
var subscriptionsForMessageType = storage.GetSubscriberAddressesForMessage(MessageTypes.MessageA);
Assert.AreEqual(2, subscriptionsForMessageType.Count());
Assert.AreEqual(TestClients.ClientA, subscriptionsForMessageType.First());
}
public async Task ShouldReturnSubscriptionsForNewerVersionsOfSameMessageType()
{
var settings = new SettingsHolder();
var subscriptionPersister = new SubscriptionPersister(documentStore, settings, "NServiceBus.Routing.EndpointName", "TestEndpoint", new MessageType[0]);
var v1MessageType = new MessageType(typeof(SampleMessageType).FullName, new Version(1, 0, 0));
var v2MessageType = new MessageType(typeof(SampleMessageType).FullName, new Version(2, 0, 0));
var v2Subscriber = new Subscriber("V2SubscriberAddress", "V2Subscriber");
await subscriptionPersister.Subscribe(v2Subscriber, v2MessageType, new ContextBag());
var foundSubscriptions = await subscriptionPersister.GetSubscriberAddressesForMessage(new[] { v1MessageType }, new ContextBag());
var foundSubscriber = foundSubscriptions.Single();
Assert.AreEqual(v2Subscriber.Endpoint, foundSubscriber.Endpoint);
Assert.AreEqual(v2Subscriber.TransportAddress, foundSubscriber.TransportAddress);
}
public async Task A_subscription_entry_should_be_added_to_the_database()
{
var clientEndpoint = new Subscriber("TestEndpoint", "TestEndpoint");
var storage = new SubscriptionPersister(store);
await storage.Subscribe(clientEndpoint, new MessageType("MessageType1", "1.0.0.0"), new ContextBag());
using (var session = store.OpenAsyncSession())
{
var subscriptions = await session
.Query<Subscription>()
.Customize(c => c.WaitForNonStaleResults())
.CountAsync();
Assert.AreEqual(1, subscriptions);
}
}
public async Task A_subscription_entry_should_be_added_to_the_database()
{
var clientEndpoint = new Subscriber("TestEndpoint", "TestEndpoint");
var storage = new SubscriptionPersister(store);
await storage.Subscribe(clientEndpoint, new MessageType("MessageType1", "1.0.0.0"), new ContextBag());
using (var session = store.OpenAsyncSession())
{
var subscriptions = await session
.Query <Subscription>()
.Customize(c => c.WaitForNonStaleResults())
.CountAsync();
Assert.AreEqual(1, subscriptions);
}
}
public async Task should_not_create_additional_db_rows()
{
var storage = new SubscriptionPersister(store);
await storage.Subscribe(new Subscriber("testEndPoint@localhost", "testEndPoint"), new MessageType("SomeMessageType", "1.0.0.0"), new ContextBag());
await storage.Subscribe(new Subscriber("testEndPoint@localhost", "testEndPoint"), new MessageType("SomeMessageType", "1.0.0.0"), new ContextBag());
using (var session = store.OpenAsyncSession())
{
var subscriptions = await session
.Query <Subscription>()
.Customize(c => c.WaitForNonStaleResults())
.CountAsync();
Assert.AreEqual(1, subscriptions);
}
}
public async Task Duplicates_should_not_be_generated_for_interface_inheritance_chains()
{
var storage = new SubscriptionPersister(store);
var context = new ContextBag();
await storage.Subscribe(TestClients.ClientA, new MessageType(typeof(ISomeInterface)), context);
await storage.Subscribe(TestClients.ClientA, new MessageType(typeof(ISomeInterface2)), context);
await storage.Subscribe(TestClients.ClientA, new MessageType(typeof(ISomeInterface3)), context);
var subscriptionsForMessageType = await storage.GetSubscriberAddressesForMessage(new[]
{
new MessageType(typeof(ISomeInterface)),
new MessageType(typeof(ISomeInterface2)),
new MessageType(typeof(ISomeInterface3))
}, context);
Assert.AreEqual(1, subscriptionsForMessageType.Count());
}
public async Task should_not_create_additional_db_rows()
{
var storage = new SubscriptionPersister(store);
await storage.Subscribe(new Subscriber("testEndPoint@localhost", "testEndPoint"), new MessageType("SomeMessageType", "1.0.0.0"), new ContextBag());
await storage.Subscribe(new Subscriber("testEndPoint@localhost", "testEndPoint"), new MessageType("SomeMessageType", "1.0.0.0"), new ContextBag());
using (var session = store.OpenAsyncSession())
{
var subscriptions = await session
.Query<Subscription>()
.Customize(c => c.WaitForNonStaleResults())
.CountAsync();
Assert.AreEqual(1, subscriptions);
}
}
public void Setup()
{
dbConnection = GetConnection();
tablePrefix = GetTablePrefix();
persister = new SubscriptionPersister(
connectionBuilder: dbConnection,
tablePrefix: $"{tablePrefix}_",
sqlVariant: sqlVariant.Convert(),
schema: schema,
cacheFor: TimeSpan.FromSeconds(10)
);
using (var connection = dbConnection())
{
connection.Open();
connection.ExecuteCommand(SubscriptionScriptBuilder.BuildDropScript(sqlVariant), tablePrefix, schema: schema);
connection.ExecuteCommand(SubscriptionScriptBuilder.BuildCreateScript(sqlVariant), tablePrefix, schema: schema);
}
}
public async Task Duplicates_should_not_be_generated_for_interface_inheritance_chains()
{
var storage = new SubscriptionPersister(store);
var context = new ContextBag();
await storage.Subscribe(TestClients.ClientA, new MessageType(typeof(ISomeInterface)), context);
await storage.Subscribe(TestClients.ClientA, new MessageType(typeof(ISomeInterface2)), context);
await storage.Subscribe(TestClients.ClientA, new MessageType(typeof(ISomeInterface3)), context);
var subscriptionsForMessageType = await storage.GetSubscriberAddressesForMessage(new[]
{
new MessageType(typeof(ISomeInterface)),
new MessageType(typeof(ISomeInterface2)),
new MessageType(typeof(ISomeInterface3))
}, context);
Assert.AreEqual(1, subscriptionsForMessageType.Count());
}
public void SetupContext()
{
var cfg = new Configuration()
.DataBaseIntegration(x =>
{
x.Dialect <SQLiteDialect>();
x.ConnectionString = $"Data Source={Path.GetTempFileName()};Version=3;New=True;";
});
var mapper = new ModelMapper();
mapper.AddMapping <Config.SubscriptionMap>();
cfg.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
new SchemaExport(cfg).Create(false, true);
SessionFactory = cfg.BuildSessionFactory();
storage = new SubscriptionPersister(SessionFactory);
}
public async Task The_names_of_all_subscribers_should_be_returned()
{
var storage = new SubscriptionPersister(store);
var context = new ContextBag();
await storage.Subscribe(TestClients.ClientA, MessageTypes.MessageA, context);
await storage.Subscribe(TestClients.ClientA, MessageTypes.MessageB, context);
await storage.Subscribe(TestClients.ClientB, MessageTypes.MessageA, context);
await storage.Subscribe(TestClients.ClientA, MessageTypes.MessageAv2, context);
var subscriptionsForMessageType = await storage.GetSubscriberAddressesForMessage(new []{ MessageTypes.MessageA }, context);
Assert.AreEqual(2, subscriptionsForMessageType.Count());
Assert.AreEqual(TestClients.ClientA.TransportAddress, subscriptionsForMessageType.ElementAt(0).TransportAddress);
Assert.AreEqual(TestClients.ClientA.Endpoint, subscriptionsForMessageType.ElementAt(0).Endpoint);
Assert.AreEqual(TestClients.ClientB.TransportAddress, subscriptionsForMessageType.ElementAt(1).TransportAddress);
Assert.AreEqual(TestClients.ClientB.Endpoint, subscriptionsForMessageType.ElementAt(1).Endpoint);
}
public void The_names_of_all_subscribers_should_be_returned()
{
using (var store = DocumentStoreBuilder.Build())
{
var storage = new SubscriptionPersister
{
DocumentStore = store
};
storage.Subscribe(TestClients.ClientA, MessageTypes.MessageA);
storage.Subscribe(TestClients.ClientA, MessageTypes.MessageB);
storage.Subscribe(TestClients.ClientB, MessageTypes.MessageA);
storage.Subscribe(TestClients.ClientA, MessageTypes.MessageAv2);
var subscriptionsForMessageType = storage.GetSubscriberAddressesForMessage(MessageTypes.MessageA);
Assert.AreEqual(2, subscriptionsForMessageType.Count());
Assert.AreEqual(TestClients.ClientA, subscriptionsForMessageType.First());
}
}
SubscriptionPersister Setup(string theSchema)
{
dbConnection = GetConnection();
tablePrefix = GetTablePrefix();
var persister = new SubscriptionPersister(
connectionBuilder: () => dbConnection(theSchema),
tablePrefix: $"{tablePrefix}_",
sqlDialect: sqlDialect.Convert(theSchema),
cacheFor: TimeSpan.FromSeconds(10)
);
using (var connection = dbConnection(theSchema))
{
connection.Open();
connection.ExecuteCommand(SubscriptionScriptBuilder.BuildDropScript(sqlDialect), tablePrefix, schema: theSchema);
connection.ExecuteCommand(SubscriptionScriptBuilder.BuildCreateScript(sqlDialect), tablePrefix, schema: theSchema);
}
return(persister);
}
public async Task should_overwrite_existing_subscription()
{
const string subscriberAddress = "testEndPoint@localhost";
var messageType = new MessageType("SomeMessageType", "1.0.0.0");
var subscriber_v6 = new Subscriber(subscriberAddress, "endpoint_name");
var subscriber_v6_2 = new Subscriber(subscriberAddress, "new_endpoint_name");
var storage = new SubscriptionPersister(store);
await storage.Subscribe(subscriber_v6, messageType, new ContextBag());
await storage.Subscribe(subscriber_v6_2, messageType, new ContextBag());
var subscriber = (await storage.GetSubscriberAddressesForMessage(new[]
{
messageType
}, new ContextBag())).ToArray();
Assert.AreEqual(1, subscriber.Length);
Assert.AreEqual(subscriberAddress, subscriber[0].TransportAddress);
Assert.AreEqual("new_endpoint_name", subscriber[0].Endpoint);
}
protected override void Setup(FeatureConfigurationContext context)
{
var settings = context.Settings;
var connectionManager = settings.GetConnectionBuilder <StorageType.Subscriptions>();
var tablePrefix = settings.GetTablePrefix();
var sqlDialect = settings.GetSqlDialect();
var cacheFor = SubscriptionSettings.GetCacheFor(settings);
var persister = new SubscriptionPersister(connectionManager, tablePrefix, sqlDialect, cacheFor);
sqlDialect.ValidateTablePrefix(tablePrefix);
settings.AddStartupDiagnosticsSection("NServiceBus.Persistence.Sql.Subscriptions",
new
{
EntriesCashedFor = cacheFor,
CustomConnectionBuilder = settings.HasSetting($"SqlPersistence.ConnectionManager.{typeof(StorageType.Subscriptions).Name}")
});
context.Container.RegisterSingleton(typeof(ISubscriptionStorage), persister);
}
public async Task SetupContext()
{
var cfg = new Configuration()
.DataBaseIntegration(x =>
{
x.Dialect <MsSql2012Dialect>();
x.ConnectionString = Consts.SqlConnectionString;
});
var mapper = new ModelMapper();
mapper.AddMapping <Config.SubscriptionMap>();
cfg.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
schema = new SchemaExport(cfg);
await schema.CreateAsync(false, true);
SessionFactory = cfg.BuildSessionFactory();
storage = new SubscriptionPersister(SessionFactory);
}
public async Task should_overwrite_existing_subscription()
{
const string subscriberAddress = "testEndPoint@localhost";
var messageType = new MessageType("SomeMessageType", "1.0.0.0");
var subscriber_v6 = new Subscriber(subscriberAddress, "endpoint_name");
var subscriber_v6_2 = new Subscriber(subscriberAddress, "new_endpoint_name");
var storage = new SubscriptionPersister(store);
await storage.Subscribe(subscriber_v6, messageType, new ContextBag());
await storage.Subscribe(subscriber_v6_2, messageType, new ContextBag());
var subscriber = (await storage.GetSubscriberAddressesForMessage(new[]
{
messageType
}, new ContextBag())).ToArray();
Assert.AreEqual(1, subscriber.Length);
Assert.AreEqual(subscriberAddress, subscriber[0].TransportAddress);
Assert.AreEqual("new_endpoint_name", subscriber[0].Endpoint);
}
public async Task Should_store_schema_version()
{
// arrange
var subscriber = new Subscriber("SomeTransportAddress", "SomeEndpoint");
var storage = new SubscriptionPersister(store);
// act
await storage.Subscribe(subscriber, new MessageType("MessageType1", "1.0.0.0"), new ContextBag());
WaitForIndexing();
// assert
using (var session = store.OpenAsyncSession())
{
var subscription = await session
.Query <Subscription>()
.SingleOrDefaultAsync();
var metadata = session.Advanced.GetMetadataFor(subscription);
Assert.AreEqual(Subscription.SchemaVersion, metadata[SchemaVersionExtensions.SubscriptionSchemaVersionMetadataKey]);
}
}
public async Task The_names_of_all_subscribers_should_be_returned()
{
var storage = new SubscriptionPersister(store);
var context = new ContextBag();
await storage.Subscribe(TestClients.ClientA, MessageTypes.MessageA, context);
await storage.Subscribe(TestClients.ClientA, MessageTypes.MessageB, context);
await storage.Subscribe(TestClients.ClientB, MessageTypes.MessageA, context);
await storage.Subscribe(TestClients.ClientA, MessageTypes.MessageAv2, context);
var subscriptionsForMessageType = await storage.GetSubscriberAddressesForMessage(new [] { MessageTypes.MessageA }, context);
Assert.AreEqual(2, subscriptionsForMessageType.Count());
Assert.AreEqual(TestClients.ClientA.TransportAddress, subscriptionsForMessageType.ElementAt(0).TransportAddress);
Assert.AreEqual(TestClients.ClientA.Endpoint, subscriptionsForMessageType.ElementAt(0).Endpoint);
Assert.AreEqual(TestClients.ClientB.TransportAddress, subscriptionsForMessageType.ElementAt(1).TransportAddress);
Assert.AreEqual(TestClients.ClientB.Endpoint, subscriptionsForMessageType.ElementAt(1).Endpoint);
}
