public void NotifyAboutTestSuccess(string testName, TestSession session, BrowserPattern pattern)
{
var escapedTestName = ServiceMessageReplacements.Encode(testName);
var testWriter = serviceMessage.OpenTest(escapedTestName);
testWriter.Dispose();
UploadReportTabToCI(session, pattern.BrowserName);
}
/// <summary>
/// Serializes single value service message
/// </summary>
/// <param name="messageName">message name</param>
/// <param name="properties">params of service message properties</param>
/// <returns>service message string</returns>
public string FormatMessage(string messageName, IEnumerable <ServiceMessageProperty> properties)
{
if (messageName == null)
{
throw new ArgumentNullException(nameof(messageName));
}
if (properties == null)
{
throw new ArgumentNullException(nameof(properties));
}
if (messageName == null)
{
throw new ArgumentNullException(nameof(messageName));
}
if (string.IsNullOrEmpty(messageName))
{
throw new ArgumentException("The message name must not be empty", nameof(messageName));
}
if (properties == null)
{
throw new ArgumentNullException(nameof(properties));
}
if (ServiceMessageReplacements.Encode(messageName) != messageName)
{
throw new ArgumentException("The message name contains illegal characters", nameof(messageName));
}
if (ServiceMessageReplacements.Encode(messageName) != messageName)
{
throw new ArgumentException("Message name contains illegal characters", nameof(messageName));
}
var sb = new StringBuilder();
sb.Append(ServiceMessageConstants.ServiceMessageOpen);
sb.Append(messageName);
foreach (var property in properties)
{
if (string.IsNullOrEmpty(property.Key))
{
throw new InvalidOperationException("The property name must not be empty");
}
if (ServiceMessageReplacements.Encode(property.Key) != property.Key)
{
throw new InvalidOperationException($"The property name “{property.Key}” contains illegal characters");
}
sb.AppendFormat(" {0}='{1}'", property.Key, ServiceMessageReplacements.Encode(property.Value));
}
sb.Append(ServiceMessageConstants.ServiceMessageClose);
return(sb.ToString());
}
public void NotifyAboutTestFail(string testName, TestSession session, BrowserPattern pattern)
{
var escapedTestName = ServiceMessageReplacements.Encode(testName);
var detailsMessage = GetDetailsMessage(session, pattern);
var testWriter = serviceMessage.OpenTest(escapedTestName);
testWriter.WriteFailed("Screenshots are different", detailsMessage);
testWriter.Dispose();
UploadReportTabToCI(session, pattern.BrowserName);
}
public void TestDecode_1_special()
{
Assert.AreEqual(ServiceMessageReplacements.Decode("|n"), "\n");
Assert.AreEqual(ServiceMessageReplacements.Decode("|r"), "\r");
Assert.AreEqual(ServiceMessageReplacements.Decode("|]"), "]");
Assert.AreEqual(ServiceMessageReplacements.Decode("|'"), "'");
Assert.AreEqual(ServiceMessageReplacements.Decode("||"), "|");
Assert.AreEqual(ServiceMessageReplacements.Decode("|x"), "\u0085");
Assert.AreEqual(ServiceMessageReplacements.Decode("|l"), "\u2028");
Assert.AreEqual(ServiceMessageReplacements.Decode("|p"), "\u2029");
}
public void TestEncode_1_special()
{
Assert.AreEqual("|n", ServiceMessageReplacements.Encode("\n"));
Assert.AreEqual("|r", ServiceMessageReplacements.Encode("\r"));
Assert.AreEqual("|]", ServiceMessageReplacements.Encode("]"));
Assert.AreEqual("|'", ServiceMessageReplacements.Encode("'"));
Assert.AreEqual("||", ServiceMessageReplacements.Encode("|"));
Assert.AreEqual("|x", ServiceMessageReplacements.Encode("\u0085"));
Assert.AreEqual("|l", ServiceMessageReplacements.Encode("\u2028"));
Assert.AreEqual("|p", ServiceMessageReplacements.Encode("\u2029"));
}
/// <summary>
/// Serializes single value service message
/// </summary>
/// <param name="messageName">message name</param>
/// <param name="singleValue">value</param>
/// <returns>service message string</returns>
public string FormatMessage([NotNull] string messageName, [NotNull] string singleValue)
{
if (string.IsNullOrEmpty(messageName))
{
throw new ArgumentNullException(nameof(messageName));
}
if (singleValue == null)
{
throw new ArgumentNullException(nameof(singleValue));
}
if (ServiceMessageReplacements.Encode(messageName) != messageName)
{
throw new ArgumentException("The message name contains illegal characters.", nameof(messageName));
}
return(string.Format("{2}{0} '{1}'{3}", messageName, ServiceMessageReplacements.Encode(singleValue), ServiceMessageConstants.ServiceMessageOpen, ServiceMessageConstants.ServiceMessageClose));
}
/// <summary>
/// Serializes single value service message
/// </summary>
/// <param name="messageName">message name</param>
/// <param name="singleValue">value</param>
/// <returns>service message string</returns>
public string FormatMessage(string messageName, string singleValue)
{
if (string.IsNullOrEmpty(messageName))
{
throw new ArgumentNullException("messageName");
}
if (singleValue == null)
{
throw new ArgumentNullException("singleValue");
}
if (ServiceMessageReplacements.Encode(messageName) != messageName)
{
throw new ArgumentException("The message name contains illegal characters.", "messageName");
}
return(string.Format("{2}{0} '{1}'{3}", messageName, ServiceMessageReplacements.Encode(singleValue), ServiceMessageConstants.SERVICE_MESSAGE_OPEN, ServiceMessageConstants.SERVICE_MESSAGE_CLOSE));
}
/// <summary>
/// Serializes single value service message
/// </summary>
/// <param name="messageName">message name</param>
/// <param name="properties">params of service message properties</param>
/// <returns>service message string</returns>
public string FormatMessage([NotNull] string messageName, [NotNull] IEnumerable <ServiceMessageProperty> properties)
{
if (string.IsNullOrEmpty(messageName))
{
throw new ArgumentNullException("messageName");
}
if (properties == null)
{
throw new ArgumentNullException("properties");
}
if (ServiceMessageReplacements.Encode(messageName) != messageName)
{
throw new ArgumentException("The message name contains illegal characters.", "messageName");
}
if (ServiceMessageReplacements.Encode(messageName) != messageName)
{
throw new ArgumentException("Message name contains illegal characters", "messageName");
}
var sb = new StringBuilder();
sb.Append(ServiceMessageConstants.SERVICE_MESSAGE_OPEN);
sb.Append(messageName);
foreach (ServiceMessageProperty property in properties)
{
if (ServiceMessageReplacements.Encode(property.Key) != property.Key)
{
throw new InvalidOperationException(string.Format("The property name “{0}” contains illegal characters.", property.Key));
}
sb.AppendFormat(" {0}='{1}'", property.Key, ServiceMessageReplacements.Encode(property.Value));
}
sb.Append(ServiceMessageConstants.SERVICE_MESSAGE_CLOSE);
return(sb.ToString());
}
public void ShouldDecodeWhenInvalidDecodedText(string textFormServiceMessage, string actualText)
{
Assert.AreEqual(actualText, ServiceMessageReplacements.Decode(textFormServiceMessage));
}
public void ShouldDecodeAndEncodeWhenUnicode(string textFormServiceMessage, string actualText)
{
Assert.AreEqual(actualText, ServiceMessageReplacements.Decode(textFormServiceMessage));
Assert.AreEqual(textFormServiceMessage, ServiceMessageReplacements.Encode(actualText));
}
/// <summary>
/// Reads stream parsing service messages from it.
/// </summary>
/// <param name="reader">stream to parse. Stream will not be closed</param>
/// <returns>Iterator of service messages</returns>
public IEnumerable <IServiceMessage> ParseServiceMessages([NotNull] TextReader reader)
{
var startWith = ServiceMessageConstants.SERVICE_MESSAGE_OPEN.ToCharArray();
while (true)
{
int currentSymbol = 0;
int symbol;
while ((symbol = reader.Read()) >= 0)
{
var c = (char)symbol;
if (c != startWith[currentSymbol])
{
//This was not a service message, let's try again in the next char
currentSymbol = 0;
}
else
{
currentSymbol++;
if (currentSymbol >= startWith.Length)
{
break;
}
}
}
if (symbol < 0)
{
yield break;
}
//there was ##teamcity[ parsed
if (currentSymbol != startWith.Length)
{
yield break;
}
var messageName = new StringBuilder();
while ((symbol = reader.Read()) >= 0 && !char.IsWhiteSpace((char)symbol))
{
messageName.Append((char)symbol);
}
if (symbol < 0)
{
yield break;
}
while ((symbol = reader.Read()) >= 0 && char.IsWhiteSpace((char)symbol))
{
;
}
if (symbol < 0)
{
yield break;
}
if (symbol == '\'')
{
var buffer = new List <char>();
while ((symbol = reader.Read()) >= 0)
{
var ch = (char)symbol;
if (ch == '|')
{
buffer.Add(ch);
symbol = reader.Read();
if (symbol < 0)
{
yield break;
}
buffer.Add((char)symbol);
}
else
{
if (ch == '\'')
{
break;
}
buffer.Add(ch);
}
}
if (symbol < 0)
{
yield break;
}
while ((symbol = reader.Read()) >= 0 && char.IsWhiteSpace((char)symbol))
{
;
}
if (symbol < 0)
{
yield break;
}
if (symbol == ']')
{
yield return(new ServiceMessage(messageName.ToString(), ServiceMessageReplacements.Decode(buffer.ToArray())));
}
}
else
{
var paramz = new Dictionary <string, string>();
while (true)
{
var name = new StringBuilder();
name.Append((char)symbol);
while ((symbol = reader.Read()) >= 0 && symbol != '=')
{
name.Append((char)symbol);
}
if (symbol < 0)
{
yield break;
}
while ((symbol = reader.Read()) >= 0 && char.IsWhiteSpace((char)symbol))
{
;
}
if (symbol < 0)
{
yield break;
}
if (symbol != '\'')
{
break;
}
var buffer = new List <char>();
while ((symbol = reader.Read()) >= 0)
{
var ch = (char)symbol;
if (ch == '|')
{
buffer.Add(ch);
symbol = reader.Read();
if (symbol < 0)
{
yield break;
}
buffer.Add((char)symbol);
}
else
{
if (ch == '\'')
{
break;
}
buffer.Add(ch);
}
}
if (symbol < 0)
{
yield break;
}
paramz[name.ToString().Trim()] = ServiceMessageReplacements.Decode(buffer.ToArray());
while ((symbol = reader.Read()) >= 0 && char.IsWhiteSpace((char)symbol))
{
;
}
if (symbol < 0)
{
yield break;
}
if (symbol == ']')
{
yield return(new ServiceMessage(messageName.ToString(), null, paramz));
break;
}
}
}
}
}
public void TestEncode_0()
{
Assert.AreEqual("", ServiceMessageReplacements.Encode(""));
}
public void TestDecode_1()
{
Assert.AreEqual("a", ServiceMessageReplacements.Decode("a"));
}
