prepare 5.14.2 release (#136)

Author: LaunchDarklyCI

src/LaunchDarkly.ServerSdk/FeatureRequestor.cs

@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using Common.Logging;
 using LaunchDarkly.Client.Interfaces;
+using LaunchDarkly.Client.Utils;
 using LaunchDarkly.Common;
 
 namespace LaunchDarkly.Client
@@ -21,7 +22,7 @@ internal class FeatureRequestor : IFeatureRequestor
 
         internal FeatureRequestor(Configuration config, Uri baseUri)
         {
-            _allUri = new Uri(baseUri.AbsoluteUri + "sdk/latest-all");
+            _allUri = baseUri.AddPath("sdk/latest-all");
             _httpClient = Util.MakeHttpClient(config.HttpRequestConfiguration, ServerSideClientEnvironment.Instance);
             _httpConfig = config.HttpConfiguration;
         }

src/LaunchDarkly.ServerSdk/Integrations/EventProcessorBuilder.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using LaunchDarkly.Client.Interfaces;
+using LaunchDarkly.Client.Utils;
 using LaunchDarkly.Common;
 
 namespace LaunchDarkly.Client.Integrations
@@ -267,8 +268,8 @@ IEventProcessor IEventProcessorFactoryWithDiagnostics.CreateEventProcessor(Confi
                 EventCapacity = _capacity,
                 EventFlushInterval = _flushInterval,
                 EventSamplingInterval = _samplingInterval,
-                EventsUri = new Uri(_baseUri, "bulk"),
-                DiagnosticUri = new Uri(_baseUri, "diagnostic"),
+                EventsUri = _baseUri.AddPath("bulk"),
+                DiagnosticUri = _baseUri.AddPath("diagnostic"),
                 HttpClientTimeout = httpConfig.ConnectTimeout,
                 InlineUsersInEvents = _inlineUsersInEvents,
                 PrivateAttributeNames = _privateAttributes.ToImmutableHashSet(),

src/LaunchDarkly.ServerSdk/StreamProcessor.cs

@@ -5,6 +5,7 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using LaunchDarkly.Client.Interfaces;
+using LaunchDarkly.Client.Utils;
 using LaunchDarkly.Common;
 
 namespace LaunchDarkly.Client
@@ -30,7 +31,7 @@ TimeSpan initialReconnectDelay
             )
         {
             var httpConfig = config.HttpConfiguration;
-            var streamProperties = new StreamProperties(new Uri(baseUri, "/all"),
+            var streamProperties = new StreamProperties(baseUri.AddPath("/all"),
                 HttpMethod.Get, null);
             var streamManagerConfig = new StreamManagerConfigImpl
             {

src/LaunchDarkly.ServerSdk/Utils/UriExtensions.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace LaunchDarkly.Client.Utils
+{
+    internal static class UriExtensions
+    {
+        // This differs from "new Uri(baseUri, path)" in that it always assumes a trailing "/" in
+        // baseUri. For instance, if baseUri is http://hostname/basepath and path is "relativepath",
+        // baseUri.AddPath(path) will return http://hostname/basepath/relativepath, whereas
+        // new Uri(baseUri, path) would return http://hostname/relativepath (since, with no trailing
+        // slash, it would treat "basepath" as the equivalent of a filename rather than the
+        // equivalent of a directory name). We should assume that if an application has specified a
+        // base URL with a non-empty path, the intention is to use that as a prefix for everything.
+        public static Uri AddPath(this Uri baseUri, string path)
+        {
+            var ub = new UriBuilder(baseUri);
+            ub.Path = ub.Path.TrimEnd('/') + "/" + path.TrimStart('/');
+            return ub.Uri;
+        }
+    }
+}

test/LaunchDarkly.ServerSdk.Tests/FeatureRequestorTest.cs

@@ -1,6 +1,7 @@
 using LaunchDarkly.Client;
 using System;
 using System.Collections.Generic;
+using System.Net.Http;
 using System.Threading.Tasks;
 using WireMock;
 using WireMock.Logging;
@@ -23,6 +24,35 @@ private IFeatureRequestor MakeRequestor(FluentMockServer server)
             return new FeatureRequestor(config, new Uri(server.Urls[0]));
         }
 
+        [Theory]
+        [InlineData("", "/sdk/latest-all")]
+        [InlineData("/basepath", "/basepath/sdk/latest-all")]
+        [InlineData("/basepath/", "/basepath/sdk/latest-all")]
+        public async Task GetAllUsesCorrectUriAndMethodAsync(
+            string baseUriExtraPath,
+            string expectedPath
+            )
+        {
+            using (var server = await TestHttpUtils.StartServerAsync())
+            {
+                server.Given(Request.Create().UsingGet())
+                    .RespondWith(Response.Create().WithStatusCode(200).WithBody(AllDataJson));
+
+                var config = Configuration.Builder("key")
+                    .Http(Components.HttpConfiguration().ConnectTimeout(TimeSpan.FromDays(1)))
+                    .Build();
+                var baseUri = new Uri(server.Urls[0] + baseUriExtraPath);
+
+                using (var requestor = new FeatureRequestor(config, baseUri))
+                {
+                    await requestor.GetAllDataAsync();
+
+                    var req = GetLastRequest(server);
+                    Assert.Equal("GET", req.Method.ToUpper());
+                }
+            }
+        }
+
         [Fact]
         public async Task GetAllUsesCorrectUriAndParsesResponseAsync()
         {

test/LaunchDarkly.ServerSdk.Tests/LdClientEndToEndTest.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+using LaunchDarkly.Client;
+using WireMock;
+using WireMock.RequestBuilders;
+using WireMock.ResponseBuilders;
+using Xunit;
+
+namespace LaunchDarkly.Tests
+{
+    public class LdClientEndToEndTest
+    {
+        [Theory]
+        [InlineData("", "")]
+        [InlineData("/", "")]
+        [InlineData("/basepath", "/basepath")]
+        [InlineData("/basepath/", "/basepath")]
+        public async Task EventsAreSentToCorrectEndpointsAsync(
+            string baseUriExtraPath,
+            string expectedBasePath
+            )
+        {
+            using (var server = await TestHttpUtils.StartServerAsync())
+            {
+                var requests = new BlockingCollection<RequestMessage>();
+                server.Given(Request.Create()).RespondWith(Response.Create().WithCallback(req =>
+                {
+                    requests.Add(req);
+                    return new ResponseMessage() { StatusCode = 202 };
+
+                }));
+
+                var baseUri = server.Urls[0].TrimEnd('/') + baseUriExtraPath;
+                var config = Configuration.Builder("key")
+                    .DataSource(Components.ExternalUpdatesOnly)
+                    .Events(Components.SendEvents().BaseUri(new Uri(baseUri)))
+                    .Build();
+
+                using (var client = new LdClient(config))
+                {
+                    client.Identify(User.WithKey("userkey"));
+                    client.Flush();
+
+                    Assert.True(requests.TryTake(out var request1, TimeSpan.FromSeconds(5)));
+                    Assert.True(requests.TryTake(out var request2, TimeSpan.FromSeconds(5)));
+
+                    if (request1.Path.EndsWith("diagnostic"))
+                    {
+                        var temp = request1;
+                        request1 = request2;
+                        request2 = temp;
+                    }
+
+                    Assert.Equal("POST", request1.Method.ToUpper());
+                    Assert.Equal(expectedBasePath + "/bulk", request1.Path);
+
+                    Assert.Equal("POST", request2.Method.ToUpper());
+                    Assert.Equal(expectedBasePath + "/diagnostic", request2.Path);
+                }
+            }
+        }
+    }
+}

test/LaunchDarkly.ServerSdk.Tests/StreamProcessorTest.cs

@@ -40,15 +40,18 @@ public StreamProcessorTest()
                 .EventSourceCreator(_eventSourceFactory.Create());
         }
 
-        [Fact]
-        public void StreamUriHasCorrectEndpoint()
+        [Theory]
+        [InlineData("", "/all")]
+        [InlineData("/basepath", "/basepath/all")]
+        [InlineData("/basepath/", "/basepath/all")]
+        public void StreamRequestHasCorrectUriAndMethod(string baseUriExtraPath, string expectedPath)
         {
-            _dataSourceBuilder.BaseUri(new Uri("http://stream.test.com"));
+            _dataSourceBuilder.BaseUri(new Uri("http://stream.test.com" + baseUriExtraPath));
             StreamProcessor sp = CreateAndStartProcessor();
-            Assert.Equal(new Uri("http://stream.test.com/all"),
+            Assert.Equal(new Uri("http://stream.test.com" + expectedPath),
                 _eventSourceFactory.ReceivedProperties.StreamUri);
         }
-        
+
         [Fact]
         public void PutCausesFeatureToBeStored()
         {