public void Constructor_ExpectedValues()
{
// Call
var converter = new MessageTypeConverter();
// Assert
Assert.That(converter, Is.InstanceOf <IValueConverter>());
}
protected override void Evaluate()
{
if (Parameters.Count != 2)
{
throw new Exception(string.Format("Expected 2 parameters, got {0} in function name {1}.",
Parameters.Count, Text));
}
Messages.AddMessage(MessageTypeConverter.ToType(Parameters[0]), Parameters[1]);
}
public void ConvertBack_Always_ThrowsNotSupportedException()
{
// Setup
var converter = new MessageTypeConverter();
// Call
TestDelegate call = () => converter.ConvertBack(null, null, null, null);
// Assert
Assert.That(call, Throws.Exception.TypeOf <NotSupportedException>()
.With.Message.EqualTo("ConvertBack operation is not supported."));
}
public void Convert_WithValidMessageTypeAndTargetTypeBrush_ReturnsExpectedValue(
MessageType valueToConvert, Brush expectedValue)
{
// Setup
var converter = new MessageTypeConverter();
// Call
object convertedValue = converter.Convert(valueToConvert, typeof(Brush), null, null);
// Assert
Assert.That(convertedValue, Is.InstanceOf <Brush>());
Assert.That(convertedValue, Is.EqualTo(expectedValue));
}
public void Convert_WithInvalidValueTypes_ThrowsNotSupportedException(object unsupportedValue)
{
// Setup
var converter = new MessageTypeConverter();
// Call
TestDelegate call = () => converter.Convert(unsupportedValue, typeof(Brush), null, null);
// Assert
string expectedMessage = $"Conversion from {unsupportedValue?.GetType().Name} is not supported.";
Assert.That(call, Throws.Exception.InstanceOf <NotSupportedException>()
.And.Message.EqualTo(expectedMessage));
}
public void Convert_WithInvalidTargetType_ThrowsNotSupportedException()
{
// Setup
var random = new Random(21);
var converter = new MessageTypeConverter();
Type unsupportedType = typeof(int);
// Call
TestDelegate call = () => converter.Convert(random.NextEnum <MessageType>(), unsupportedType, null, null);
// Assert
string expectedMessage = $"Conversion to {unsupportedType.Name} is not supported.";
Assert.That(call, Throws.Exception.InstanceOf <NotSupportedException>()
.And.Message.EqualTo(expectedMessage));
}
public void Convert_WithInvalidMessageType_ThrowsNotSupportedException()
{
// Setup
const MessageType invalidMessageType = (MessageType)1001;
var converter = new MessageTypeConverter();
// Call
TestDelegate call = () => converter.Convert(invalidMessageType, typeof(object), null, null);
// Assert
string expectedMessage = $"The value of argument 'value' ({(int)invalidMessageType}) is invalid for Enum type '{typeof(MessageType).Name}'." +
$"{Environment.NewLine}Parameter name: value";
Assert.That(call, Throws.Exception.InstanceOf <InvalidEnumArgumentException>()
.And.Message.EqualTo(expectedMessage));
}
public void ConvertsInfoTypeToStringAndBack()
{
Assert.AreEqual(MessageType.Information, MessageTypeConverter.ToType(MessageTypeConverter.ToString(MessageType.Information)));
}
public void ConvertsWarningTypeToString()
{
Assert.AreEqual("WARN", MessageTypeConverter.ToString(MessageType.Warning));
}
public void ConvertsErrorTypeToString()
{
Assert.AreEqual("CRIT", MessageTypeConverter.ToString(MessageType.Error));
}
public void ThrowsAfterAttemptingToConvertNonsensicalType()
{
Assert.Throws <InvalidEnumArgumentException>(() => MessageTypeConverter.ToString((MessageType)10030238));
}
public virtual Task SendAsync(ArraySegment <byte> data, MessageType messageType, bool endOfMessage, CancellationToken cancellationToken)
{
return(this.WebSocket.SendAsync(data, MessageTypeConverter.ConvertToWebSocketMessageType(messageType), endOfMessage, cancellationToken));
}
public void ConvertsInformationTypeToString()
{
Assert.AreEqual("INFO", MessageTypeConverter.ToString(MessageType.Information));
}
public void ConvertsWARNToType()
{
Assert.AreEqual(MessageType.Warning, MessageTypeConverter.ToType("WARN"));
}
public void ConvertsCRITToType()
{
Assert.AreEqual(MessageType.Error, MessageTypeConverter.ToType("CRIT"));
}
public void ConvertsDBUGToType()
{
Assert.AreEqual(MessageType.Debug, MessageTypeConverter.ToType("DBUG"));
}
public void ConvertsINFOToType()
{
Assert.AreEqual(MessageType.Information, MessageTypeConverter.ToType("INFO"));
}
public void ConvertsDebugTypeToString()
{
Assert.AreEqual("DBUG", MessageTypeConverter.ToString(MessageType.Debug));
}
public void ThrowsAfterAttemptingToConvertNonsensicalString()
{
Assert.Throws <ArgumentException>(() => MessageTypeConverter.ToType("nonsensical message"));
}
public void AddMessage(MessageType type, string message)
{
_lastId++;
Console.WriteLine("{0}: {1}", _lastId, message);
_messages[_lastId] = string.Format("[{0}] {1}", MessageTypeConverter.ToString(type), message);
}
