public void WrapperReturnsAFunction()
{
var messageLock = Substitute.For<IMessageLock>();
var handlerWrapper = new MessageHandlerWrapper(messageLock, new NullOpMessageMonitor());
var wrapped = handlerWrapper.WrapMessageHandler(() => new UnadornedHandlerAsync());
Assert.That(wrapped, Is.Not.Null);
}
public async Task ReturnedFunctionIsCallable()
{
// arrange
var messageLock = Substitute.For<IMessageLock>();
var handlerWrapper = new MessageHandlerWrapper(messageLock, new NullOpMessageMonitor());
var mockHandler = Substitute.For<IHandlerAsync<GenericMessage>>();
mockHandler.Handle(Arg.Any<GenericMessage>()).Returns(Task.FromResult(true));
// act
var wrapped = handlerWrapper.WrapMessageHandler(() => mockHandler);
var result = await wrapped(new GenericMessage());
Assert.That(result, Is.True);
}
public async Task Token_endpoint_supports_client_authentication_with_basic_authentication_with_POST()
{
await _pipeline.LoginAsync("bob");
var nonce = Guid.NewGuid().ToString();
_pipeline.BrowserClient.AllowAutoRedirect = false;
var url = _pipeline.CreateAuthorizeUrl(
clientId: "code_pipeline.Client",
responseType: "code",
scope: "openid",
redirectUri: "https://code_pipeline.Client/callback?foo=bar&baz=quux",
nonce: nonce);
var response = await _pipeline.BrowserClient.GetAsync(url);
var authorization = _pipeline.ParseAuthorizationResponseUrl(response.Headers.Location.ToString());
authorization.Code.Should().NotBeNull();
var code = authorization.Code;
// backchannel client
var wrapper = new MessageHandlerWrapper(_pipeline.Handler);
var tokenClient = new HttpClient(wrapper);
var tokenResult = await tokenClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
{
Address = IdentityServerPipeline.TokenEndpoint,
ClientId = "code_pipeline.Client",
ClientSecret = "secret",
Code = code,
RedirectUri = "https://code_pipeline.Client/callback?foo=bar&baz=quux"
});
tokenResult.IsError.Should().BeFalse();
tokenResult.HttpErrorReason.Should().BeNull();
tokenResult.TokenType.Should().Be("Bearer");
tokenResult.AccessToken.Should().NotBeNull();
tokenResult.ExpiresIn.Should().BeGreaterThan(0);
tokenResult.IdentityToken.Should().NotBeNull();
wrapper.Response.Headers.CacheControl.NoCache.Should().BeTrue();
wrapper.Response.Headers.CacheControl.NoStore.Should().BeTrue();
}
public async Task ReturnedFunctionCallsInner()
{
// arrange
var messageLock = Substitute.For <IMessageLockAsync>();
var handlerWrapper = new MessageHandlerWrapper(messageLock, new NullOpMessageMonitor());
var mockHandler = Substitute.For <IHandlerAsync <SimpleMessage> >();
mockHandler.Handle(Arg.Any <SimpleMessage>()).Returns(Task.FromResult(true));
var testMessage = new SimpleMessage();
// act
var wrapped = handlerWrapper.WrapMessageHandler(() => mockHandler);
await wrapped(testMessage);
await mockHandler.Received().Handle(testMessage);
}
public async Task ReturnedFunctionCallsInner()
{
// arrange
var messageLock = Substitute.For<IMessageLock>();
var handlerWrapper = new MessageHandlerWrapper(messageLock, new NullOpMessageMonitor());
var mockHandler = Substitute.For<IHandlerAsync<GenericMessage>>();
mockHandler.Handle(Arg.Any<GenericMessage>()).Returns(Task.FromResult(true));
var testMessage = new GenericMessage();
// act
var wrapped = handlerWrapper.WrapMessageHandler(() => mockHandler);
await wrapped(testMessage);
await mockHandler.Received().Handle(testMessage);
}
/// <summary>
/// Register a entity message handler for given entity id.
/// </summary>
/// <typeparam name="TMessageType">The type of the message.</typeparam>
/// <param name="entityId">The entity id.</param>
/// <param name="handler">The handler executed on received message of given entity id.</param>
public void Register <TMessageType>(long entityId, EntityMessageHandler <TMessageType> handler) where TMessageType : IEntityMessage
{
var type = typeof(TMessageType).FullName;
if (type == null)
{
throw new Exception($"Unable to get type of {typeof(TMessageType)}");
}
if (!_entityMessageHandler.ContainsKey(entityId))
{
_entityMessageHandler.Add(entityId, new Dictionary <string, HashSet <MessageHandlerWrapper> > {
{ type, new HashSet <MessageHandlerWrapper>(_wrapperComparer) }
});
}
if (!_entityMessageHandler[entityId].ContainsKey(type))
{
_entityMessageHandler[entityId].Add(type, new HashSet <MessageHandlerWrapper>(_wrapperComparer));
}
_entityMessageHandler[entityId][type].Add(MessageHandlerWrapper.Create(handler));
}
