public async Task Handles_Many_Concurrent_Calls_Correctly_Without_Errors()
        {
            var tempDir = GetTempDirectory();
            Log.DebugFormat("Temp directory: {0}", tempDir);

            var fsSubscriptionService = new FilesystemSubscriptionTrackingService(tempDir);
            await fsSubscriptionService.Init();

            var topicNames = Enumerable.Range(0, 10)
                .Select(i => new TopicName("Topic-" + i));

            var subscriptions = topicNames
                .SelectMany(t =>
                    Enumerable.Range(0, 100)
                        .Select(j => new Uri("http://localhost/subscriber-" + j))
                        .Select(s => new
                        {
                            Topic = t,
                            Subscriber = s
                        }))
                .ToList();

            await Task.WhenAll(subscriptions.Select(s => fsSubscriptionService.AddSubscription(s.Topic, s.Subscriber)));

            var subscriptionsByTopic = subscriptions.GroupBy(s => s.Topic);
            foreach (var grouping in subscriptionsByTopic)
            {
                var expectedSubscribers = grouping.Select(g => g.Subscriber).ToList();
                var actualSubscribers = await fsSubscriptionService.GetSubscribers(grouping.Key);
                Assert.That(actualSubscribers, Is.EquivalentTo(expectedSubscribers));
            }
        }
 public Task<ISubscriptionTrackingService> CreateSubscriptionTrackingService(
     SubscriptionTrackingElement configuration)
 {
     var path = configuration.GetString("path");
     var fsTrackingBaseDir = new DirectoryInfo(GetRootedPath(path));
     var fsTrackingService = new FilesystemSubscriptionTrackingService(fsTrackingBaseDir);
     fsTrackingService.Init();
     return Task.FromResult<ISubscriptionTrackingService>(fsTrackingService);
 }
        public FilesystemFixture()
        {
            BaseDirectory = GetTempDirectory();

            var fsQueueingOptions = new FilesystemMessageQueueingOptions
            {
                DiagnosticService = DiagnosticService,
                BaseDirectory     = BaseDirectory
            };

            MessageQueueingService = new FilesystemMessageQueueingService(fsQueueingOptions);
            MessageQueueingService.Init();

            SubscriptionTrackingService = new FilesystemSubscriptionTrackingService(BaseDirectory);
            SubscriptionTrackingService.Init();
        }
        public async Task Subscriber_Should_Not_Be_Returned_After_It_Is_Removed()
        {
            var tempDir = GetTempDirectory();
            Log.DebugFormat("Temp directory: {0}", tempDir);

            var fsSubscriptionService = new FilesystemSubscriptionTrackingService(tempDir);
            await fsSubscriptionService.Init();

            var topic = "topic-0";
            var subscriber = new Uri("http://localhost/platibus");
            await fsSubscriptionService.AddSubscription(topic, subscriber);

            var subscribers = await fsSubscriptionService.GetSubscribers(topic);
            Assert.That(subscribers, Has.Member(subscriber));

            await fsSubscriptionService.RemoveSubscription(topic, subscriber);

            var subscribersAfterRemoval = await fsSubscriptionService.GetSubscribers(topic);
            Assert.That(subscribersAfterRemoval, Has.No.Member(subscriber));
        }
        public async Task Expired_Subscription_Should_Not_Be_Returned()
        {
            var tempDir = GetTempDirectory();
            Log.DebugFormat("Temp directory: {0}", tempDir);

            var fsSubscriptionService = new FilesystemSubscriptionTrackingService(tempDir);
            await fsSubscriptionService.Init();

            var topic = "topic-0";
            var subscriber = new Uri("http://localhost/platibus");
            await fsSubscriptionService.AddSubscription(topic, subscriber, TimeSpan.FromMilliseconds(1));

            await Task.Delay(TimeSpan.FromMilliseconds(100));

            var subscribers = await fsSubscriptionService.GetSubscribers(topic);
            Assert.That(subscribers, Has.No.Member(subscriber));
        }
        public async Task Existing_Subscriptions_Should_Be_Loaded_When_Initializing()
        {
            var tempDir = GetTempDirectory();
            Log.DebugFormat("Temp directory: {0}", tempDir);

            var fsSubscriptionService = new FilesystemSubscriptionTrackingService(tempDir);
            await fsSubscriptionService.Init();

            var topicNames = Enumerable.Range(0, 10)
                .Select(i => new TopicName("Topic-" + i));

            var subscriptions = topicNames
                .SelectMany(t =>
                    Enumerable.Range(0, 100)
                        .Select(j => new Uri("http://localhost/subscriber-" + j))
                        .Select(s => new
                        {
                            Topic = t,
                            Subscriber = s
                        }))
                .ToList();

            await Task.WhenAll(subscriptions.Select(s => fsSubscriptionService.AddSubscription(s.Topic, s.Subscriber)));

            // Next, initialize a new FilesystemSubscriptionService instance
            // with the same directory and observe that the subscriptions
            // are returned as expected.

            var fsSubscriptionService2 = new FilesystemSubscriptionTrackingService(tempDir);
            await fsSubscriptionService2.Init();

            var subscriptionsByTopic = subscriptions.GroupBy(s => s.Topic);
            foreach (var grouping in subscriptionsByTopic)
            {
                var expectedSubscribers = grouping.Select(g => g.Subscriber).ToList();
                var actualSubscribers = await fsSubscriptionService2.GetSubscribers(grouping.Key);
                Assert.That(actualSubscribers, Is.EquivalentTo(expectedSubscribers));
            }
        }