示例#1
0
        public static IEndpoint AddSecureWSHttpEndpoint(this IServiceHostConfigurator configurator, Type contract, HttpEndpointAddress address, Action <WSHttpBinding> configureBinding = null)
        {
            if (configurator is null)
            {
                throw new ArgumentNullException(nameof(configurator));
            }

            if (contract is null)
            {
                throw new ArgumentNullException(nameof(contract));
            }

            if (address is null)
            {
                throw new ArgumentNullException(nameof(address));
            }

            var secureAddress = new HttpEndpointAddress {
                Host = address.Host, IsSecure = true, Path = address.Path, Port = address.Port
            };

            return(configurator.AddWSHttpEndpoint(contract, secureAddress, ConfigureBinding));

            void ConfigureBinding(WSHttpBinding binding)
            {
                binding.UseHttps();
                configureBinding?.Invoke(binding);
            }
        }
        public static HttpEndpointAddress UseECS(this HttpEndpointAddress endpointAddress, IConfiguration configuration, Action <ECSContainerMetadataOptions> configureOptions = null)
        {
            if (Environment.GetEnvironmentVariable(EMG.Extensions.Configuration.ECSMetadataExtensions.ECSContainerMetadataFileKey) == null)
            {
                return(endpointAddress);
            }

            var containerMetadata = configuration.Get <ECSContainerMetadata>();

            if (containerMetadata == null)
            {
                return(endpointAddress);
            }

            var options = new ECSContainerMetadataOptions();

            configureOptions?.Invoke(options);

            var portMapping = options.PortMappingSelector(containerMetadata.PortMappings);

            if (portMapping == null)
            {
                return(endpointAddress);
            }

            return(EndpointAddress.ForHttp(containerMetadata.HostPrivateIPv4Address, endpointAddress.Path, portMapping.HostPort, endpointAddress.IsSecure));
        }
示例#3
0
        public void UseECS_uses_selected_port_mapping(HttpEndpointAddress endpointAddress, IConfiguration configuration, PortMapping mapping)
        {
            AddFakeContainerMetadataFileKey();

            var newEndpoint = ECSMetadataExtensions.UseECS(endpointAddress, configuration, options => options.PortMappingSelector = items => mapping);

            Assert.That(newEndpoint.Port, Is.EqualTo(mapping.HostPort));
        }
示例#4
0
        public void UseECS_uses_configureOptions(HttpEndpointAddress endpointAddress, IConfiguration configuration, Action <ECSContainerMetadataOptions> configureOptions)
        {
            AddFakeContainerMetadataFileKey();

            ECSMetadataExtensions.UseECS(endpointAddress, configuration, configureOptions);

            Mock.Get(configureOptions).Verify(p => p(It.IsAny <ECSContainerMetadataOptions>()), Times.Once());
        }
示例#5
0
        public void UseECS_returns_same_address_if_port_mapping_is_null(HttpEndpointAddress endpointAddress, IConfiguration configuration)
        {
            AddFakeContainerMetadataFileKey();

            var newEndpoint = ECSMetadataExtensions.UseECS(endpointAddress, configuration, options => options.PortMappingSelector = list => null);

            Assert.That(newEndpoint, Is.SameAs(endpointAddress));
        }
示例#6
0
        public static HttpEndpointAddress UseECS(this HttpEndpointAddress endpointAddress, IConfiguration configuration)
        {
            if (Environment.GetEnvironmentVariable("ECS_CONTAINER_METADATA_FILE") == null)
            {
                return(endpointAddress);
            }

            var containerMetadata = configuration.Get <ECSContainerMetadata>();

            return(EndpointAddress.ForHttp(containerMetadata.HostPrivateIPv4Address, endpointAddress.Path, containerMetadata.PortMappings[0].HostPort, endpointAddress.IsSecure));
        }
示例#7
0
        public void Valid_URI_can_be_cast_to_EndpointAddress(HttpEndpointAddress testAddress)
        {
            var testUri = testAddress.ToUri();

            HttpEndpointAddress address = testUri;

            Assert.That(address.Host, Is.EqualTo(testAddress.Host).IgnoreCase);
            Assert.That(address.Port, Is.EqualTo(testAddress.Port));
            Assert.That(address.Path, Is.EqualTo(testAddress.Path).IgnoreCase);
            Assert.That(address.IsSecure, Is.EqualTo(testAddress.IsSecure));
        }
