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));
}
}
