public async Task ProcessGetActionShouldSucceed()
{
// Arrange
var command = new Command()
{
Id = EnvelopeId.NewId(),
Method = CommandMethod.Get,
Uri = new LimeUri("/ping")
};
var settings = JObject.FromObject(command, LimeSerializerContainer.Serializer);
var variable = "responseBody";
settings.TryAdd(nameof(variable), variable);
var target = GetTarget();
var responseCommand = new Command()
{
Method = CommandMethod.Get,
Status = CommandStatus.Success,
Resource = new JsonDocument()
};
BlipClient.ProcessCommandAsync(Arg.Any <Command>(), Arg.Any <CancellationToken>()).Returns(responseCommand);
// Act
await target.ExecuteAsync(Context, settings, CancellationToken);
// Assert
await BlipClient.Received(1).ProcessCommandAsync(Arg.Is <Command>(c => c.Uri.Equals(command.Uri)), Arg.Any <CancellationToken>());
await Context.Received(1).SetVariableAsync(variable, JsonConvert.SerializeObject(responseCommand, LimeSerializerContainer.Serializer.Converters.ToArray()), Arg.Any <CancellationToken>());
}
public async Task <bool> HasRecipientAsync(string listName, Identity recipientIdentity, CancellationToken cancellationToken = new CancellationToken())
{
var listIdentity = GetListIdentity(listName);
if (recipientIdentity == null)
{
throw new ArgumentNullException(nameof(recipientIdentity));
}
var requestCommand = new Command()
{
Id = EnvelopeId.NewId(),
To = DistributionListAddress,
Method = CommandMethod.Get,
Uri = new LimeUri($"/lists/{Uri.EscapeDataString(listIdentity.ToString())}/recipients/{Uri.EscapeDataString(recipientIdentity.ToString())}")
};
try
{
await ProcessCommandAsync(requestCommand, cancellationToken);
return(true);
}
catch (LimeException ex) when(ex.Reason.Code == ReasonCodes.COMMAND_RESOURCE_NOT_FOUND)
{
return(false);
}
}
public async Task NegotiateSessionAsync_NegotiatingState_CallsTransportAndReadsFromBuffer()
{
var target = GetTarget(EnvelopeId.NewId(), state: SessionState.Negotiating);
var cancellationToken = Dummy.CreateCancellationToken();
var compression = SessionCompression.GZip;
var encryption = SessionEncryption.TLS;
var session = Dummy.CreateSession(SessionState.Negotiating);
session.Id = target.SessionId;
_transport
.Setup(t => t.ReceiveAsync(It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult <Envelope>(session))
.Verifiable();
var actualSession = await target.NegotiateSessionAsync(compression, encryption, cancellationToken);
_transport.Verify(
t => t.SendAsync(It.Is <Session>(
e => e.State == SessionState.Negotiating &&
e.Id == target.SessionId &&
e.Compression == compression &&
e.Encryption == encryption),
It.IsAny <CancellationToken>()),
Times.Once());
Assert.AreEqual(session, actualSession);
}
public async Task OnStateChanged_MultiplePendingMessagesAndRegisteredToNewChannel_SendsToNewChannel()
{
// Arrange
var messageStorage = new MemoryMessageStorage();
var messages = new List <Message>();
for (int i = 0; i < Dummy.CreateRandomInt(100) + 1; i++)
{
var message = Dummy.CreateMessage(Dummy.CreateTextContent());
message.Id = EnvelopeId.NewId();
messages.Add(message);
}
var target1 = GetTarget(messageStorage: messageStorage);
var channel2Mock = CreateChannel(_channel.Object.LocalNode, _channel.Object.RemoteNode);
// Act
var actuals = new List <Message>();
foreach (var message in messages)
{
var actual = await((IChannelModule <Message>)target1).OnSendingAsync(message, _cancellationToken);
actuals.Add(actual);
}
target1.OnStateChanged(SessionState.Finished);
var target2 = GetTarget(messageStorage: messageStorage, channel: channel2Mock);
await Task.Delay(_resendMessageIntervalWithSafeMargin);
// Assert
foreach (var message in messages)
{
actuals.ShouldContain(message);
_channel.Verify(c => c.SendMessageAsync(message, It.IsAny <CancellationToken>()), Times.Never);
channel2Mock.Verify(c => c.SendMessageAsync(message, It.IsAny <CancellationToken>()), Times.Once);
}
}
public async Task ProcessAsync_SessionCloseHeader_FinishTransport()
{
// Arrange
var session = new Session()
{
Id = EnvelopeId.NewId(),
State = SessionState.Established
};
EmulatedTransport
.Setup(e => e.GetSessionAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(session);
Processor1HttpRequest.Headers.Add(Constants.SESSION_HEADER, Constants.CLOSE_HEADER_VALUE);
var processorResponse = new HttpResponse(Processor1HttpRequest.CorrelatorId, HttpStatusCode.OK);
Processor1
.Setup(p => p.ProcessAsync(Processor1HttpRequest, It.IsAny <UriTemplateMatch>(), It.IsAny <ITransportSession>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(processorResponse)
.Verifiable();
// Act
await Target.StartAsync();
HttpServerRequestBuffer.Post(Processor1HttpRequest);
// Assert
var actualResponse = await HttpServerResponse;
Processor1.Verify();
actualResponse.ShouldBe(processorResponse);
EmulatedTransport.Verify(t => t.FinishAsync(It.IsAny <CancellationToken>()), Times.Once());
HttpTransportProvider.Verify(h => h.GetTransport(Principal.Object, false), Times.Once());
}
public async Task SendAsync_FullSessionNegotiationWithTlsUpgrade_ShouldSucceed()
{
// Arrange
ServerCertificate = CertificateUtil.GetOrCreateSelfSignedCertificate("localhost");
ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
var(clientTransport, serverTransport) = await GetAndOpenTargetsAsync();
var clientChannel = new ClientChannel(clientTransport, TimeSpan.FromSeconds(30));
var serverChannel = new ServerChannel(EnvelopeId.NewId(), "*****@*****.**", serverTransport, TimeSpan.FromSeconds(30));
// Act
var clientEstablishmentTask = clientChannel.EstablishSessionAsync(
c => SessionCompression.None,
e => SessionEncryption.TLS,
"*****@*****.**",
(schemes, authentication) => new GuestAuthentication(),
EnvelopeId.NewId(),
CancellationToken);
var serverEstablishmentTask = serverChannel.EstablishSessionAsync(
serverTransport.GetSupportedCompression(),
serverTransport.GetSupportedEncryption(),
new[] { AuthenticationScheme.Guest },
(i, am, cancellationToken) => new AuthenticationResult(DomainRole.Member).AsCompletedTask(),
(_, __, ___) => Task.FromResult(Node.Parse("[email protected]/instance")),
CancellationToken);
await Task.WhenAll(clientEstablishmentTask, serverEstablishmentTask);
// Assert
serverTransport.Encryption.ShouldBe(SessionEncryption.TLS);
clientTransport.Encryption.ShouldBe(SessionEncryption.TLS);
var session = await clientEstablishmentTask;
session.State.ShouldBe(SessionState.Established);
}
public async Task OnSending_MultipleMessagesWithoutNotification_ShouldResendUntilLimit()
{
// Arrange
var messages = new List <Message>();
for (int i = 0; i < Dummy.CreateRandomInt(100) + 1; i++)
{
var message = Dummy.CreateMessage(Dummy.CreateTextContent());
message.Id = EnvelopeId.NewId();
messages.Add(message);
}
var target = GetTarget();
// Act
var actuals = new List <Message>();
foreach (var message in messages)
{
var actual = await((IChannelModule <Message>)target).OnSendingAsync(message, _cancellationToken);
actuals.Add(actual);
}
await Task.Delay(ResendLimit);
// Assert
foreach (var message in messages)
{
actuals.ShouldContain(message);
_channel.Verify(c => c.SendMessageAsync(message, It.IsAny <CancellationToken>()), Times.Exactly(_resendMessageTryCount));
}
}
public UserOwnerResolverTests()
{
TunnelExtension = Substitute.For <ITunnelExtension>();
UserIdentity = new Identity("user", "domain");
ApplicationIdentity = new Identity("application", "domain");
Application = new Application()
{
Identifier = ApplicationIdentity.Name,
Domain = ApplicationIdentity.Domain
};
Message = new Message()
{
From = UserIdentity.ToNode(),
To = ApplicationIdentity.ToNode()
};
BuilderConfiguration = new BuilderConfiguration();
TunnelIdentity = new Identity(EnvelopeId.NewId(), Take.Blip.Client.Extensions.Tunnel.TunnelExtension.TunnelAddress.Domain);
TunnelOwner = new Identity("owner", "domain");
TunnelExtension
.GetTunnelAsync(TunnelIdentity, CancellationToken)
.Returns(new Tunnel()
{
Owner = TunnelOwner,
Originator = UserIdentity.ToNode(),
Destination = ApplicationIdentity
});
}
public async Task SetupAsync()
{
_cancellationToken = TimeSpan.FromSeconds(10).ToCancellationToken();
_clientTransport = new FakeTransport();
_serverTransport = new FakeTransport();
_serverTransport.ReceiveBuffer = _clientTransport.SendBuffer;
_clientTransport.ReceiveBuffer = _serverTransport.SendBuffer;
_sendTimeout = TimeSpan.FromSeconds(60);
_clientChannel = new ClientChannel(_clientTransport, _sendTimeout);
_serverChannel = new ServerChannel(EnvelopeId.NewId(), Dummy.CreateNode(), _serverTransport, _sendTimeout);
var clientEstablishSessionTask = Task.Run(() =>
_clientChannel.EstablishSessionAsync(
c => c[0],
e => e[0],
Dummy.CreateIdentity(),
(s, a) => new GuestAuthentication(),
Environment.MachineName,
_cancellationToken),
_cancellationToken);
await Task.WhenAll(
_serverChannel.EstablishSessionAsync(
new [] { SessionCompression.None, },
new [] { SessionEncryption.None },
new [] { AuthenticationScheme.Guest },
(i, authentication, cancellationToken) => new AuthenticationResult(DomainRole.Member).AsCompletedTask(),
(_, __, ___) => Task.FromResult(Dummy.CreateNode()),
_cancellationToken),
clientEstablishSessionTask);
}
public async Task GetFromNonTunnelSenderShouldReturnNull()
{
// Arrange
Message.From = new Node(EnvelopeId.NewId(), "not.tunnel.net", "instance");
Message.Metadata = new Dictionary <string, string>
{
{ Take.Blip.Client.Extensions.Tunnel.TunnelExtension.TUNNEL_OWNER_METADATA_KEY, Owner },
{ Take.Blip.Client.Extensions.Tunnel.TunnelExtension.TUNNEL_ORIGINATOR_METADATA_KEY, Originator }
};
var target = GetTarget();
// Act
var actualOriginator = await target.GetVariableAsync("originator", Context, CancellationToken);
var actualOwner = await target.GetVariableAsync("owner", Context, CancellationToken);
var actualDestination = await target.GetVariableAsync("destination", Context, CancellationToken);
var actualIdentity = await target.GetVariableAsync("identity", Context, CancellationToken);
// Assert
actualOriginator.ShouldBeNull();
actualOwner.ShouldBeNull();
actualDestination.ShouldBeNull();
actualIdentity.ShouldBeNull();
}
public TunnelVariableProviderTests()
{
TunnelExtension = Substitute.For <ITunnelExtension>();
BuilderConfiguration = new BuilderConfiguration();
Message = new Message();
UserIdentity = new Identity("user", "msging.net");
LazyInput = new LazyInput(
Message,
UserIdentity,
BuilderConfiguration,
Substitute.For <IDocumentSerializer>(),
Substitute.For <IEnvelopeSerializer>(),
Substitute.For <IArtificialIntelligenceExtension>(),
CancellationToken);
Context.Input.Returns(LazyInput);
Owner = new Identity("owner", "msging.net");
Originator = new Node("originator", "msging.net", "instance");
TunnelIdentity = new Identity(EnvelopeId.NewId(), Take.Blip.Client.Extensions.Tunnel.TunnelExtension.TunnelAddress.Domain);
ApplicationIdentity = new Identity("application", "msging.net");
Message.To = ApplicationIdentity.ToNode();
Tunnel = new Tunnel()
{
Owner = Owner,
Originator = Originator,
Destination = ApplicationIdentity
};
}
public async Task SetAndGetContactUnitTest(string authKey)
{
var id = EnvelopeId.NewId();
var identity = Identity.Parse($"{id}[email protected]");
Command setResponse;
Contact getResponse;
var contact = new Contact
{
Name = id,
Identity = identity
};
if (authKey.Equals(""))
{
setResponse = await _contactService.SetAsync(contact, CancellationToken.None, _logger);
getResponse = await _contactService.GetAsync(identity, CancellationToken.None, _logger);
}
else
{
var contactService = new ContactService(authKey);
setResponse = await contactService.SetAsync(contact, CancellationToken.None, _logger);
getResponse = await contactService.GetAsync(identity, CancellationToken.None, _logger);
}
setResponse.Status.ShouldBe(CommandStatus.Success);
getResponse.ShouldNotBeNull();
getResponse.Name.ShouldBe(id);
getResponse.Identity.ShouldBe(identity);
getResponse.GetMediaType().ToString().ShouldBe("application/vnd.lime.contact+json");
}
public async Task Unbind_MultiplePendingMessagesAndBoundToNewChannel_SendsToBoundChannel()
{
// Arrange
var messages = new List <Message>();
for (int i = 0; i < Dummy.CreateRandomInt(100) + 1; i++)
{
var message = Dummy.CreateMessage(Dummy.CreateTextContent());
message.Id = EnvelopeId.NewId();
messages.Add(message);
}
var target = GetTarget();
var channel2Mock = CreateChannel();
// Act
var actuals = new List <Message>();
foreach (var message in messages)
{
var actual = await((IChannelModule <Message>)target).OnSendingAsync(message, _cancellationToken);
actuals.Add(actual);
}
target.Unbind();
target.Bind(channel2Mock.Object, true);
await Task.Delay(_resendMessageIntervalWithSafeMargin);
// Assert
foreach (var message in messages)
{
actuals.ShouldContain(message);
_channel.Verify(c => c.SendMessageAsync(message, It.IsAny <CancellationToken>()), Times.Never);
channel2Mock.Verify(c => c.SendMessageAsync(message, It.IsAny <CancellationToken>()), Times.Once);
}
}
public async Task AddQuestions(string intentId, Question[] questions)
{
if (questions == null)
{
throw new ArgumentNullException(nameof(questions));
}
try
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri(Uri.EscapeUriString($"/intentions/{intentId}/questions")),
Method = CommandMethod.Set,
Resource = new DocumentCollection
{
ItemType = Question.MediaType,
Items = questions
}
};
var envelopeResult = await RunCommandAsync(command);
EnsureCommandSuccess(envelopeResult);
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
throw;
}
}
public Task SetVariableAsync <T>(Identity identity, string variableName, T document, CancellationToken cancellationToken,
TimeSpan expiration = default(TimeSpan)) where T : Document
{
if (identity == null)
{
throw new ArgumentNullException(nameof(identity));
}
if (variableName == null)
{
throw new ArgumentNullException(nameof(variableName));
}
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
var uriPath = GetVariableRequestUri(identity, variableName);
uriPath = AppendExpiration <T>(uriPath, expiration);
var requestCommand = CreateSetCommandRequest(
document,
uriPath,
id: $"disposable:{EnvelopeId.NewId()}"
);
return(ProcessCommandAsync(requestCommand, cancellationToken));
}
public async Task <DocumentCollection> GetAllDocumentKeysAsync(BucketNamespace bucketNamespace = BucketNamespace.Document)
{
string @namespace = GetNamespaceAsString(bucketNamespace);
try
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri($"/{@namespace}/"),
Method = CommandMethod.Get
};
var envelopeResult = await RunCommandAsync(command);
return(envelopeResult.Resource as DocumentCollection);
}
catch (HttpRequestException e)
{
_logger.LogError(e, "\nException Caught!");
_logger.LogError(e, "Message :{0} ", e.Message);
return(null);
}
}
public async Task ExecuteAsync(IContext context, JObject settings, CancellationToken cancellationToken)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings), $"The settings are required for '{nameof(ProcessCommandAction)}' action");
}
string variable = null;
if (settings.TryGetValue(nameof(variable), out var variableToken))
{
variable = variableToken.ToString().Trim('"');
}
var command = settings.ToObject <Command>(LimeSerializerContainer.Serializer);
command.Id = EnvelopeId.NewId();
var resultCommand = await _sender.ProcessCommandAsync(command, cancellationToken);
if (string.IsNullOrWhiteSpace(variable))
{
return;
}
var resultCommandJson = _envelopeSerializer.Serialize(resultCommand);
await context.SetVariableAsync(variable, resultCommandJson, cancellationToken);
}
public async Task <string> AddEntity(Entity entity)
{
try
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri("/entities"),
Method = CommandMethod.Set,
Resource = new Entity
{
Name = entity.Name,
Values = entity.Values
}
};
var envelopeResult = await RunCommandAsync(command);
EnsureCommandSuccess(envelopeResult);
var createdEntity = envelopeResult.Resource as Entity;
return(createdEntity.Id);
}
catch (HttpRequestException e)
{
_logger.LogError(e, "\nException Caught!");
_logger.LogError(e, "Message :{0} ", e.Message);
return(null);
}
}
protected override async Task FillEnvelopeAsync(Command envelope, HttpRequest request)
{
CommandMethod method;
if (TryConvertToCommandMethod(request.Method, out method))
{
var limeUriFragment = request.Uri.Segments.Except(_exceptUriSegments).Aggregate((s1, s2) => s1 + s2);
if (!string.IsNullOrWhiteSpace(limeUriFragment))
{
if (envelope.Id.IsNullOrEmpty())
{
envelope.Id = EnvelopeId.NewId();
}
envelope.Method = method;
envelope.Uri = new LimeUri(limeUriFragment);
if (envelope.Method == CommandMethod.Set ||
envelope.Method == CommandMethod.Observe)
{
envelope.Resource = await ParseDocumentAsync(request).ConfigureAwait(false);
}
}
else
{
throw new LimeException(ReasonCodes.VALIDATION_INVALID_URI, "Invalid command URI");
}
}
else
{
throw new LimeException(ReasonCodes.VALIDATION_INVALID_METHOD, "Invalid method");
}
}
public async Task <string> AddIntent(string intentName, bool verbose = false)
{
try
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri("/intentions"),
Method = CommandMethod.Set,
Resource = new Intention
{
Name = intentName,
}
};
var envelopeResult = await RunCommandAsync(command);
if (envelopeResult.Status == CommandStatus.Success)
{
var createdIntention = envelopeResult.Resource as Intention;
return(createdIntention.Id);
}
LogVerboseLine($"{intentName}: {envelopeResult.Status} - {envelopeResult.Reason.Code} = {envelopeResult.Reason.Description}");
return(null);
}
catch (Exception e)
{
_logger.LogError(e, "\nException Caught!");
_logger.LogError(e, "Message: {0} ", e.Message);
return(null);
}
}
public async Task OnSending_ReceivedNotificationAfterSecondResend_ShouldNotResendAgain()
{
// Arrange
var message = Dummy.CreateMessage(Dummy.CreateTextContent());
message.Id = EnvelopeId.NewId();
var notification = Dummy.CreateNotification(Event.Received);
notification.Id = message.Id;
notification.From = message.To;
var channel = CreateChannel();
var target = GetTarget(channel: channel);
var callCount = 0;
channel
.Setup(c => c.SendMessageAsync(It.IsAny <Message>(), It.IsAny <CancellationToken>()))
.Returns((Message m, CancellationToken c) => ((IChannelModule <Message>)target).OnSendingAsync(m, _cancellationToken))
.Callback(async(Message m, CancellationToken c) =>
{
callCount++;
if (callCount == 2)
{
await((IChannelModule <Notification>)target).OnReceivingAsync(notification, _cancellationToken);
}
});
// Act
var actual = await((IChannelModule <Message>)target).OnSendingAsync(message, _cancellationToken);
await Task.Delay(ResendLimit);
// Assert
actual.ShouldBe(message);
channel.Verify(c => c.SendMessageAsync(message, It.IsAny <CancellationToken>()), Times.Exactly(2));
}
public async Task AddAnswers(string intentId, Answer[] answers)
{
if (answers == null)
{
throw new ArgumentNullException(nameof(answers));
}
try
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri(Uri.EscapeUriString($"/intentions/{intentId}/answers")),
Method = CommandMethod.Set,
Resource = new DocumentCollection
{
ItemType = Answer.MediaType,
Items = answers
}
};
var envelopeResult = await RunCommandAsync(command);
EnsureCommandSuccess(envelopeResult);
}
catch (HttpRequestException e)
{
_logger.LogError(e, "\nException Caught!");
_logger.LogError(e, "Message :{0} ", e.Message);
throw;
}
}
public async Task ProcessAsync_InvalidSessionAuthentication_ReturnsUnauthorized()
{
// Arrange
var session = new Session()
{
Id = EnvelopeId.NewId().ToString(),
State = SessionState.Failed,
Reason = new Reason()
{
Code = ReasonCodes.SESSION_AUTHENTICATION_FAILED,
Description = Dummy.CreateRandomString(50)
}
};
EmulatedTransport
.Setup(e => e.GetSessionAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(session);
// Act
await Target.StartAsync();
HttpServerRequestBuffer.Post(Processor1HttpRequest);
// Assert
var actualResponse = await HttpServerResponse;
actualResponse.StatusCode.ShouldBe(HttpStatusCode.Unauthorized);
actualResponse.StatusDescription.ShouldBe(session.Reason.Description);
}
public async Task <AnalysisResponse> AnalyseForMetrics(string analysisRequest)
{
if (analysisRequest == null)
{
throw new ArgumentNullException(nameof(analysisRequest));
}
try
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri("/analysis"),
Method = CommandMethod.Set,
Resource = new AnalysisRequest
{
TestingRequest = true,
Text = analysisRequest
}
};
var envelopeResult = await RunCommandAsync(command);
return(envelopeResult.Resource as AnalysisResponse);
}
catch (HttpRequestException e)
{
_logger.LogError(e, "\nException Caught!");
_logger.LogError(e, "Message :{0} ", e.Message);
return(null);
}
}
public async Task ReceiveAsync(Message message, CancellationToken cancellationToken)
{
var receivedLocation = message.Content as Location;
var textDocument = new PlainText {
Text = "Um instante... ⏳ Estou procurando os postos, ${contact.name}."
};
var textMessage = new Message
{
To = message.From,
Content = textDocument,
Id = EnvelopeId.NewId(),
Metadata = new Dictionary <string, string>
{
{ "#message.replaceVariables", "true" }
}
};
await _sender.SendMessageAsync(textMessage, cancellationToken);
//Get GasStations
var carousel = await _gasStationService.GetNearGasStationsAsync(receivedLocation);
//Carousel with near gas stations
textDocument.Text = "Pronto!Os postos próximos são esses aqui: ⬅️➡️";
await _sender.SendMessageAsync(textDocument, message.From, cancellationToken);
await _sender.SendMessageAsync(carousel, message.From, cancellationToken);
}
public async Task <KeyValuePair <string, Document>?> GetDocumentAsync(string key, BucketNamespace bucketNamespace)
{
try
{
string @namespace = GetNamespaceAsString(bucketNamespace);
var pairsCollection = new List <KeyValuePair <string, Document> >();
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri($"/{@namespace}/{key}"),
Method = CommandMethod.Get
};
var envelopeResult = await RunCommandAsync(command);
var document = envelopeResult.Resource;
var value = new KeyValuePair <string, Document>(key.ToString(), document);
return(value);
}
catch (HttpRequestException e)
{
_logger.LogError(e, "\nException Caught!");
_logger.LogError(e, "Message :{0} ", e.Message);
return(null);
}
}
public override async Task ExecuteAsync(IContext context, SendMessageFromHttpSettings settings, CancellationToken cancellationToken)
{
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, settings.Uri);
if (settings.Headers != null)
{
foreach (var header in settings.Headers)
{
httpRequestMessage.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
}
else
{
httpRequestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(settings.Type));
}
using (var cts = new CancellationTokenSource(settings.RequestTimeout ?? DefaultRequestTimeout))
using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, cts.Token))
using (var httpResponseMessage = await _httpClient.SendAsync(httpRequestMessage, linkedCts.Token).ConfigureAwait(false))
{
httpResponseMessage.EnsureSuccessStatusCode();
var body = await httpResponseMessage.Content.ReadAsStringAsync();
var message = new Message(EnvelopeId.NewId())
{
Id = EnvelopeId.NewId(),
To = context.Input.Message.From,
Content = _documentSerializer.Deserialize(body, settings.MediaType)
};
await _sender.SendMessageAsync(message, cancellationToken);
}
}
public async Task AddDocumentAsync(string key, Document document, BucketNamespace bucketNamespace = BucketNamespace.Document)
{
try
{
string @namespace = GetNamespaceAsString(bucketNamespace);
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri($"/{@namespace}/{key}"),
Method = CommandMethod.Set,
Resource = document
};
var envelopeResult = await RunCommandAsync(command);
EnsureCommandSuccess(envelopeResult);
}
catch (HttpRequestException e)
{
_logger.LogError(e, "\nException Caught!");
_logger.LogError(e, "Message :{0} ", e.Message);
}
}
public async Task AuthenticateSessionAsync_AuthenticatingState_CallsTransportAndReadsFromTransport()
{
var target = GetTarget(sessionId: EnvelopeId.NewId(), state: SessionState.Authenticating);
var cancellationToken = Dummy.CreateCancellationToken();
var localIdentity = Dummy.CreateIdentity();
var localInstance = Dummy.CreateInstanceName();
var authentication = Dummy.CreateAuthentication(Security.AuthenticationScheme.Plain);
var session = Dummy.CreateSession(SessionState.Established);
session.Id = target.SessionId;
var tcs = new TaskCompletionSource <Envelope>();
_transport
.SetupSequence(t => t.ReceiveAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <Envelope>(session))
.Returns(tcs.Task);
var actualSession = await target.AuthenticateSessionAsync(localIdentity, authentication, localInstance, cancellationToken);
_transport.Verify(
t => t.SendAsync(It.Is <Session>(
e => e.State == SessionState.Authenticating &&
e.Id == target.SessionId &&
e.From.ToIdentity().Equals(localIdentity) &&
e.From.Instance.Equals(localInstance) &&
e.Authentication == authentication),
It.IsAny <CancellationToken>()),
Times.Once());
Assert.AreEqual(session, actualSession);
}
public async Task SendCommand_SingleCommand_ShouldWriteOnResponseStream()
{
// Arrange
var message = new Command()
{
Id = EnvelopeId.NewId(),
Method = CommandMethod.Set,
Uri = "/greeting",
Resource = "Hello world"
};
var target = GetTarget();
// Act
await target.SendCommandAsync(message, CancellationTokenSource.Token);
// Assert
ResponseBody.Position.ShouldBePositive();
ResponseBody.Position = 0;
using var reader = new StreamReader(ResponseBody, Encoding.UTF8);
var json = await reader.ReadToEndAsync();
var actualEnvelope = EnvelopeSerializer.Deserialize(json);
var actualCommand = actualEnvelope.ShouldBeOfType <Command>();
actualCommand.Id.ShouldBe(message.Id);
actualCommand.Method.ShouldBe(message.Method);
actualCommand.Uri.ShouldBe(message.Uri);
actualCommand.Type.ShouldBe(message.Type);
actualCommand.Resource.ToString().ShouldBe(message.Resource.ToString());
}