示例#8
0
        public void ParseFromUri_returns_EndpointAddress(HttpEndpointAddress testAddress)
        {
            var testUri = testAddress.ToUri();

            var address = HttpEndpointAddress.ParseFromUri(testUri);

            Assert.That(address.Host, Is.EqualTo(testAddress.Host).IgnoreCase);
            Assert.That(address.Port, Is.EqualTo(testAddress.Port));
            Assert.That(address.Path, Is.EqualTo(testAddress.Path).IgnoreCase);
            Assert.That(address.IsSecure, Is.EqualTo(testAddress.IsSecure));
        }
示例#9
0
        public void GetBasicHttpEndpointAddress_can_return_endpoint(ConfigurationBuilder builder, HttpEndpointAddress testAddress)
        {
            var configuration = builder.AddInMemoryCollection(new Dictionary <string, string>()
            {
                ["Host"] = testAddress.Host,
                ["Port"] = testAddress.Port.ToString(),
                ["Path"] = testAddress.Path
            }).Build();

            Uri result = ConfigurationExtensions.GetBasicHttpEndpointAddress(configuration);

            Assert.That(result.Scheme, Is.EqualTo(Uri.UriSchemeHttp));
            Assert.That(result.Host, Is.EqualTo(testAddress.Host).IgnoreCase);
            Assert.That(result.Port, Is.EqualTo(testAddress.Port));
            Assert.That(result.AbsolutePath, Is.EqualTo("/" + testAddress.Path).IgnoreCase);
        }
示例#10
0
 public static IEndpoint AddWSHttpEndpoint(this IServiceHostConfigurator configurator, Type contract, HttpEndpointAddress address, Action <WSHttpBinding> configureBinding = null) => configurator.AddEndpoint(contract, address, configureBinding);
示例#11
0
 public void ToString_returns_formed_Uri(HttpEndpointAddress testAddress)
 {
     Assert.That(testAddress.ToString(), Is.EqualTo($"Address: {testAddress.ToUri()}"));
 }
示例#12
0
 public void ParseFromUri_throws_if_uri_is_null(HttpEndpointAddress _)
 {
     Assert.Throws <ArgumentNullException>(() => HttpEndpointAddress.ParseFromUri(null));
 }
示例#13
0
        public void ParseFromUri_throws_if_invalid_scheme(HttpEndpointAddress testAddress, string invalidScheme)
        {
            var testUri = new UriBuilder(invalidScheme, testAddress.Host, testAddress.Port, testAddress.Path).Uri;

            Assert.Throws <ArgumentException>(() => HttpEndpointAddress.ParseFromUri(testUri));
        }
示例#14
0
        public void UseECS_returns_same_address_if_metadata_not_found_in_configuration(HttpEndpointAddress endpointAddress, ConfigurationBuilder configurationBuilder)
        {
            AddFakeContainerMetadataFileKey();

            var newEndpoint = ECSMetadataExtensions.UseECS(endpointAddress, configurationBuilder.Build());

            Assert.That(newEndpoint, Is.SameAs(endpointAddress));
        }
示例#15
0
        public void AddWSHttpEndpoint_forwards_to_configurator(IServiceHostConfigurator configurator, Action <WSHttpBinding> testDelegate, HttpEndpointAddress address)
        {
            configurator.AddWSHttpEndpoint(typeof(ITestService), address, testDelegate);

            Mock.Get(configurator).Verify(p => p.AddEndpoint <WSHttpBinding>(typeof(ITestService), address, testDelegate));
        }
示例#16
0
        public void UseECS_returns_same_address_if_ECSContainerMetadataFileKey_not_available(HttpEndpointAddress endpointAddress, IConfiguration configuration)
        {
            var newEndpoint = ECSMetadataExtensions.UseECS(endpointAddress, configuration);

            Assert.That(newEndpoint, Is.SameAs(endpointAddress));
        }
示例#17
0
        public void UseECS_returns_private_IPV4_address([Frozen] ECSContainerMetadata metadata, HttpEndpointAddress endpointAddress, IConfiguration configuration, Action <ECSContainerMetadataOptions> configureOptions)
        {
            AddFakeContainerMetadataFileKey();

            var newEndpoint = ECSMetadataExtensions.UseECS(endpointAddress, configuration, configureOptions);

            Assert.That(newEndpoint.Host, Is.EqualTo(metadata.HostPrivateIPv4Address));
        }