#33 Implemented custom IEndpointCollection implementation for Loopbac…

…kConfigration to support sending to arbitrary named endpoints

Source/Platibus.UnitTests/LoopbackTests.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Platibus.Config;
+using Platibus.InMemory;
+using Xunit;
+
+namespace Platibus.UnitTests
+{
+    public class LoopbackTests
+    {
+        protected LoopbackConfiguration Configuration = new LoopbackConfiguration();
+        protected object MessageContent = Guid.NewGuid().ToString();
+        protected SendOptions SendOptions = new SendOptions {ContentType = "text/plain"};
+        protected CancellationTokenSource CancellationSource = new CancellationTokenSource();
+
+        public LoopbackTests()
+        {
+            Configuration.MessageQueueingService = new InMemoryMessageQueueingService();
+        }
+
+        [Theory]
+        [InlineData("loopback")] // Standard loopback endpoint
+        [InlineData("undefined")] // Undefined/unknown endpoint
+        public async Task MessageIsHandledWhenSendingToNamedEndpoint(string endpointName)
+        {
+            var handlerTask = GivenHandler();
+            await WhenSendingToNamedEndpoint(endpointName);
+            var handledContent = await handlerTask;
+            Assert.Equal(MessageContent, handledContent);
+        }
+
+        [Theory]
+        [InlineData("urn:localhost/loopback")] // Standard loopback endpoint address
+        [InlineData("http://localhost/undefined")] // Undefined/unknown endpoint address
+        public async Task MessageIsHandledWhenSendingToEndpointAddress(string address)
+        {
+            var handlerTask = GivenHandler();
+            await WhenSendingToEndpointAddress(new Uri(address));
+            var handledContent = await handlerTask;
+            Assert.Equal(MessageContent, handledContent);
+        }
+
+        protected Task<object> GivenHandler()
+        {
+            var handlerCompletionSource = new TaskCompletionSource<object>();
+            CancellationSource.Token.Register(() => handlerCompletionSource.TrySetCanceled());
+            Configuration.AddHandlingRule<object>(".*", (content, ctx) =>
+                {
+                    handlerCompletionSource.TrySetResult(content);
+                    ctx.Acknowledge();
+                });
+            return handlerCompletionSource.Task;
+        }
+
+        protected async Task WhenSendingToNamedEndpoint(EndpointName endpointName)
+        {
+            var host = LoopbackHost.Start(Configuration, CancellationSource.Token);
+            await host.Bus.Send(MessageContent, endpointName, SendOptions, CancellationSource.Token);
+        }
+
+        protected async Task WhenSendingToEndpointAddress(Uri endpointAddress)
+        {
+            var host = LoopbackHost.Start(Configuration, CancellationSource.Token);
+            await host.Bus.Send(MessageContent, endpointAddress, SendOptions, CancellationSource.Token);
+        }
+    }
+}

Source/Platibus/Bus.cs

@@ -90,7 +90,7 @@ public Bus(IPlatibusConfiguration configuration, Uri baseUri, ITransportService
                 configuration.SerializationService,
                 configuration.DefaultContentType);
 
-            _endpoints = new ReadOnlyEndpointCollection(configuration.Endpoints);
+            _endpoints = configuration.Endpoints ?? EndpointCollection.Empty;
             _topics = configuration.Topics.ToList();
             _sendRules = configuration.SendRules.ToList();
             _handlingRules = configuration.HandlingRules.ToList();

Source/Platibus/Config/LoopbackConfiguration.cs

@@ -32,53 +32,44 @@ namespace Platibus.Config
     /// </summary>
     public class LoopbackConfiguration : PlatibusConfiguration, ILoopbackConfiguration
     {
-        private readonly EndpointName _loopbackEndpoint;
+        private static readonly EndpointName LoopbackEndpoint = "loopback";
+        private static readonly Uri LoopbackUri = new Uri("urn:localhost/loopback");
 
         /// <inheritdoc />
-        public Uri BaseUri { get; }
+        public Uri BaseUri => LoopbackUri;
 
         /// <inheritdoc />
         public IMessageQueueingService MessageQueueingService { get; set; }
 
+        /// <inheritdoc />
+        /// <summary>
+        /// Initializes a new <see cref="T:Platibus.Config.LoopbackConfiguration" />
+        /// </summary>
+        public LoopbackConfiguration() : this(null)
+        {
+        }
+        /// <inheritdoc />
         /// <inheritdoc />
         /// <summary>
         /// Initializes a new <see cref="T:Platibus.Config.LoopbackConfiguration" /> with a preconfigured
         /// <paramref name="diagnosticService" />
         /// </summary>
         /// <param name="diagnosticService">(Optional) The service through which diagnostic events
         /// are reported and processed</param>
-        public LoopbackConfiguration(IDiagnosticService diagnosticService = null) : base(diagnosticService)
+        public LoopbackConfiguration(IDiagnosticService diagnosticService) : base(diagnosticService, new LoopbackEndpoints(LoopbackEndpoint, LoopbackUri))
         {
-            _loopbackEndpoint = new EndpointName("looback");
-            BaseUri = new Uri("urn:localhost/loopback");
-            base.AddEndpoint(_loopbackEndpoint, new Endpoint(BaseUri));
             var allMessages = new MessageNamePatternSpecification(".*");
-            base.AddSendRule(new SendRule(allMessages, _loopbackEndpoint));
+            base.AddSendRule(new SendRule(allMessages, LoopbackEndpoint));
         }
-
+        /// <summary>
         /// <inheritdoc />
         public override void AddTopic(TopicName topic)
         {
             base.AddTopic(topic);
-            base.AddSubscription(new Subscription(_loopbackEndpoint, topic));
-        }
-
-        /// <inheritdoc />
-        public override void AddEndpoint(EndpointName name, IEndpoint endpoint)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <inheritdoc />
-        public override void AddSendRule(ISendRule sendRule)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <inheritdoc />
-        public override void AddSubscription(ISubscription subscription)
-        {
-            throw new NotSupportedException();
+            AddSubscription(new Subscription(LoopbackEndpoint, topic));
         }
+        /// </remarks>
+        /// </remarks>
+        /// </remarks>
     }
 }

