// 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 UnauthorizedDirectWebSocketsConnectionDoesNotConnect()
{
bool ExpectedErrors(WriteContext writeContext)
{
return(writeContext.LoggerName == typeof(HttpConnection).FullName &&
writeContext.EventId.Name == "ErrorStartingTransport");
}
using (StartServer <Startup>(out var server, ExpectedErrors))
{
var logger = LoggerFactory.CreateLogger <EndToEndTests>();
var url = server.Url + "/auth";
var options = new HttpConnectionOptions
{
Url = new Uri(url),
Transports = HttpTransportType.WebSockets,
SkipNegotiation = true
};
var connection = new HttpConnection(options, LoggerFactory);
await Assert.ThrowsAsync <WebSocketException>(() => connection.StartAsync(TransferFormat.Binary).OrTimeout());
}
}
// Internal for testing
internal static HttpConnectionOptions ShallowCopyHttpConnectionOptions(HttpConnectionOptions options)
{
var newOptions = new HttpConnectionOptions
{
HttpMessageHandlerFactory = options.HttpMessageHandlerFactory,
Headers = options.Headers,
Cookies = options.Cookies,
Url = options.Url,
Transports = options.Transports,
SkipNegotiation = options.SkipNegotiation,
AccessTokenProvider = options.AccessTokenProvider,
CloseTimeout = options.CloseTimeout,
Credentials = options.Credentials,
Proxy = options.Proxy,
UseDefaultCredentials = options.UseDefaultCredentials,
DefaultTransferFormat = options.DefaultTransferFormat,
WebSocketConfiguration = options.WebSocketConfiguration,
};
// WASM doesn't support Crypto APIs and our setter throws if you try to assign null
if (options.ClientCertificates != null)
{
newOptions.ClientCertificates = options.ClientCertificates;
}
return(newOptions);
}
/// <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 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;
}
public async Task HttpRequestsNotSentWhenWebSocketsTransportRequestedAndSkipNegotiationSet()
{
using (StartServer <Startup>(out var server))
{
var logger = LoggerFactory.CreateLogger <EndToEndTests>();
var url = server.Url + "/echo";
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(
(request, cancellationToken) => Task.FromException <HttpResponseMessage>(new InvalidOperationException("HTTP requests should not be sent.")));
var httpOptions = new HttpConnectionOptions
{
Url = new Uri(url),
Transports = HttpTransportType.WebSockets,
SkipNegotiation = true,
HttpMessageHandlerFactory = (httpMessageHandler) => mockHttpHandler.Object
};
var connection = new HttpConnection(httpOptions, LoggerFactory);
try
{
var message = new byte[] { 42 };
await connection.StartAsync(TransferFormat.Binary).OrTimeout();
await connection.Transport.Output.WriteAsync(message).OrTimeout();
var receivedData = await connection.Transport.Input.ReadAsync(1);
Assert.Equal(message, receivedData);
}
catch (Exception ex)
{
logger.LogInformation(ex, "Test threw exception");
throw;
}
finally
{
logger.LogInformation("Disposing Connection");
await connection.DisposeAsync().OrTimeout();
logger.LogInformation("Disposed Connection");
}
}
}
// Internal for testing
internal static HttpConnectionOptions ShallowCopyHttpConnectionOptions(HttpConnectionOptions options)
{
return(new HttpConnectionOptions
{
HttpMessageHandlerFactory = options.HttpMessageHandlerFactory,
Headers = options.Headers,
ClientCertificates = options.ClientCertificates,
Cookies = options.Cookies,
Url = options.Url,
Transports = options.Transports,
SkipNegotiation = options.SkipNegotiation,
AccessTokenProvider = options.AccessTokenProvider,
CloseTimeout = options.CloseTimeout,
Credentials = options.Credentials,
Proxy = options.Proxy,
UseDefaultCredentials = options.UseDefaultCredentials,
DefaultTransferFormat = options.DefaultTransferFormat,
WebSocketConfiguration = options.WebSocketConfiguration,
});
}
public async Task HttpConnectionThrowsIfSkipNegotiationSetAndTransportIsNotWebSockets(HttpTransportType transportType)
{
using (StartServer <Startup>(out var server))
{
var logger = LoggerFactory.CreateLogger <EndToEndTests>();
var url = server.Url + "/echo";
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(
(request, cancellationToken) => Task.FromException <HttpResponseMessage>(new InvalidOperationException("HTTP requests should not be sent.")));
var httpOptions = new HttpConnectionOptions
{
Url = new Uri(url),
Transports = transportType,
SkipNegotiation = true,
HttpMessageHandlerFactory = (httpMessageHandler) => mockHttpHandler.Object
};
var connection = new HttpConnection(httpOptions, LoggerFactory);
try
{
var exception = await Assert.ThrowsAsync <InvalidOperationException>(() => connection.StartAsync(TransferFormat.Binary).OrTimeout());
Assert.Equal("Negotiation can only be skipped when using the WebSocket transport directly.", exception.Message);
}
catch (Exception ex)
{
logger.LogInformation(ex, "Test threw exception");
throw;
}
finally
{
await connection.DisposeAsync().OrTimeout();
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WebSocketConnectionContext"/> class.
/// </summary>
/// <param name="uri">The URL to connect to.</param>
/// <param name="options">The connection options to use.</param>
public WebSocketConnectionContext(Uri uri, HttpConnectionOptions options)
{
Uri = uri;
Options = options;
}
