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 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_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); }