public void Parse_InvalidSchemeAbsoluteString_ThrowsArgumentException()
{
var absolutePath = "http://[email protected]/presence";
Action action = () => LimeUri.Parse(absolutePath);
action.ShouldThrow <ArgumentException>();
}
public void Parse_NullString_ThrowsArgumentNullException()
{
string path = null;
Action action = () => LimeUri.Parse(path);
action.ShouldThrow <ArgumentNullException>();
}
public async Task ReceiveCommandAsync_PingCommandAbsoluteUriReceivedAndAutoReplyPingsTrue_SendsPingCommandToTransport()
{
var ping = Dummy.CreatePing();
var command = Dummy.CreateCommand(ping);
command.Uri = LimeUri.Parse(LimeUri.Parse(UriTemplates.PING).ToUri(command.From).ToString());
var cancellationToken = Dummy.CreateCancellationToken();
var tcs = new TaskCompletionSource <Envelope>();
_transport
.SetupSequence(t => t.ReceiveAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <Envelope>(command))
.Returns(tcs.Task);
var target = GetTarget(state: SessionState.Established, autoReplyPings: true);
await Task.Delay(250);
_transport.Verify(
t => t.SendAsync(It.Is <Command>(
c => c.Id == command.Id &&
c.To.Equals(command.From) &&
c.Resource.GetMediaType().ToString().Equals(Ping.MIME_TYPE, StringComparison.OrdinalIgnoreCase) &&
c.Status == CommandStatus.Success),
It.IsAny <CancellationToken>()),
Times.Once());
}
private Task SetPresenceAsync()
{
return(_clientChannel.SetResourceAsync(
LimeUri.Parse(UriTemplates.PRESENCE),
Presence,
_receiveTimeout.ToCancellationToken()));
}
public async Task ReceiveCommandAsync_PingCommandReceivedAndAutoReplyPingsFalse_DoNotSendsPingCommandToTransport()
{
var ping = Dummy.CreatePing();
var command = Dummy.CreateCommand(ping);
command.Uri = LimeUri.Parse(UriTemplates.PING);
var cancellationToken = Dummy.CreateCancellationToken();
var tcs = new TaskCompletionSource <Envelope>();
_transport
.SetupSequence(t => t.ReceiveAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <Envelope>(command))
.Returns(tcs.Task);
var target = GetTarget(state: SessionState.Established, autoReplyPings: false);
var actual = await target.ReceiveCommandAsync(cancellationToken);
actual.ShouldBe(command);
_transport.Verify(
t => t.SendAsync(It.Is <Command>(
c => c.Id == command.Id &&
c.To.Equals(command.From) &&
c.Resource is Ping &&
c.Status == CommandStatus.Success),
It.IsAny <CancellationToken>()),
Times.Never());
}
public void Parse_InvalidRelativeString_ThrowsArgumentException()
{
var resourceName = Dummy.CreateRandomString(10);
var invalidPath = string.Format("\\{0}", resourceName);
Action action = () => LimeUri.Parse(invalidPath);
action.ShouldThrow <ArgumentException>();
}
public void ToUri_RelativeInstance_ThrowsInvalidOperationException()
{
var resourceName = DataUtil.CreateRandomString(10);
var relativePath = string.Format("/{0}", resourceName);
var limeUri = LimeUri.Parse(relativePath);
// Act
var uri = limeUri.ToUri();
}
public void ToUriIdentity_AbsoluteInstance_ThrowsInvalidOperationException()
{
var identity = DataUtil.CreateIdentity();
var resourceName = DataUtil.CreateRandomString(10);
var absolutePath = string.Format("{0}://{1}/{2}", LimeUri.LIME_URI_SCHEME, identity, resourceName);
var limeUri = LimeUri.Parse(absolutePath);
// Act
var uri = limeUri.ToUri(identity);
}
public void Parse_ValidRelativeString_ReturnsInstance()
{
var resourceName = Dummy.CreateRandomString(10);
var relativePath = string.Format("/{0}", resourceName);
var actual = LimeUri.Parse(relativePath);
actual.Path.ShouldNotBe(null);
actual.Path.ShouldBe(relativePath);
actual.IsRelative.ShouldBe(true);
}
public Task <Command> GetContactsAsync(CancellationToken cancellationToken)
{
var rosterCommand = new Command
{
Method = CommandMethod.Get,
Uri = LimeUri.Parse(UriTemplates.CONTACTS)
};
return(Channel.ProcessCommandAsync(rosterCommand, cancellationToken));
}
private async void Contacts_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (!ModernUIHelper.IsInDesignMode)
{
if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
{
var addedContacts = e.NewItems.Cast <ContactViewModel>();
var cancellationToken = _receiveTimeout.ToCancellationToken();
foreach (var contactViewModel in addedContacts)
{
try
{
await base.ExecuteAsync(async() =>
{
var identityPresence = await _clientChannel.GetResourceAsync <Presence>(
LimeUri.Parse(UriTemplates.PRESENCE),
new Node()
{
Name = contactViewModel.Contact.Identity.Name,
Domain = contactViewModel.Contact.Identity.Domain
},
cancellationToken);
if (identityPresence.Instances != null &&
identityPresence.Instances.Any())
{
var presence = await _clientChannel.GetResourceAsync <Presence>(
LimeUri.Parse(UriTemplates.PRESENCE),
new Node()
{
Name = contactViewModel.Contact.Identity.Name,
Domain = contactViewModel.Contact.Identity.Domain,
Instance = identityPresence.Instances[0]
},
cancellationToken);
contactViewModel.Presence = presence;
}
});
}
catch (LimeException ex)
{
ErrorMessage = ex.Message;
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
break;
}
}
}
}
}
public Task <Command> SetContactsAsync(Contact contact, CancellationToken cancellationToken)
{
var contactCommand = new Command
{
Method = CommandMethod.Set,
Uri = LimeUri.Parse(UriTemplates.CONTACTS),
Resource = contact
};
return(Channel.ProcessCommandAsync(contactCommand, cancellationToken));
}
private async Task SetPresenceAsync(IClientChannel clientChannel, CancellationToken cancellationToken = default(CancellationToken))
{
if (!IsGuest(clientChannel.LocalNode.Name))
{
await clientChannel.SetResourceAsync(
LimeUri.Parse(UriTemplates.PRESENCE),
new Presence { Status = PresenceStatus.Available, RoutingRule = RoutingRule, RoundRobin = true },
cancellationToken)
.ConfigureAwait(false);
}
}
public void ToUri_RelativeInstance_ThrowsInvalidOperationException()
{
var resourceName = Dummy.CreateRandomString(10);
var relativePath = string.Format("/{0}", resourceName);
var limeUri = LimeUri.Parse(relativePath);
// Act
Action action = () => limeUri.ToUri();
action.ShouldThrow <InvalidOperationException>();
}
public void Parse_ValidAbsoluteString_ReturnsInstance()
{
var identity = Dummy.CreateIdentity();
var resourceName = Dummy.CreateRandomString(10);
var absolutePath = string.Format("{0}://{1}/{2}", LimeUri.LIME_URI_SCHEME, identity, resourceName);
var actual = LimeUri.Parse(absolutePath);
actual.Path.ShouldNotBe(null);
actual.Path.ShouldBe(absolutePath);
actual.IsRelative.ShouldBe(false);
}
public void Parse_ValidAbsoluteSpecialCharactersStringContainingSpace_ReturnsInstance()
{
var identity = Dummy.CreateIdentity();
var resourceNameWithSpace = $"{Dummy.CreateRandomStringSpecial(5)} {Dummy.CreateRandomStringSpecial(5)}";
var absolutePath = string.Format("{0}://{1}/{2}", LimeUri.LIME_URI_SCHEME, identity, Uri.EscapeDataString(resourceNameWithSpace));
var actual = LimeUri.Parse(absolutePath);
actual.Path.ShouldNotBe(null);
actual.Path.ShouldBe(absolutePath);
actual.IsRelative.ShouldBe(false);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, global::Newtonsoft.Json.JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.String)
{
var tokenValue = reader.Value.ToString();
return(LimeUri.Parse(tokenValue));
}
else
{
return(null);
}
}
private async Task GetContactsAsync()
{
var contactCollection = await _clientChannel.GetResourceAsync <DocumentCollection>(
LimeUri.Parse(UriTemplates.CONTACTS),
_receiveTimeout.ToCancellationToken());
Contacts.Clear();
foreach (Contact contact in contactCollection.Items)
{
Contacts.Add(new ContactViewModel(contact, _clientChannel));
}
}
private async Task SetReceiptAsync(IClientChannel clientChannel, CancellationToken cancellationToken = default(CancellationToken))
{
if (IsGuest(clientChannel.LocalNode.Name) ||
ReceiptEvents.Length == 0)
{
return;
}
await clientChannel.SetResourceAsync(
LimeUri.Parse(UriTemplates.RECEIPT),
new Receipt { Events = ReceiptEvents },
cancellationToken)
.ConfigureAwait(false);
}
public Task RejectPendingContactAsync()
{
return(ExecuteAsync(async() =>
{
var selectedContact = SelectedContact;
if (selectedContact != null &&
selectedContact.Contact != null)
{
await _clientChannel.DeleteResourceAsync(
LimeUri.Parse(UriTemplates.CONTACT.NamedFormat(new { contactIdentity = selectedContact.Contact.Identity })),
_receiveTimeout.ToCancellationToken());
await GetContactsAsync();
}
}));
}
public void ToUri_AbsoluteInstance_ReturnsUri()
{
var identity = Dummy.CreateIdentity();
var resourceName = Dummy.CreateRandomString(10);
var absolutePath = string.Format("{0}://{1}/{2}", LimeUri.LIME_URI_SCHEME, identity, resourceName);
var limeUri = LimeUri.Parse(absolutePath);
// Act
var uri = limeUri.ToUri();
// Assert
uri.Scheme.ShouldBe(LimeUri.LIME_URI_SCHEME);
uri.UserInfo.ShouldBe(identity.Name);
uri.Authority.ShouldBe(identity.Domain);
uri.PathAndQuery.ShouldBe("/" + resourceName);
}
private Task RemoveContactAsync()
{
return(ExecuteAsync(async() =>
{
var selectedContact = SelectedContact;
if (selectedContact != null &&
selectedContact.Contact != null)
{
await _clientChannel.DeleteResourceAsync(
LimeUri.Parse(Smart.Format(UriTemplates.CONTACT, new { contactIdentity = SelectedContact.Contact })),
_receiveTimeout.ToCancellationToken());
await GetContactsAsync();
}
}));
}
static ServiceStackSerializer()
{
JsConfig.ExcludeTypeInfo = true;
JsConfig.EmitCamelCaseNames = true;
JsConfig <Message> .IncludeTypeInfo = false;
JsConfig <Notification> .IncludeTypeInfo = false;
JsConfig <Command> .IncludeTypeInfo = false;
JsConfig <Session> .IncludeTypeInfo = false;
JsConfig <MediaType> .SerializeFn = m => m.ToString();
JsConfig <MediaType> .DeSerializeFn = s => MediaType.Parse(s);
JsConfig <Node> .SerializeFn = n => n.ToString();
JsConfig <Node> .DeSerializeFn = s => Node.Parse(s);
JsConfig <Identity> .SerializeFn = i => i.ToString();
JsConfig <Identity> .DeSerializeFn = s => Identity.Parse(s);
JsConfig <Guid> .SerializeFn = g => g.ToString();
JsConfig <Guid> .DeSerializeFn = s => Guid.Parse(s);
JsConfig <LimeUri> .SerializeFn = u => u.ToString();
JsConfig <LimeUri> .DeSerializeFn = u => LimeUri.Parse(u);
JsConfig <Document> .RawSerializeFn = d =>
{
var mediaType = d.GetMediaType();
if (mediaType.IsJson)
{
return(global::ServiceStack.Text.JsonSerializer.SerializeToString(d));
}
else
{
return(string.Format("\"{0}\"", d.ToString()));
}
};
foreach (var enumType in TypeUtil.GetEnumTypes())
{
var jsonConfigEnumType = typeof(JsConfig <>).MakeGenericType(enumType);
var serializeProperty = jsonConfigEnumType.GetProperty("SerializeFn");
var serializeFuncType = typeof(Func <,>).MakeGenericType(enumType, typeof(string));
var methodInfo = typeof(ServiceStackSerializer).GetMethod("ToCamelCase", BindingFlags.Static | BindingFlags.NonPublic);
var enumToCamelCaseMethod = methodInfo.MakeGenericMethod(enumType);
var serializeFunc = Delegate.CreateDelegate(serializeFuncType, enumToCamelCaseMethod);
serializeProperty.SetValue(null, serializeFunc, BindingFlags.Static, null, null, CultureInfo.InvariantCulture);
}
}
public void ToUriIdentity_RelativeInstance_ReturnsUri()
{
var identity = DataUtil.CreateIdentity();
var resourceName = DataUtil.CreateRandomString(10);
var relativePath = string.Format("/{0}", resourceName);
var limeUri = LimeUri.Parse(relativePath);
// Act
var uri = limeUri.ToUri(identity);
// Assert
uri.Scheme.ShouldBe(LimeUri.LIME_URI_SCHEME);
uri.UserInfo.ShouldBe(identity.Name);
uri.Authority.ShouldBe(identity.Domain);
uri.PathAndQuery.ShouldBe("/" + resourceName);
}
private Task AddContactAsync()
{
return(ExecuteAsync(async() =>
{
var identity = _searchOrAddContactIdentity;
if (identity != null)
{
await _clientChannel.SetResourceAsync(
LimeUri.Parse(UriTemplates.CONTACTS),
new Contact
{
Identity = _searchOrAddContactIdentity
},
_receiveTimeout.ToCancellationToken());
await GetContactsAsync();
}
}));
}
public Task UnshareAccountInfoAsync()
{
return(ExecuteAsync(async() =>
{
var selectedContact = SelectedContact;
if (selectedContact != null &&
selectedContact.Contact != null)
{
await _clientChannel.SetResourceAsync(
LimeUri.Parse(UriTemplates.CONTACTS),
new Contact
{
Identity = selectedContact.Contact.Identity,
ShareAccountInfo = false
},
_receiveTimeout.ToCancellationToken());
await GetContactsAsync();
}
}));
}
public void Parse_NullString_ThrowsArgumentNullException()
{
string path = null;
var actual = LimeUri.Parse(path);
}
public void Parse_InvalidSchemeAbsoluteString_ThrowsArgumentException()
{
var absolutePath = "http://[email protected]/presence";
var actual = LimeUri.Parse(absolutePath);
}
public void Parse_InvalidRelativeString_ThrowsArgumentException()
{
var resourceName = DataUtil.CreateRandomString(10);
var invalidPath = string.Format("\\{0}", resourceName);
var actual = LimeUri.Parse(invalidPath);
}
private async Task LoadedAsync()
{
if (!_loaded &&
!ModernUIHelper.IsInDesignMode &&
_clientChannel != null)
{
await ExecuteAsync(async() =>
{
// Events for notification
await _clientChannel.SetResourceAsync(
LimeUri.Parse(UriTemplates.RECEIPT),
new Receipt
{
Events = new[]
{
Event.Accepted,
Event.Received,
Event.Consumed
}
},
_receiveTimeout.ToCancellationToken());
try
{
// Gets the user account
Account = await _clientChannel.GetResourceAsync <Account>(
LimeUri.Parse(UriTemplates.ACCOUNT),
_receiveTimeout.ToCancellationToken());
}
catch (LimeException ex)
{
if (ex.Reason.Code != ReasonCodes.COMMAND_RESOURCE_NOT_FOUND)
{
throw;
}
}
// Creates the account if doesn't exists
if (Account == null)
{
Account = new Account
{
IsTemporary = false,
AllowAnonymousSender = false,
AllowUnknownSender = false
};
await _clientChannel.SetResourceAsync(
LimeUri.Parse(UriTemplates.ACCOUNT),
Account,
_receiveTimeout.ToCancellationToken());
}
// Gets the roster
await GetContactsAsync();
// Sets the presence
Presence = new Presence
{
Status = PresenceStatus.Available,
RoutingRule = RoutingRule.Identity
};
await SetPresenceAsync();
_loaded = true;
});
}
}
