public void SerialiseSmsMessage()
{
// Arrange
try
{
SmsMessage smsMessage = new SmsMessage();
string xml = "";
// Act - Assert
XmlSchema schema = GetEmbeddedSchema(MessageSchemas.DispatcherRequestSchemaName);
XmlReaderSettings settings = new XmlReaderSettings()
{
ValidationType = ValidationType.Schema,
ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings
};
settings.ValidationEventHandler += new ValidationEventHandler(settings_ValidationEventHandler);
settings.Schemas.Add(schema);
XmlReader reader = XmlReader.Create(new StringReader(xml), settings);
while (reader.Read()) { }
}
catch (XmlException)
{
Assert.Fail();
}
}
public void SendMessage(string from, PhoneNumber to, string message)
{
var smsMessage = new SmsMessage(to, message, _account);
smsMessage.Originator = from;
_dispatcher.SendMessage(smsMessage);
}
public void WhenCharacterSetIsDefaultItIsNotSerialised()
{
var message = new SmsMessage();
var serialiser = new XmlSerialiser();
var serialisedMessage = serialiser.Serialise(message);
Assert.That(serialisedMessage, Is.Not.StringContaining("characterset"));
}
public void WhenSmsMessageIsSerializedThenTheCharacterSetIsSerialisedAsExpected(CharacterSet characterSet, string expectedXml)
{
var message = new SmsMessage {CharacterSet = characterSet};
var serialiser = new XmlSerialiser();
var serialisedMessage = serialiser.Serialise(message);
Assert.That(serialisedMessage, Is.EqualTo(expectedXml));
}
public void WhenCharacterSetIsSetShouldBeSerialised([Values(CharacterSet.Auto, CharacterSet.GSM, CharacterSet.Unicode)] CharacterSet characterSet)
{
var message = new SmsMessage();
message.CharacterSet = characterSet;
var serialiser = new XmlSerialiser();
var serialisedMessage = serialiser.Serialise(message);
Assert.That(serialiser.Deserialise<SmsMessage>(serialisedMessage).CharacterSet, Is.EqualTo(characterSet));
}
public void SmsMessageCollection_ConstructorWithSmsMessage()
{
// Arrange
string recipients = "recipients";
string body = "body";
string accountReference = "accountReference";
SmsMessage message = new SmsMessage(recipients, body, accountReference);
// Act
SmsMessageCollection messagesInstance = new SmsMessageCollection(message);
// Assert
Assert.AreEqual(message, messagesInstance.Items.ElementAt(0));
}
public void SendMessagesToSantas(IEnumerable<SantaEntry> entries, string messageTemplate, string originator, string account)
{
foreach (var entry in entries)
{
var santaChosenName = NickOrFirstname(entry.Santa);
var reciverChosenName = NickOrFirstname(entry.Receiver);
var fullMessage = string.Format(messageTemplate, santaChosenName, reciverChosenName);
var smsMessage = new SmsMessage(entry.Santa.PhoneNumber, fullMessage, account);
smsMessage.Originator = originator;
_dispatcher.SendMessage(smsMessage);
}
}
public void SmsMessage_DefaultDIConstructor()
{
// Arrange
var recipients = "recipients";
var body = "body";
var accountReference = "accountReference";
// Act
var messageInstance = new SmsMessage(recipients, body, accountReference);
// Assert
Assert.AreEqual(accountReference, messageInstance.AccountReference);
Assert.AreEqual(body, messageInstance.Body);
Assert.AreEqual(recipients, messageInstance.Recipients);
}
public void SendMessages_WithSmsMessage_ReturnsBatchIdResult()
{
// Arrange
SmsMessage message = new SmsMessage("recipients", "body", "accountReference");
SmsMessageCollection messages = new SmsMessageCollection(message);
string serialisedMessage = "serialisedMessage";
RestResource resource = new MessageDispatcherResource(serialisedMessage, false);
RestResponse response = new RestResponse()
{
StatusCode = HttpStatusCode.OK,
Content = "serialisedResponse"
};
MessagingResult expectedResult = new MessagingResult()
{
BatchId = Guid.NewGuid(),
MessageIds = new List<ResourceLink>()
};
mockSerialiser
.Setup(s => s.Serialise(messages))
.Returns(serialisedMessage);
mockRestClient
.Setup(rc => rc.Post(resource))
.Returns(response);
mockSerialiser
.Setup(s => s.Deserialise<MessagingResult>(response.Content))
.Returns(expectedResult);
// Act
MessagingResult actualResult = service.SendMessages(messages);
// Assert
Assert.IsNotNull(actualResult);
Assert.AreEqual(expectedResult.BatchId, actualResult.BatchId);
Assert.AreEqual(0, actualResult.MessageIds.Count());
}
public void Message_WithOriginator_SerialisesOriginator()
{
// Arrange
SmsMessage message = new SmsMessage()
{
Originator = "07000000000"
};
XmlSerialiser serialiser = new XmlSerialiser();
// Act
string serialisedXml = serialiser.Serialise(message);
// Assert
var document = XDocument.Parse(serialisedXml);
var originator = document.Element("message").Element("from");
Assert.IsNotNull(originator);
Assert.AreEqual(message.Originator, originator.Value);
}
public void Message_WithoutBlankOriginator_ShouldNotSerialiseOriginator()
{
// Arrange
var message = new SmsMessage
{
Originator = string.Empty
};
var serialiser = new XmlSerialiser();
// Act
var serialisedXml = serialiser.Serialise(message);
// Assert
var document = XDocument.Parse(serialisedXml);
var originator = document.Element("message")
.Element("from");
Assert.IsNull(originator);
}
public void SmsMessage_DefaultDIConstructor_WithNullOrEmptyParams()
{
// Arrange
string recipients = string.Empty;
string body = null;
string accountReference = string.Empty;
// Act
try
{
SmsMessage messageInstance = new SmsMessage(recipients, body, accountReference);
Assert.Fail();
}
// Assert
catch (ArgumentNullException ex)
{
Assert.AreEqual("recipients", ex.ParamName);
}
}
public void SendSmsMessageCollection_RestClientReturnsNull_ReturnsNull()
{
// Arrange
SmsMessage message = new SmsMessage("recipients", "body", "accountReference");
SmsMessageCollection messages = new SmsMessageCollection(message);
string serialisedMessage = "serialisedMessage";
RestResource resource = new MessageDispatcherResource(serialisedMessage, false);
RestResponse response = null;
mockSerialiser
.Setup(s => s.Serialise(messages))
.Returns(serialisedMessage);
mockRestClient
.Setup(rc => rc.Post(resource))
.Returns(response);
// Act
MessagingResult actualResult = service.SendMessages(messages);
// Assert
Assert.IsNull(actualResult);
}
private static void SendMessageExample(EsendexCredentials credentials)
{
var message = new SmsMessage(_sendTo, "This is a test message from the .Net SDK...", _accountReference);
var messagingService = new MessagingService(true, credentials);
try
{
var messageResult = messagingService.SendMessage(message);
Console.WriteLine("\tMessage Batch Id: {0}", messageResult.BatchId);
foreach (var messageId in messageResult.MessageIds)
{
Console.WriteLine("\t\tMessage Uri: {0}", messageId.Uri);
}
}
catch (WebException ex)
{
Console.Write(ex.Message);
}
}
/// <summary>
/// Sends a com.esendex.sdk.messaging.SmsMessage instance and returns a com.esendex.sdk.messaging.MessagingResult instance.
/// </summary>
/// <param name="message">A com.esendex.sdk.messaging.SmsMessage instance that contains the SMS message.</param>
/// <returns>A com.esendex.sdk.messaging.MessagingResult instance that contains the message batch Id.</returns>
/// <exception cref="System.Net.WebException"></exception>
public MessagingResult SendMessage(SmsMessage message)
{
var messages = new SmsMessageCollection(message);
return(SendMessages <SmsMessageCollection>(messages));
}
private static void SendMessageExample()
{
SmsMessage message = new SmsMessage("07000000000", "This is a test...", accountReference);
MessagingService messagingService = new MessagingService(true, Credentials);
try
{
MessagingResult messageResult = messagingService.SendMessage(message);
Console.WriteLine("Message Batch Id: {0}", messageResult.BatchId);
foreach (ResourceLink messageId in messageResult.MessageIds)
{
Console.WriteLine("Message Uri: {0}", messageId.Uri);
}
}
catch (WebException ex)
{
Console.Write(ex.Message);
}
}