Source/Platibus/Config/PlatibusConfiguration.cs

@@ -28,8 +28,9 @@
 
 namespace Platibus.Config
 {
+    /// <inheritdoc />
     /// <summary>
-    /// Concrete mutable implementation of <see cref="IPlatibusConfiguration" /> used for
+    /// Concrete mutable implementation of <see cref="T:Platibus.Config.IPlatibusConfiguration" /> used for
     /// programmatically configuring the bus.
     /// </summary>
     /// <remarks>
@@ -39,7 +40,7 @@ namespace Platibus.Config
     /// </remarks>
     public class PlatibusConfiguration : IPlatibusConfiguration
     {
-        private readonly EndpointCollection _endpoints = new EndpointCollection();
+        private readonly EndpointCollection _endpoints;
         private readonly IList<IHandlingRule> _handlingRules = new List<IHandlingRule>();
         private readonly IList<ISendRule> _sendRules = new List<ISendRule>();
         private readonly IList<ISubscription> _subscriptions = new List<ISubscription>();
@@ -81,23 +82,49 @@ public class PlatibusConfiguration : IPlatibusConfiguration
         /// <inheritdoc />
         public SendOptions DefaultSendOptions { get; set; }
 
+        /// <inheritdoc />
+        /// <summary>
+        /// Initializes a new <see cref="T:Platibus.Config.PlatibusConfiguration" />
+        /// </summary>
+        public PlatibusConfiguration() : this(null, null)
+        {
+        }
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Initializes a new <see cref="T:Platibus.Config.PlatibusConfiguration" /> with a preconfigured
+        /// <paramref name="diagnosticService" />
+        /// </summary>
+        /// <param name="diagnosticService">(Optional) The service through which diagnostic events
+        /// are reported and processed</param>
+        /// <remarks>
+        /// If a custom <paramref name="diagnosticService" /> is not specified, then the default
+        /// singleton instance <see cref="F:Platibus.Diagnostics.DiagnosticService.DefaultInstance" /> will 
+        /// be used.
+        /// </remarks>
+        public PlatibusConfiguration(IDiagnosticService diagnosticService) : this(diagnosticService, null)
+        {
+        }
+
         /// <summary>
         /// Initializes a new <see cref="PlatibusConfiguration"/> with a preconfigured
-        /// <paramref name="diagnosticService"/>
+        /// <paramref name="diagnosticService"/> and an initial set of <paramref name="endpoints"/>
         /// </summary>
         /// <param name="diagnosticService">(Optional) The service through which diagnostic events
         /// are reported and processed</param>
+        /// <param name="endpoints">(Optional) An initial set of default endpoints</param>
         /// <remarks>
         /// If a custom <paramref name="diagnosticService"/> is not specified, then the default
         /// singleton instance <see cref="Diagnostics.DiagnosticService.DefaultInstance"/> will 
         /// be used.
         /// </remarks>
-        public PlatibusConfiguration(IDiagnosticService diagnosticService = null)
+        public PlatibusConfiguration(IDiagnosticService diagnosticService, EndpointCollection endpoints)
         {
             MessageNamingService = new DefaultMessageNamingService();
             SerializationService = new DefaultSerializationService();
             DefaultContentType = "application/json";
             DiagnosticService = diagnosticService ?? Diagnostics.DiagnosticService.DefaultInstance;
+            _endpoints = endpoints ?? new EndpointCollection();
         }
 
         /// <summary>

Source/Platibus/EndpointCollection.cs

@@ -28,11 +28,14 @@
 
 namespace Platibus
 {
+    /// <inheritdoc />
     /// <summary>
-    /// A mutable <see cref="IEndpointCollection"/> implementation
+    /// A mutable <see cref="T:Platibus.IEndpointCollection" /> implementation
     /// </summary>
     public class EndpointCollection : IEndpointCollection
     {
+        public static readonly IEndpointCollection Empty = new EndpointCollection();
+
         private readonly IDictionary<EndpointName, IEndpoint> _endpoints = new Dictionary<EndpointName, IEndpoint>();
 
         /// <summary>
@@ -44,21 +47,15 @@ public class EndpointCollection : IEndpointCollection
         /// or <paramref name="endpoint"/> are <c>null</c></exception>
         /// <exception cref="EndpointAlreadyExistsException">Thrown if there is already an
         /// endpoint with the specified <paramref name="endpointName"/></exception>
-        public void Add(EndpointName endpointName, IEndpoint endpoint)
+        public virtual void Add(EndpointName endpointName, IEndpoint endpoint)
         {
             if (endpointName == null) throw new ArgumentNullException(nameof(endpointName));
             if (_endpoints.ContainsKey(endpointName)) throw new EndpointAlreadyExistsException(endpointName);
             _endpoints[endpointName] = endpoint ?? throw new ArgumentNullException(nameof(endpoint));
         }
 
-        /// <summary>
-        /// Returns the endpoint with the specified name
-        /// </summary>
-        /// <param name="endpointName">The name of the endpoint</param>
-        /// <returns>Returns the endpoint</returns>
-        /// <exception cref="EndpointNotFoundException">Thrown if there
-        /// is no endpoint with the specified name</exception>
-        public IEndpoint this[EndpointName endpointName]
+        /// <inheritdoc />
+        public virtual IEndpoint this[EndpointName endpointName]
         {
             get
             {
@@ -70,23 +67,16 @@ public void Add(EndpointName endpointName, IEndpoint endpoint)
             }
         }
 
-        /// <summary>
-        /// Tries to retrieve the endpoint with the specified address
-        /// </summary>
-        /// <param name="address">The address of the endpoint</param>
-        /// <param name="endpoint">An output parameter that will be initialied
-        /// with the endpoint if the endpoint is found</param>
-        /// <returns>Returns <c>true</c> if the endpoint is found; <c>false</c>
-        /// otherwise</returns>
-        public bool TryGetEndpointByAddress(Uri address, out IEndpoint endpoint)
+        /// <inheritdoc />
+        public virtual bool TryGetEndpointByAddress(Uri address, out IEndpoint endpoint)
         {
             var comparer = new EndpointAddressEqualityComparer();
             endpoint = _endpoints.Values.FirstOrDefault(e => comparer.Equals(e.Address, address));
             return endpoint != null;
         }
 
         /// <inheritdoc />
-        public bool Contains(EndpointName endpointName)
+        public virtual bool Contains(EndpointName endpointName)
         {
             return _endpoints.ContainsKey(endpointName);
         }
@@ -96,13 +86,7 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
-        /// <summary>
-        /// Returns an enumerator that iterates through the collection.
-        /// </summary>
-        /// <returns>
-        /// A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
-        /// </returns>
-        /// <filterpriority>1</filterpriority>
+        /// <inheritdoc />
         public IEnumerator<KeyValuePair<EndpointName, IEndpoint>> GetEnumerator()
         {
             return _endpoints.GetEnumerator();

Source/Platibus/Http/HttpTransportService.cs

@@ -71,9 +71,7 @@ public HttpTransportService(HttpTransportServiceOptions options)
             if (options == null) throw new ArgumentNullException(nameof(options));
 
             _baseUri = options.BaseUri.WithTrailingSlash();
-            _endpoints = options.Endpoints == null
-                ? ReadOnlyEndpointCollection.Empty
-                : new ReadOnlyEndpointCollection(options.Endpoints);
+            _endpoints = options.Endpoints = options.Endpoints ?? EndpointCollection.Empty;
 
             _messageQueueingService = options.MessageQueueingService;
             _messageJournal = options.MessageJournal;

Source/Platibus/LoopbackEndpoints.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace Platibus
+{
+    internal class LoopbackEndpoints : EndpointCollection
+    {
+        private readonly Uri _baseUri;
+
+        public LoopbackEndpoints(EndpointName name, Uri baseUri)
+        {
+            _baseUri = baseUri ?? throw new ArgumentNullException(nameof(baseUri));
+            base.Add(name, new Endpoint(baseUri));
+        }
+
+        public override void Add(EndpointName endpointName, IEndpoint endpoint)
+        {
+        }
+
+        public override IEndpoint this[EndpointName endpointName] => new Endpoint(_baseUri);
+
+        public override bool TryGetEndpointByAddress(Uri address, out IEndpoint endpoint)
+        {
+            endpoint = new Endpoint(_baseUri);
+            return true;
+        }
+
+        public override  bool Contains(EndpointName endpointName)
+        {
+            return true;
+        }
+
+    }
+}