public void HttpOptionsCannotSetNullCookieContainer() { var httpOptions = new HttpConnectionOptions(); Assert.NotNull(httpOptions.Cookies); Assert.Throws <ArgumentNullException>(() => httpOptions.Cookies = null); }
public async Task <ConnectionContext> ConnectAsync(TransferFormat transferFormat, string connectionId, string target, CancellationToken cancellationToken = default) { var httpConnectionOptions = new HttpConnectionOptions { Url = GetServiceUrl(connectionId, target), AccessTokenProvider = () => Task.FromResult(_provider.GenerateServerAccessToken(_hubName, _userId)), Transports = HttpTransportType.WebSockets, SkipNegotiation = true, Headers = CustomHeader }; var httpConnection = new HttpConnection(httpConnectionOptions, _loggerFactory); try { await httpConnection.StartAsync(transferFormat); return(httpConnection); } catch { await httpConnection.DisposeAsync(); throw; } }
public void HttpConnectionOptionsNegativeBufferSizeThrows() { var httpOptions = new HttpConnectionOptions(); Assert.Throws <ArgumentOutOfRangeException>(() => httpOptions.TransportMaxBufferSize = -1); Assert.Throws <ArgumentOutOfRangeException>(() => httpOptions.ApplicationMaxBufferSize = -1); }
public async Task <ConnectionContext> ConnectAsync(HubServiceEndpoint endpoint, TransferFormat transferFormat, string connectionId, string target, CancellationToken cancellationToken = default, IDictionary <string, string> headers = null) { var provider = endpoint.Provider; var hubName = endpoint.Hub; var httpConnectionOptions = new HttpConnectionOptions { Url = GetServiceUrl(provider, hubName, connectionId, target), AccessTokenProvider = () => Task.FromResult(provider.GenerateServerAccessToken(hubName, _userId)), Transports = HttpTransportType.WebSockets, SkipNegotiation = true, Headers = headers, Proxy = provider.Proxy, }; var httpConnection = new HttpConnection(httpConnectionOptions, _loggerFactory); try { await httpConnection.StartAsync(transferFormat, cancellationToken); return(httpConnection); } catch { await httpConnection.DisposeAsync(); throw; } }
public async Task HttpOptionsSetOntoWebSocketOptions() { ClientWebSocketOptions webSocketsOptions = null; var httpOptions = new HttpConnectionOptions(); httpOptions.Cookies.Add(new Cookie("Name", "Value", string.Empty, "fakeuri.org")); var clientCertificate = new X509Certificate(Array.Empty <byte>()); httpOptions.ClientCertificates.Add(clientCertificate); httpOptions.UseDefaultCredentials = false; httpOptions.Credentials = Mock.Of <ICredentials>(); httpOptions.Proxy = Mock.Of <IWebProxy>(); httpOptions.WebSocketConfiguration = options => webSocketsOptions = options; await using (var server = await StartServer <Startup>()) { var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: httpOptions, loggerFactory: null, accessTokenProvider: null); Assert.NotNull(webSocketsTransport); // we need to open a connection so it would apply httpOptions to webSocketOptions await webSocketsTransport.StartAsync(new Uri(server.WebSocketsUrl + "/echo"), TransferFormat.Binary).DefaultTimeout(); await webSocketsTransport.StopAsync().DefaultTimeout(); } Assert.NotNull(webSocketsOptions); Assert.Equal(1, webSocketsOptions.Cookies.Count); Assert.Single(webSocketsOptions.ClientCertificates); Assert.Same(clientCertificate, webSocketsOptions.ClientCertificates[0]); Assert.False(webSocketsOptions.UseDefaultCredentials); Assert.Same(httpOptions.Proxy, webSocketsOptions.Proxy); Assert.Same(httpOptions.Credentials, webSocketsOptions.Credentials); }
// Internal for testing internal static HttpConnectionOptions ShallowCopyHttpConnectionOptions(HttpConnectionOptions options) { var newOptions = new HttpConnectionOptions { HttpMessageHandlerFactory = options.HttpMessageHandlerFactory, Headers = options.Headers, Url = options.Url, Transports = options.Transports, SkipNegotiation = options.SkipNegotiation, AccessTokenProvider = options.AccessTokenProvider, CloseTimeout = options.CloseTimeout, DefaultTransferFormat = options.DefaultTransferFormat, ApplicationMaxBufferSize = options.ApplicationMaxBufferSize, TransportMaxBufferSize = options.TransportMaxBufferSize }; if (!OperatingSystem.IsBrowser()) { newOptions.Cookies = options.Cookies; newOptions.ClientCertificates = options.ClientCertificates; newOptions.Credentials = options.Credentials; newOptions.Proxy = options.Proxy; newOptions.UseDefaultCredentials = options.UseDefaultCredentials; newOptions.WebSocketConfiguration = options.WebSocketConfiguration; newOptions.WebSocketFactory = options.WebSocketFactory; } return(newOptions); }
public async Task HttpOptionsWebSocketFactoryIsUsed() { var httpOptions = new HttpConnectionOptions(); var webSocketMock = new Mock <WebSocket>(); bool factoryWasUsed = false; // we emulate that connection is closed right away after it was established webSocketMock.Setup(socket => socket.CloseStatus).Returns(WebSocketCloseStatus.NormalClosure); webSocketMock.Setup(socket => socket.ReceiveAsync(It.IsAny <Memory <byte> >(), It.IsAny <CancellationToken>())) .ReturnsAsync(new ValueWebSocketReceiveResult(0, WebSocketMessageType.Close, true)); httpOptions.WebSocketFactory = (context, token) => { factoryWasUsed = true; return(ValueTask.FromResult(webSocketMock.Object)); }; var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: httpOptions, loggerFactory: null, accessTokenProvider: null); await webSocketsTransport.StartAsync(new Uri("http://FakeEndpot.com/echo"), TransferFormat.Binary).DefaultTimeout(); await webSocketsTransport.StopAsync().DefaultTimeout(); webSocketMock.Verify((socket) => socket.ReceiveAsync(It.IsAny <Memory <byte> >(), It.IsAny <CancellationToken>()), Times.Once()); Assert.True(factoryWasUsed); }
public void HttpOptionsSetOntoWebSocketOptions() { ClientWebSocketOptions webSocketsOptions = null; var httpOptions = new HttpConnectionOptions(); httpOptions.Cookies.Add(new Cookie("Name", "Value", string.Empty, "fakeuri.org")); var clientCertificate = new X509Certificate(); httpOptions.ClientCertificates.Add(clientCertificate); httpOptions.UseDefaultCredentials = false; httpOptions.Credentials = Mock.Of <ICredentials>(); httpOptions.Proxy = Mock.Of <IWebProxy>(); httpOptions.WebSocketConfiguration = options => webSocketsOptions = options; var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: httpOptions, loggerFactory: null, accessTokenProvider: null); Assert.NotNull(webSocketsTransport); Assert.NotNull(webSocketsOptions); Assert.Equal(1, webSocketsOptions.Cookies.Count); Assert.Single(webSocketsOptions.ClientCertificates); Assert.Same(clientCertificate, webSocketsOptions.ClientCertificates[0]); Assert.False(webSocketsOptions.UseDefaultCredentials); Assert.Same(httpOptions.Proxy, webSocketsOptions.Proxy); Assert.Same(httpOptions.Credentials, webSocketsOptions.Credentials); }
public async Task HttpConnectionChangesAfterConfigChange_UseChangeToken() { var serviceCollection = new ServiceCollection(); // serviceCollection.AddSingleton<HttpJsonPlaceholderService, HttpJsonPlaceholderService>(); var config = new HttpConnectionOptions() { Server = "before", Schema = "https", Port = 443, TimeoutMS = 50 }; serviceCollection.AddHttpClientOptions(); serviceCollection .Configure <HttpClientOptions>("service", options => { options.Connection.Server = config.Server; options.Connection.Schema = config.Schema; options.Connection.Port = config.Port; options.Connection.Timeout = config.Timeout; }); serviceCollection .AddSingleton(new ChangeTokenSource <HttpClientOptions>("service")); serviceCollection .AddSingleton <IOptionsChangeTokenSource <HttpClientOptions> >(sp => sp.GetRequiredService <ChangeTokenSource <HttpClientOptions> >()); var serviceProvider = serviceCollection.BuildServiceProvider(); var factory = serviceProvider.GetRequiredService <IHttpClientFactory>(); var client = factory.CreateClient("service"); Assert.AreEqual(new Uri("https://before:443").ToString(), client.BaseAddress.ToString()); Assert.AreEqual(50, client.Timeout.TotalMilliseconds); config.Server = "after"; config.Schema = "http"; config.Port = 7878; config.TimeoutMS = 500; serviceProvider.GetRequiredService <ChangeTokenSource <HttpClientOptions> >().InvokeChange(); await Policy.HandleResult <string>(e => e == "before").WaitAndRetryAsync(new[] { TimeSpan.FromMilliseconds(20), TimeSpan.FromMilliseconds(20), TimeSpan.FromMilliseconds(20), }).ExecuteAsync(() => Task.FromResult(factory.CreateClient("service").BaseAddress.Host)); Assert.AreEqual(new Uri("http://after:7878").ToString(), factory.CreateClient("service").BaseAddress.ToString()); Assert.AreEqual(500, factory.CreateClient("service").Timeout.TotalMilliseconds); }
private static HttpConnection CreateConnection( HttpConnectionOptions httpConnectionOptions, ILoggerFactory loggerFactory = null, ITransport transport = null, ITransportFactory transportFactory = null, TransferFormat transferFormat = TransferFormat.Text) { loggerFactory = loggerFactory ?? NullLoggerFactory.Instance; httpConnectionOptions.Url ??= new Uri("http://fakeuri.org/"); httpConnectionOptions.DefaultTransferFormat = transferFormat; if (transportFactory == null && transport != null) { transportFactory = new TestTransportFactory(transport); } if (transportFactory != null) { return(new HttpConnection(httpConnectionOptions, loggerFactory, transportFactory)); } else { // Use the public constructor to get the default transport factory. return(new HttpConnection(httpConnectionOptions, loggerFactory)); } }
public async Task HttpConnectionChangesAfterTimeoutChange_UseChangeToken() { var serviceCollection = new ServiceCollection(); var config = new HttpConnectionOptions() { Server = "www.google.com", Schema = "http", Port = 80, }; var timeout = new HttpTimeoutOptions() { TimeoutMS = 50000 }; serviceCollection.AddHttpClientOptions(options => { options.ServiceName = "service"; }); serviceCollection .Configure <HttpClientOptions>("service", options => { options.Connection.Server = config.Server; options.Connection.Schema = config.Schema; options.Connection.Port = config.Port; options.Handler.HandlerLifeTimeMinutes = 0.05; options.Timeout.Timeout = timeout.Timeout; }); serviceCollection .AddSingleton(new ChangeTokenSource <HttpClientOptions>("service")); serviceCollection .AddSingleton <IOptionsChangeTokenSource <HttpClientOptions> >(sp => sp.GetRequiredService <ChangeTokenSource <HttpClientOptions> >()); var serviceProvider = serviceCollection.BuildServiceProvider(); var factory = serviceProvider.GetRequiredService <IHttpClientFactory>(); var client = factory.CreateClient("service"); await client.GetAsync("/"); timeout.TimeoutMS = 1; serviceProvider.GetRequiredService <ChangeTokenSource <HttpClientOptions> >().InvokeChange(); await Task.Delay(TimeSpan.FromSeconds(10)); var ex = Policy.Handle <AssertionException>().WaitAndRetry(new[] { TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(20), }).Execute(() => Assert.ThrowsAsync <TimeoutException>(() => factory.CreateClient("service").GetAsync("/"))); Assert.That(ex.Data.Keys, Has.One.Items.Contains("timeout")); Assert.That(ex.Data["timeout"], Is.EqualTo(TimeSpan.FromMilliseconds(1))); }
/// <summary> /// 重写以实现<see cref="HttpConnectionOptions"/>的行为 /// </summary> /// <param name="opts"></param> protected virtual void HttpConnectionOptionsAction(HttpConnectionOptions opts) { if (!string.IsNullOrEmpty(Version)) { opts.Headers["Version"] = Version; } opts.Headers["HostName"] = Dns.GetHostName(); }
public WebSocketsTransport(HttpConnectionOptions httpConnectionOptions, ILoggerFactory loggerFactory) { _webSocket = new ClientWebSocket(); // Issue in ClientWebSocket prevents user-agent being set - https://github.com/dotnet/corefx/issues/26627 //_webSocket.Options.SetRequestHeader("User-Agent", Constants.UserAgentHeader.ToString()); if (httpConnectionOptions != null) { if (httpConnectionOptions.Headers != null) { foreach (var header in httpConnectionOptions.Headers) { _webSocket.Options.SetRequestHeader(header.Key, header.Value); } } if (httpConnectionOptions.Cookies != null) { _webSocket.Options.Cookies = httpConnectionOptions.Cookies; } if (httpConnectionOptions.ClientCertificates != null) { _webSocket.Options.ClientCertificates.AddRange(httpConnectionOptions.ClientCertificates); } if (httpConnectionOptions.Credentials != null) { _webSocket.Options.Credentials = httpConnectionOptions.Credentials; } if (httpConnectionOptions.Proxy != null) { _webSocket.Options.Proxy = httpConnectionOptions.Proxy; } if (httpConnectionOptions.UseDefaultCredentials != null) { _webSocket.Options.UseDefaultCredentials = httpConnectionOptions.UseDefaultCredentials.Value; } if (httpConnectionOptions.AccessTokenProvider != null) { _accessTokenProvider = httpConnectionOptions.AccessTokenProvider; } httpConnectionOptions.WebSocketConfiguration?.Invoke(_webSocket.Options); _closeTimeout = httpConnectionOptions.CloseTimeout; } // Set this header so the server auth middleware will set an Unauthorized instead of Redirect status code // See: https://github.com/aspnet/Security/blob/ff9f145a8e89c9756ea12ff10c6d47f2f7eb345f/src/Microsoft.AspNetCore.Authentication.Cookies/Events/CookieAuthenticationEvents.cs#L42 _webSocket.Options.SetRequestHeader("X-Requested-With", "XMLHttpRequest"); _logger = (loggerFactory ?? NullLoggerFactory.Instance).CreateLogger <WebSocketsTransport>(); }
/// <summary> /// Initializes a new instance of the <see cref="HttpConnectionFactory"/> class. /// </summary> /// <param name="options">The connection options.</param> /// <param name="loggerFactory">The logger factory.</param> public HttpConnectionFactory(IOptions <HttpConnectionOptions> options, ILoggerFactory loggerFactory) { if (options == null) { throw new ArgumentNullException(nameof(options)); } _httpConnectionOptions = options.Value; _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory)); }
public HubConnectionEx(IJSRuntime runtime, HttpConnectionOptions options) { this.Runtime = runtime; this.Options = options; this.InternalConnectionId = Guid.NewGuid().ToString(); runtime.InvokeSync <object>(CREATE_CONNECTION_METHOD, this.InternalConnectionId, DotNetObjectReference.Create(this.Options)); this.JsonSerializerOptions = GetJsonSerializerSettings(); }
public void HttpConnectionOptionsDefaults() { var httpOptions = new HttpConnectionOptions(); Assert.Equal(1024 * 1024, httpOptions.TransportMaxBufferSize); Assert.Equal(1024 * 1024, httpOptions.ApplicationMaxBufferSize); Assert.Equal(TimeSpan.FromSeconds(5), httpOptions.CloseTimeout); Assert.Equal(TransferFormat.Binary, httpOptions.DefaultTransferFormat); Assert.Equal(HttpTransports.All, httpOptions.Transports); }
/// <summary> /// 注册公钥 /// </summary> /// <param name="options">Hub连接选项</param> /// <param name="publicKey">公钥</param> public static void RegisterPublicKey(this HttpConnectionOptions options, Guid publicKey) { //添加Header options.Headers.Add(SessionKey.PublicKey, publicKey.ToString()); //添加QueryString string url = options.Url.ToString(); string urlWithPublicKey = $"{url}?{SessionKey.PublicKey}={publicKey}"; options.Url = new Uri(urlWithPublicKey); }
/// <summary> /// Configures http connection /// </summary> /// <param name="options"></param> protected virtual void ConnectionOptionsConfig(HttpConnectionOptions options) { if (MessageHandler != null) { options.HttpMessageHandlerFactory = _ => MessageHandler; } if (TokenProvider != null) { options.AccessTokenProvider = TokenProvider.ResolveToken; } }
public DefaultTransportFactory(HttpTransportType requestedTransportType, ILoggerFactory loggerFactory, HttpClient httpClient, HttpConnectionOptions httpConnectionOptions) { if (httpClient == null && requestedTransportType != HttpTransportType.WebSockets) { throw new ArgumentNullException(nameof(httpClient)); } _requestedTransportType = requestedTransportType; _loggerFactory = loggerFactory; _httpClient = httpClient; _httpConnectionOptions = httpConnectionOptions; }
protected override async Task OnInitAsync() { var opt = new HttpConnectionOptions(); Http.DefaultRequestHeaders.Add("Accept", "application/json"); Http.DefaultRequestHeaders.Add("Accept", "text/plain"); Http.DefaultRequestHeaders.Add("Accept", ""); Connection = HubConnectionBuilder.WithUrl(BaseUrl).Build(); Connection.On <Message>("newMessage", OnBroadCastMessage); await Connection.StartAsync(); }
public static async Task <ConnectionContext> ConnectAsync(ILoggerFactory lf) { // Await to enforce it run in another thread await Task.Yield(); var httpConnectionOptions = new HttpConnectionOptions { Url = new Uri("http://locolhost"), }; return(new HttpConnection(httpConnectionOptions, lf)); }
public DefaultTransportFactory(HttpTransportType requestedTransportType, ILoggerFactory loggerFactory, HttpClient?httpClient, HttpConnectionOptions httpConnectionOptions, Func <Task <string?> > accessTokenProvider) { if (httpClient == null && requestedTransportType != HttpTransportType.WebSockets) { throw new ArgumentNullException(nameof(httpClient)); } _requestedTransportType = requestedTransportType; _loggerFactory = loggerFactory; _httpClient = httpClient; _httpConnectionOptions = httpConnectionOptions; _accessTokenProvider = accessTokenProvider; }
protected async Task <ConnectionContext> CreateConnectionAsync() { var options = new HttpConnectionOptions { Url = _uri, Transports = HttpTransportType.WebSockets, SkipNegotiation = true }; options.Headers["Authorization"] = $"Bearer {_token}"; var httpConnection = new HttpConnection(options, _loggerFactory); await httpConnection.StartAsync(); return(httpConnection); }
protected async override Task OnInitAsync() { Debug.WriteLine("Chat base initialized"); var opt = new HttpConnectionOptions(); Http.DefaultRequestHeaders.Add("Accept", "application/json"); Http.DefaultRequestHeaders.Add("Accept", "text/plain"); Http.DefaultRequestHeaders.Add("Accept", ""); Connection = HubConnectionBuilder.WithUrl(BaseUrl).Build(); Connection.On <Message>("newMessage", OnBroadCastMessage); await Connection.StartAsync(); Log += "\nstart signalr Blazor"; Messages.Add("Welcom to chat!, say something"); }
public void ShallowCopyHttpConnectionOptionsCopiesAllPublicProperties() { Func <HttpMessageHandler, HttpMessageHandler> handlerFactory = handler => handler; Func <Task <string> > tokenProvider = () => Task.FromResult(""); Func <WebSocketConnectionContext, CancellationToken, ValueTask <WebSocket> > webSocketFactory = (context, token) => ValueTask.FromResult <WebSocket>(null); Action <ClientWebSocketOptions> webSocketConfig = options => { }; var testValues = new Dictionary <string, object> { { $"{nameof(HttpConnectionOptions.HttpMessageHandlerFactory)}", handlerFactory }, { $"{nameof(HttpConnectionOptions.Headers)}", new Dictionary <string, string>() }, { $"{nameof(HttpConnectionOptions.ClientCertificates)}", new X509CertificateCollection() }, { $"{nameof(HttpConnectionOptions.Cookies)}", new CookieContainer() }, { $"{nameof(HttpConnectionOptions.Url)}", new Uri("https://example.com") }, { $"{nameof(HttpConnectionOptions.Transports)}", HttpTransportType.ServerSentEvents }, { $"{nameof(HttpConnectionOptions.SkipNegotiation)}", true }, { $"{nameof(HttpConnectionOptions.AccessTokenProvider)}", tokenProvider }, { $"{nameof(HttpConnectionOptions.CloseTimeout)}", TimeSpan.FromDays(1) }, { $"{nameof(HttpConnectionOptions.Credentials)}", Mock.Of <ICredentials>() }, { $"{nameof(HttpConnectionOptions.Proxy)}", Mock.Of <IWebProxy>() }, { $"{nameof(HttpConnectionOptions.UseDefaultCredentials)}", true }, { $"{nameof(HttpConnectionOptions.DefaultTransferFormat)}", TransferFormat.Text }, { $"{nameof(HttpConnectionOptions.WebSocketConfiguration)}", webSocketConfig }, { $"{nameof(HttpConnectionOptions.WebSocketFactory)}", webSocketFactory }, { $"{nameof(HttpConnectionOptions.ApplicationMaxBufferSize)}", 1L * 1024 * 1024 }, { $"{nameof(HttpConnectionOptions.TransportMaxBufferSize)}", 1L * 1024 * 1024 }, }; var options = new HttpConnectionOptions(); var properties = typeof(HttpConnectionOptions) .GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (var property in properties) { property.SetValue(options, testValues[property.Name]); } var shallowCopiedOptions = HttpConnectionFactory.ShallowCopyHttpConnectionOptions(options); foreach (var property in properties) { Assert.Equal(testValues[property.Name], property.GetValue(shallowCopiedOptions)); testValues.Remove(property.Name); } Assert.Empty(testValues); }
public async Task HttpOptionsSetOntoHttpClientHandler() { var testHttpHandler = TestHttpMessageHandler.CreateDefault(); var negotiateUrlTcs = new TaskCompletionSource <string>(); testHttpHandler.OnNegotiate((request, cancellationToken) => { negotiateUrlTcs.TrySetResult(request.RequestUri.ToString()); return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationContent())); }); HttpClientHandler httpClientHandler = null; var httpOptions = new HttpConnectionOptions(); httpOptions.Url = new Uri("http://fakeuri.org/"); httpOptions.HttpMessageHandlerFactory = inner => { httpClientHandler = (HttpClientHandler)inner; return(testHttpHandler); }; httpOptions.Cookies.Add(new Cookie("Name", "Value", string.Empty, "fakeuri.org")); var clientCertificate = new X509Certificate(Array.Empty <byte>()); httpOptions.ClientCertificates.Add(clientCertificate); httpOptions.UseDefaultCredentials = false; httpOptions.Credentials = Mock.Of <ICredentials>(); httpOptions.Proxy = Mock.Of <IWebProxy>(); httpOptions.Transports = HttpTransportType.LongPolling; await WithConnectionAsync( CreateConnection(httpOptions), async (connection) => { await connection.StartAsync().DefaultTimeout(); }); Assert.NotNull(httpClientHandler); Assert.Equal(1, httpClientHandler.CookieContainer.Count); Assert.Single(httpClientHandler.ClientCertificates); Assert.Same(clientCertificate, httpClientHandler.ClientCertificates[0]); Assert.False(httpClientHandler.UseDefaultCredentials); Assert.Same(httpOptions.Proxy, httpClientHandler.Proxy); Assert.Same(httpOptions.Credentials, httpClientHandler.Credentials); }
public IServiceConnection GetNextConnection(Action onError, Action onSuccess, String endpoint = null) { var next = Next(endpoint); var builder = _getBuilder(); var opts = new HttpConnectionOptions(); _httpConnectionOptions(opts); var connection = builder .WithQuery(next, _request, _transportType, _httpConnectionOptions) .Build(); return(new Connection(next, connection, onError, onSuccess)); }
public void MapHub <THub>(PathString path, Action <HttpConnectionOptions> configureOptions) where THub : Hub { // find auth attributes var authorizeAttributes = typeof(THub).GetCustomAttributes <AuthorizeAttribute>(inherit: true); var options = new HttpConnectionOptions(); foreach (var attribute in authorizeAttributes) { options.AuthorizationData.Add(attribute); } configureOptions?.Invoke(options); _routes.MapConnections(path, options, builder => { builder.UseHub <THub>(); }); }
public async Task VerifyUserOptionsAreNotChanged() { using (StartVerifiableLog()) { HttpConnectionOptions originalOptions = null, resolvedOptions = null; var accessTokenFactory = new Func <Task <string> >(() => Task.FromResult("fakeAccessToken")); var fakeHeader = "fakeHeader"; var connection = new HubConnectionBuilder() .WithUrl("http://example.com", Http.Connections.HttpTransportType.WebSockets, options => { originalOptions = options; options.SkipNegotiation = true; options.Headers.Add(fakeHeader, "value"); options.AccessTokenProvider = accessTokenFactory; options.WebSocketFactory = (context, token) => { resolvedOptions = context.Options; return(ValueTask.FromResult <WebSocket>(null)); }; }) .Build(); try { // since we returned null WebSocket it would fail await Assert.ThrowsAsync <InvalidOperationException>(() => connection.StartAsync().DefaultTimeout()); } finally { await connection.DisposeAsync().DefaultTimeout(); } Assert.NotNull(resolvedOptions); Assert.NotNull(originalOptions); // verify that object was copied Assert.NotSame(resolvedOptions, originalOptions); Assert.NotSame(resolvedOptions.AccessTokenProvider, originalOptions.AccessTokenProvider); // verify original object still points to the same provider Assert.Same(originalOptions.AccessTokenProvider, accessTokenFactory); Assert.Same(resolvedOptions.Headers, originalOptions.Headers); Assert.Contains(fakeHeader, resolvedOptions.Headers); } }
private static HttpConnection CreateConnection(HttpConnectionOptions httpConnectionOptions, ILoggerFactory loggerFactory = null, ITransport transport = null, ITransportFactory transportFactory = null) { loggerFactory = loggerFactory ?? NullLoggerFactory.Instance; httpConnectionOptions.Url = httpConnectionOptions.Url ?? new Uri("http://fakeuri.org/"); if (transportFactory != null) { return(new HttpConnection(httpConnectionOptions, loggerFactory, transportFactory)); } else if (transport != null) { return(new HttpConnection(httpConnectionOptions, loggerFactory, new TestTransportFactory(transport))); } else { return(new HttpConnection(httpConnectionOptions, loggerFactory)); } }