bool ValidateAccessPointTamperingMessage(NotificationMessageHolderType notification,
MessageCheckSettings settings,
StringBuilder logger)
{
MessageDescription messageInfo = new MessageDescription();
messageInfo.IsProperty = true;
messageInfo.AddSimpleItem("State", "boolean", XSNAMESPACE);
messageInfo.AddSimpleItem("Reason", "string", XSNAMESPACE);
return(ValidateAccessPointMessage(notification, settings, logger, messageInfo));
}
bool ValidateAccessPointMessage(NotificationMessageHolderType notification,
MessageCheckSettings settings,
StringBuilder logger,
MessageDescription messageInfo)
{
XmlElement messageElement = notification.Message;
XmlElement messageRawElement = settings.RawMessageElements[notification];
TopicInfo topicInfo = settings.ExpectedTopic;
XmlNamespaceManager manager = settings.NamespaceManager;
// Init
StringBuilder dump = new StringBuilder();
bool ok = true;
ok = ValidateMessageCommonElements(
notification, messageRawElement, topicInfo,
settings.ExpectedPropertyOperation, manager, dump);
if (messageElement != null)
{
// check message source and data
// source
bool localOk = ValidateAccessPointEventSource(messageElement, manager, settings.Data, dump);
ok = ok && localOk;
XmlElement messageInnerElement = messageRawElement.GetMessageContentElement();
XmlElement dataElement = messageInnerElement.GetMessageData();
localOk = ValidateMessageDataSimpleItems(dataElement, messageInfo, dump);
ok = ok && localOk;
}
if (!ok)
{
logger.Append(dump.ToString());
}
return(ok);
}
/// <summary>
/// Validates resulting message
/// </summary>
/// <param name="notify">Notify packet</param>
/// <param name="message">Selected message</param>
/// <param name="rawData">Raw notification data</param>
/// <param name="resultTopic">Resulting event topic</param>
/// <param name="validateResultMessageFunction">Message validation method</param>
/// <param name="accessPointToken">Expected access point token</param>
/// <param name="credentialsToken">Expected credentials token</param>
/// <param name="credentialsHolderName">Expected credentials holder name</param>
void ValidateResultMessage(Notify notify,
NotificationMessageHolderType message,
byte[] rawData,
TopicInfo resultTopic,
ValidateMessageFunction validateResultMessageFunction,
string accessPointToken, string credentialsToken, string credentialsHolderName)
{
BeginStep("Validate message");
XmlDocument doc = new XmlDocument();
string soapRawPacket = System.Text.Encoding.UTF8.GetString(rawData);
doc.LoadXml(soapRawPacket);
XmlNamespaceManager manager = CreateNamespaceManager(doc);
Dictionary <NotificationMessageHolderType, XmlElement> rawElements =
GetRawElements(notify.NotificationMessage, doc, manager, true);
StringBuilder logger = new StringBuilder();
bool ok = true;
MessageCheckSettings settings = new MessageCheckSettings();
settings.NamespaceManager = manager;
settings.ExpectedPropertyOperation = null;
settings.ExpectedTopic = resultTopic;
settings.RawMessageElements = rawElements;
settings.Data = accessPointToken;
ok = validateResultMessageFunction(message, settings, logger);
if (ok)
{
Dictionary <string, string> dataSimpleItems = message.Message.GetMessageDataSimpleItems();
if (dataSimpleItems.ContainsKey(CREDENTIALSTOKENSIMPLEITEM))
{
string actualCredentialsToken = dataSimpleItems[CREDENTIALSTOKENSIMPLEITEM];
if (credentialsToken != actualCredentialsToken)
{
ok = false;
logger.Append(string.Format("CredentialToken is incorrect: expected '{0}', actual '{1}'{2}",
credentialsToken, actualCredentialsToken, Environment.NewLine));
}
}
if (!string.IsNullOrEmpty(credentialsHolderName))
{
if (dataSimpleItems.ContainsKey(CREDENTIALSHOLDERNAMESIMPLEITEM))
{
string actualCredentialsHolderName = dataSimpleItems[CREDENTIALSHOLDERNAMESIMPLEITEM];
if (!string.IsNullOrEmpty(actualCredentialsHolderName))
{
if (credentialsHolderName != actualCredentialsHolderName)
{
ok = false;
logger.Append(
string.Format("CredentialHolderName is incorrect: expected '{0}', actual '{1}'{2}",
credentialsHolderName, actualCredentialsHolderName, Environment.NewLine));
}
}
}
}
}
if (!ok)
{
throw new AssertException(logger.ToStringTrimNewLine());
}
StepPassed();
}
/// <summary>
/// Receives and validates request message
/// </summary>
/// <param name="server">Notification listening server</param>
/// <param name="timeout">Waiting timeout</param>
/// <param name="accessRequestTopic">Topic for request message</param>
/// <param name="validateRequestMessageFunction">Validation method for request message</param>
/// <param name="fullAccessPointsList">Full list of access points</param>
/// <param name="accessPointsList">Filtered list of access points</param>
/// <param name="credentialsToken">[out parameter]CredentialToken, if such SimpleItem is present
/// (if not present and this item is mandatory, validation will fail)</param>
/// <param name="credentialsHolderName">[out parameter]CredentialHolderName, if
/// such SimpleItem is present</param>
/// <returns></returns>
string GetAccessRequestMessage(Utils.NotifyServer server,
int timeout,
TopicInfo accessRequestTopic,
ValidateMessageFunction validateRequestMessageFunction,
List <AccessPointInfo> fullAccessPointsList,
List <AccessPointInfo> accessPointsList,
ref string credentialsToken,
ref string credentialsHolderName)
{
credentialsToken = string.Empty;
string accessPointToken = null;
string message = string.Format("{0} event is expected!", accessRequestTopic.GetDescription());
Action eventInitiationAction = new Action(() =>
{
StepPassed();
_operator.ShowMessage(message);
});
// receive request event
{
BeginStep("Start listening");
Notify notify = null;
try
{
notify = server.WaitForNotify(eventInitiationAction,
timeout * 1000,
_semaphore.StopEvent);
}
finally
{
_operator.HideMessage();
}
ValidateNotificationsPacket(server.RawData);
ValidateNotifyNotEmpty(notify);
if (notify.NotificationMessage.Length > 1)
{
LogTestEvent("DUT sent more than one notification. Test will be performed for token from the first notification");
}
NotificationMessageHolderType notification = notify.NotificationMessage[0];
BeginStep("Validate message");
XmlDocument doc = new XmlDocument();
string soapRawPacket = System.Text.Encoding.UTF8.GetString(server.RawData);
doc.LoadXml(soapRawPacket);
XmlNamespaceManager manager = CreateNamespaceManager(doc);
Dictionary <NotificationMessageHolderType, XmlElement> rawElements =
GetRawElements(notify.NotificationMessage, doc, manager, true);
MessageCheckSettings settings = new MessageCheckSettings();
settings.NamespaceManager = manager;
settings.ExpectedPropertyOperation = null;
settings.ExpectedTopic = accessRequestTopic;
settings.RawMessageElements = rawElements;
EntityListInfo <AccessPointInfo> info = new EntityListInfo <AccessPointInfo>();
info.FilteredList = accessPointsList;
info.FullList = fullAccessPointsList;
settings.Data = info;
StringBuilder logger = new StringBuilder();
bool ok = true;
ok = validateRequestMessageFunction(notification, settings, logger);
XmlElement messageElement = notification.Message;
if (ok)
{
// if names are duplicated, OK will be false by this moment
Dictionary <string, string> sourceSimpleItems = messageElement.GetMessageSourceSimpleItems();
accessPointToken = sourceSimpleItems[ACCESSPOINTTOKENSIMPLEITEM];
}
if (!ok)
{
throw new AssertException(logger.ToStringTrimNewLine());
}
StepPassed();
// simple items must be OK by that moment
Dictionary <string, string> dataSimpleItems = messageElement.GetMessageDataSimpleItems();
if (dataSimpleItems.ContainsKey(CREDENTIALSTOKENSIMPLEITEM))
{
credentialsToken = dataSimpleItems[CREDENTIALSTOKENSIMPLEITEM];
}
if (dataSimpleItems.ContainsKey(CREDENTIALSHOLDERNAMESIMPLEITEM))
{
credentialsHolderName = dataSimpleItems[CREDENTIALSHOLDERNAMESIMPLEITEM];
}
}
return(accessPointToken);
}
