public void SaslFactory_WhenSCRAM_SHA1Available_FuncReturnsScramShaMechanism(string mechanismType)
{
//arrange
var connection = new Mock <IConnection>();
var connectionPool = new Mock <IConnectionPool>();
connectionPool.Setup(x => x.Acquire()).Returns(connection.Object);
var opResult = new Mock <IOperationResult <string> >();
opResult.Setup(x => x.Success).Returns(true);
opResult.Setup(x => x.Value).Returns("SCRAM-Sha512 SCRAM-Sha256 SCRAM-SHA1 CRAM-MD5 PLAIN");
var transcoder = new DefaultTranscoder(new DefaultConverter());
var service = new Mock <IIOService>();
service.Setup(x => x.ConnectionPool).Returns(connectionPool.Object);
service.Setup(x => x.Execute(It.IsAny <SaslList>(), It.IsAny <IConnection>()))
.Returns(opResult.Object);
SaslFactory.Execute = (op, conn) => opResult.Object;
//act
var factory = SaslFactory.GetFactory();
var mechanism = factory("authenticated", "secret", connectionPool.Object, transcoder);
//assert
Assert.IsTrue(mechanism is ScramShaMechanism);
Assert.AreEqual("SCRAM-SHA1", mechanism.MechanismType);
}
public DefaultMemcachedConfiguration()
{
NodeLocator = typeof(DefaultNodeLocator);
KeyTransformer = new Base64KeyTransformer();
Transcoder = new DefaultTranscoder();
Initialize();
}
public void SaslFactory_WhenSCRAM_SHA1Available_FuncReturnsScramShaMechanism(string mechanismType)
{
//arrange
var connection = new Mock<IConnection>();
var connectionPool = new Mock<IConnectionPool>();
connectionPool.Setup(x => x.Acquire()).Returns(connection.Object);
var opResult = new Mock<IOperationResult<string>>();
opResult.Setup(x => x.Success).Returns(true);
opResult.Setup(x => x.Value).Returns("SCRAM-Sha512 SCRAM-Sha256 SCRAM-SHA1 CRAM-MD5 PLAIN");
var transcoder = new DefaultTranscoder(new DefaultConverter());
var service = new Mock<IIOService>();
service.Setup(x => x.ConnectionPool).Returns(connectionPool.Object);
service.Setup(x => x.Execute(It.IsAny<SaslList>(), It.IsAny<IConnection>()))
.Returns(opResult.Object);
//act
var factory = SaslFactory.GetFactory();
var mechanism = factory("authenticated", "secret", service.Object, transcoder);
//assert
Assert.IsTrue(mechanism is ScramShaMechanism);
Assert.AreEqual("SCRAM-SHA1", mechanism.MechanismType);
}
public void Should_Convert_To_PascalCase_Json_With_Altered_Serialization_Settings()
{
var transcoder = new DefaultTranscoder(
new DefaultSerializer(
new JsonSerializerSettings(),
new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver()
}));
var data = new Pascal
{
SomeProperty = "SOME",
SomeIntProperty = 12345,
HasPascalCase = true
};
var expectedJsonBytes = Encoding.UTF8.GetBytes("{\"SomeProperty\":\"SOME\",\"SomeIntProperty\":12345,\"HasPascalCase\":true}");
using (var jsonBytes = new MemoryStream())
using (var jsonEncoded = new MemoryStream())
{
transcoder.SerializeAsJson(jsonBytes, data);
transcoder.Encode(jsonEncoded, data, TypeCode.Object, OpCode.Get);
Assert.Equal(expectedJsonBytes, jsonBytes.ToArray());
Assert.Equal(expectedJsonBytes, jsonEncoded.ToArray());
}
}
public void Test_Timed_Execution_Parallel()
{
var options = new ParallelOptions {
MaxDegreeOfParallelism = 4
};
var converter = new DefaultConverter();
var transcoder = new DefaultTranscoder(converter);
var vbucket = GetVBucket();
var n = 1000;//set to a higher # if needed
using (new OperationTimer())
{
Parallel.For(0, n, options, i =>
{
var key = string.Format("key{0}", i);
var set = new Set <int?>(key, i, vbucket, transcoder, OperationLifespanTimeout);
var result = IOService.Execute(set);
Assert.IsTrue(result.Success);
var get = new Get <int?>(key, vbucket, transcoder, OperationLifespanTimeout);
var result1 = IOService.Execute(get);
Assert.IsTrue(result1.Success);
Assert.AreEqual(i, result1.Value);
});
}
}
public void Test_Timed_Execution()
{
var converter = new DefaultConverter();
var transcoder = new DefaultTranscoder(converter);
var vbucket = GetVBucket();
int n = 1000; //set to a higher # if needed
using (new OperationTimer())
{
var key = string.Format("key{0}", 111);
for (var i = 0; i < n; i++)
{
var set = new Set<int?>(key, 111, vbucket, transcoder, OperationLifespanTimeout);
var get = new Get<int?>(key, vbucket, transcoder, OperationLifespanTimeout);
var result = IOService.Execute(set);
Assert.IsTrue(result.Success);
var result1 = IOService.Execute(get);
Assert.IsTrue(result1.Success);
Assert.AreEqual(111, result1.Value);
}
}
}
public void Test_Timed_Execution()
{
var converter = new DefaultConverter();
var transcoder = new DefaultTranscoder(converter);
var vbucket = GetVBucket();
int n = 1000; //set to a higher # if needed
using (new OperationTimer())
{
var key = string.Format("key{0}", 111);
for (var i = 0; i < n; i++)
{
var set = new Set <int?>(key, 111, vbucket, transcoder, OperationLifespanTimeout);
var get = new Get <int?>(key, vbucket, transcoder, OperationLifespanTimeout);
var result = IOService.Execute(set);
Assert.IsTrue(result.Success);
var result1 = IOService.Execute(get);
Assert.IsTrue(result1.Success);
Assert.AreEqual(111, result1.Value);
}
}
}
public void ScramShaMechanism_WhenServiceIsNullInCtor_ThrowArgumentNullException()
{
IIOService service = null;
var transcoder = new DefaultTranscoder(new DefaultConverter());
// ReSharper disable once ExpressionIsAlwaysNull
// ReSharper disable once ObjectCreationAsStatement
Assert.Throws<ArgumentNullException>(() => new ScramShaMechanism(service, transcoder, MechanismType.ScramSha256));
}
public void ScramShaMechanism_WhenServiceIsNullInCtor_ThrowArgumentNullException()
{
IIOService service = null;
var transcoder = new DefaultTranscoder(new DefaultConverter());
// ReSharper disable once ExpressionIsAlwaysNull
// ReSharper disable once ObjectCreationAsStatement
Assert.Throws <ArgumentNullException>(() => new ScramShaMechanism(service, transcoder, MechanismType.ScramSha256));
}
/// <summary>
/// Send request to server to try and enable server features.
/// </summary>
/// <param name="connection">The connection.</param>
protected void EnableServerFeatures(IConnection connection)
{
var features = new List <short>
{
(short)ServerFeatures.SubdocXAttributes,
(short)ServerFeatures.SelectBucket,
(short)ServerFeatures.XError
};
if (ConnectionPool.Configuration.UseEnhancedDurability)
{
features.Add((short)ServerFeatures.MutationSeqno);
}
if (ConnectionPool.Configuration.ClientConfiguration != null &&
ConnectionPool.Configuration.ClientConfiguration.OperationTracingEnabled &&
ConnectionPool.Configuration.ClientConfiguration.OperationTracingServerDurationEnabled)
{
features.Add((short)ServerFeatures.ServerDuration);
}
var key = BuildHelloKey(connection.ConnectionId);
var transcoder = new DefaultTranscoder();
var result = Execute(new Hello(key, features.ToArray(), transcoder, 0, 0), connection);
if (result.Success)
{
SupportsEnhancedDurability = result.Value.Contains((short)ServerFeatures.MutationSeqno);
SupportsSubdocXAttributes = result.Value.Contains((short)ServerFeatures.SubdocXAttributes);
SupportsEnhancedAuthentication = result.Value.Contains((short)ServerFeatures.SelectBucket);
SupportsKvErrorMap = result.Value.Contains((short)ServerFeatures.XError);
ConnectionPool.SupportsEnhancedAuthentication = SupportsEnhancedAuthentication;
SupportsServerDuration = result.Value.Contains((short)ServerFeatures.ServerDuration);
Log.Info("SupportsEnhancedDurability={0}", SupportsEnhancedDurability);
Log.Info("SupportsSubdocXAttributes={0}", SupportsSubdocXAttributes);
Log.Info("SupportsEnhancedAuthentication={0}", SupportsEnhancedAuthentication);
Log.Info("SupportsKvErrorMap={0}", SupportsKvErrorMap);
Log.Info("SupportsServerDuration={0}", SupportsServerDuration);
if (SupportsKvErrorMap)
{
var errorMapResult = Execute(new GetErrorMap(transcoder, 0), connection);
if (!errorMapResult.Success)
{
throw new Exception("Error retrieving error map. Cluster indicated it was available.");
}
ErrorMap = errorMapResult.Value;
}
}
else
{
LogFailedHelloOperation(result);
}
}
public void ScramShaMechanism_WhenUsernameIsInvalidinCtor_ThrowArgumentNullException(string username)
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
string password = null;
// ReSharper disable once ExpressionIsAlwaysNull
// ReSharper disable once ObjectCreationAsStatement
// ReSharper disable once ExpressionIsAlwaysNull
Assert.Throws <ArgumentNullException>(() => new ScramShaMechanism(transcoder, username, password, MechanismType.ScramSha256));
}
public void Test_Json_Deserialize_Int()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
int value = 42;
var bytes = transcoder.SerializeAsJson(value);
var actual = transcoder.DeserializeAsJson <int>(bytes.AsMemory());
Assert.Equal(value, actual);
}
public void Test_Json_Deserialize_Int()
{
var transcoder = new DefaultTranscoder(new ManualByteConverter());
int value = 42;
var bytes = transcoder.SerializeAsJson(value);
var actual = transcoder.DeserializeAsJson <int>(bytes, 0, bytes.Length);
Assert.AreEqual(value, actual);
}
public void ScramShaMechanism_WhenMechanismIsInavlid_ThrowArgumentOutOfRangeException(string mechanismType)
{
ITypeTranscoder transcoder = new DefaultTranscoder(new DefaultConverter());
string username = "******";
string password = "******";
// ReSharper disable once ExpressionIsAlwaysNull
// ReSharper disable once ObjectCreationAsStatement
Assert.Throws <ArgumentOutOfRangeException>(() => new ScramShaMechanism(transcoder, username, password, mechanismType));
}
public void Should_Hydrate_Poco_In_PascalCase_Whatever_The_Case_In_Json()
{
byte[] jsonData = Encoding.UTF8.GetBytes("{ \"SomeProperty\": \"SOME\", \"someIntProperty\": 12345, \"haspAscalCASE\": true }");
var transcoder = new DefaultTranscoder(new ManualByteConverter());
var hydrated = transcoder.DeserializeAsJson <Pascal>(jsonData, 0, jsonData.Length);
Assert.AreEqual("SOME", hydrated.SomeProperty);
Assert.AreEqual(12345, hydrated.SomeIntProperty);
Assert.AreEqual(true, hydrated.HasPascalCase);
}
public void ScramShaMechanism_Authenticate_IsPopulated()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
string password = "******";
string username = "******";
var mech = new ScramShaMechanism(transcoder, username, password, MechanismType.ScramSha256);
Assert.That(() => !string.IsNullOrEmpty(mech.ClientNonce));
}
public void ScramShaMechanism_WhenUsernameIsInvalidinCtor_ThrowArgumentNullException(string username)
{
var service = new Mock<IIOService>().Object;
var transcoder = new DefaultTranscoder(new DefaultConverter());
string password = null;
// ReSharper disable once ExpressionIsAlwaysNull
// ReSharper disable once ObjectCreationAsStatement
// ReSharper disable once ExpressionIsAlwaysNull
Assert.Throws<ArgumentNullException>(() => new ScramShaMechanism(service, transcoder, username, password, MechanismType.ScramSha256));
}
public void DecodeString_Returns_String_When_Buffer_Is_Empty_And_Type_Is_String()
{
var transcoder = new DefaultTranscoder(new DefaultConverter(), new DefaultSerializer());
var bytes = new byte[0];
var result = transcoder.Decode <string>(bytes.AsMemory(),
new Flags {
DataFormat = DataFormat.String
},
OpCode.NoOp);
Assert.Null(result);
}
public void Sets_Expiration_Value_In_Extras()
{
const uint expiration = 10;
var transcoder = new DefaultTranscoder();
var operation = new GetL <dynamic>("key", null, transcoder, 0)
{
Expiration = expiration
};
var bytes = operation.Write();
Assert.AreEqual(expiration, transcoder.Converter.ToUInt32(bytes, 24));
}
public void Key_Is_Sent_In_Packet()
{
const string key = "test-key";
var transcoder = new DefaultTranscoder();
var hello = new Hello(key, new short[0], transcoder, 0, 0);
var bytes = hello.Write();
// key comes after header (24 bytes) and will be 8 bytes long
var helloKey = transcoder.Converter.ToString(bytes, 24, 8);
Assert.AreEqual(key, helloKey);
}
public void Test_Json_Deserialize_Int()
{
var transcoder = new DefaultTranscoder();
int value = 42;
using (var stream = new MemoryStream())
{
transcoder.SerializeAsJson(stream, value);
var actual = transcoder.DeserializeAsJson <int>(stream.ToArray());
Assert.Equal(value, actual);
}
}
public void DecodeString_Defaults_To_Null_When_Buffer_Is_Empty_And_Type_Is_JSON()
{
var transcoder = new DefaultTranscoder(new DefaultSerializer());
var bytes = new byte[0];
var result = transcoder.Decode <string>(bytes.AsMemory(),
new Flags {
DataFormat = DataFormat.Json
},
OpCode.NoOp);
Assert.Null(result);
}
public void DecodeString_Returns_String_When_Buffer_Is_Empty_And_Type_Is_String()
{
var transcoder = new DefaultTranscoder(new DefaultConverter(), new DefaultSerializer());
var bytes = new byte[0];
var result = transcoder.Decode <string>(bytes, 0, bytes.Length,
new Flags {
DataFormat = DataFormat.String
},
OperationCode.NoOp);
Assert.AreEqual(null, result);
}
public void Test_Null()
{
var transcoder = new DefaultTranscoder(new ManualByteConverter());
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = TypeCode.Empty
};
var expected = new byte[0];
var actual = transcoder.Encode <string>(null, flags);
Assert.AreEqual(expected, actual);
}
public void Test_Deserialize_Char()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
var value = 'o';
var flags = new Flags {
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = value.GetTypeCode()
};
var bytes = Encoding.UTF8.GetBytes(value.ToString());
var actual = transcoder.Decode <char>(bytes, 0, bytes.Length, flags, OperationCode.Get);
Assert.AreEqual(value, actual);
}
public void Should_Convert_To_CamelCase_Json_With_Default_Serialization_Settings()
{
var transcoder = new DefaultTranscoder(new ManualByteConverter());
var data = new Pascal
{
SomeProperty = "SOME",
SomeIntProperty = 12345,
HasPascalCase = true
};
var expectedJsonBytes = Encoding.UTF8.GetBytes("{\"someProperty\":\"SOME\",\"someIntProperty\":12345,\"hasPascalCase\":true}");
var actualJsonBytes = transcoder.SerializeAsJson(data);
var actualJsonEncoded = transcoder.Encode(data, new Flags());
Assert.AreEqual(expectedJsonBytes, actualJsonBytes);
Assert.AreEqual(expectedJsonBytes, actualJsonEncoded);
}
public void Test_Serialize_UInt32()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
UInt32 data = 9;
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = data.GetTypeCode()
};
var expected = new byte[] { 0x09, 0x00, 0x00, 0x00 };
var actual = transcoder.Encode(data, flags, OperationCode.Get);
Assert.AreEqual(expected, actual);
}
public void Test_Serialize_Int32()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
Int32 data = 9;
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = Convert.GetTypeCode(data)
};
var expected = new byte[] { 0x09, 0x00, 0x00, 0x00 };
var actual = transcoder.Encode(data, flags, OpCode.Get);
Assert.Equal(expected, actual);
}
public void Test_Deserialize_Null()
{
var transcoder = new DefaultTranscoder(new ManualByteConverter());
object value = null;
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = TypeCode.Empty
};
var bytes = transcoder.SerializeAsJson(value);
var actual = transcoder.Decode <object>(bytes, 0, bytes.Length, flags);
Assert.AreEqual(value, actual);
}
public void Test_Deserialize_Int()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
var five = 5;
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = Convert.GetTypeCode(five)
};
var bytes = transcoder.Encode(five, flags, OpCode.Get);
var actual = transcoder.Decode <int>(bytes.AsMemory(), flags, OpCode.Get);
Assert.Equal(five, actual);
}
public void Test_Deserialize_Int()
{
var transcoder = new DefaultTranscoder(new ManualByteConverter());
var five = 5;
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = five.GetTypeCode()
};
var bytes = transcoder.Encode(five, flags);
var actual = transcoder.Decode <int>(bytes, 0, bytes.Length, flags);
Assert.AreEqual(five, actual);
}
public void Test_Char()
{
var transcoder = new DefaultTranscoder(new ManualByteConverter());
var value = 'o';
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = value.GetTypeCode()
};
var expected = new byte[] { 0x6f };
var actual = transcoder.Encode(value, flags);
Assert.AreEqual(expected, actual);
}
public void Test_Serialize_String()
{
var transcoder = new DefaultTranscoder(new ManualByteConverter());
string data = "Hello";
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = data.GetTypeCode()
};
var expected = new byte[] { 0x48, 0x65, 0x6c, 0x6c, 0x6f };
var actual = transcoder.Encode(data, flags);
Assert.AreEqual(expected, actual);
}
public void Test_Serialize_Int64()
{
var transcoder = new DefaultTranscoder(new ManualByteConverter());
Int64 data = 9;
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = data.GetTypeCode()
};
var expected = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09 };
var actual = transcoder.Encode(data, flags);
Assert.AreEqual(expected, actual);
}
public void Test_Deserialize_String()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
var value = "astring";
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = Convert.GetTypeCode(value)
};
var bytes = transcoder.Encode(value, flags, OpCode.Get);
var actual = transcoder.Decode <string>(bytes.AsMemory(), flags, OpCode.Get);
Assert.Equal(value, actual);
}
public void Test_Timed_Execution_Parallel()
{
var options = new ParallelOptions { MaxDegreeOfParallelism = 4 };
var converter = new DefaultConverter();
var transcoder = new DefaultTranscoder(converter);
var vbucket = GetVBucket();
var n = 1000;//set to a higher # if needed
using (new OperationTimer())
{
Parallel.For(0, n, options, i =>
{
var key = string.Format("key{0}", i);
var set = new Set<int?>(key, i, vbucket, transcoder, OperationLifespanTimeout);
var result = IOService.Execute(set);
Assert.IsTrue(result.Success);
var get = new Get<int?>(key, vbucket, transcoder, OperationLifespanTimeout);
var result1 = IOService.Execute(get);
Assert.IsTrue(result1.Success);
Assert.AreEqual(i, result1.Value);
});
}
}
public void Should_Hydrate_Poco_In_PascalCase_Whatever_The_Case_In_Json()
{
byte[] jsonData = Encoding.UTF8.GetBytes("{ \"SomeProperty\": \"SOME\", \"someIntProperty\": 12345, \"haspAscalCASE\": true }");
var transcoder = new DefaultTranscoder(new DefaultConverter());
var hydrated = transcoder.DeserializeAsJson<Pascal>(jsonData, 0, jsonData.Length);
Assert.AreEqual("SOME", hydrated.SomeProperty);
Assert.AreEqual(12345, hydrated.SomeIntProperty);
Assert.AreEqual(true, hydrated.HasPascalCase);
}
public void Should_Convert_To_PascalCase_Json_With_Altered_Serialization_Settings()
{
var transcoder = new DefaultTranscoder(
new DefaultConverter(),
new DefaultSerializer(
new JsonSerializerSettings(),
new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver()
}));
var data = new Pascal
{
SomeProperty = "SOME",
SomeIntProperty = 12345,
HasPascalCase = true
};
var expectedJsonBytes = Encoding.UTF8.GetBytes("{\"SomeProperty\":\"SOME\",\"SomeIntProperty\":12345,\"HasPascalCase\":true}");
var actualJsonBytes = transcoder.SerializeAsJson(data);
var actualJsonEncoded = transcoder.Encode(data, OperationCode.Get);
Assert.AreEqual(expectedJsonBytes, actualJsonBytes);
Assert.AreEqual(expectedJsonBytes, actualJsonEncoded);
}
public void Test_Byte_Array()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
var value = new byte[] {0x00, 0x00, 0x01};
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Binary,
TypeCode = Type.GetTypeCode(typeof(byte[]))
};
var bytes = transcoder.Encode(value, flags, OperationCode.Get);
Assert.AreEqual(bytes, value);
var actual = transcoder.Decode<byte[]>(bytes, 0, bytes.Length, flags, OperationCode.Get);
Assert.AreEqual(bytes, actual);
}
public void Test_Json_Deserialize_Int()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
int value = 42;
var bytes = transcoder.SerializeAsJson(value);
var actual = transcoder.DeserializeAsJson<int>(bytes, 0, bytes.Length);
Assert.AreEqual(value, actual);
}
public void Test_Deserialize_Null()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
object value = null;
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = TypeCode.Empty
};
var bytes = transcoder.SerializeAsJson(value);
var actual = transcoder.Decode<object>(bytes, 0, bytes.Length, flags, OperationCode.Get);
Assert.AreEqual(value, actual);
}
public void Test_Deserialize_String()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
var value = "astring";
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = value.GetTypeCode()
};
var bytes = transcoder.Encode(value, flags, OperationCode.Get);
var bytes1 = Encoding.UTF8.GetBytes(value);
var actual = transcoder.Decode<string>(bytes, 0, bytes.Length, flags, OperationCode.Get);
Assert.AreEqual(value, actual);
}
public void Test_Poco()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
var value = new Person {Name = "jeff"};
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = Type.GetTypeCode(typeof(Person))
};
var bytes = transcoder.Encode(value, flags, OperationCode.Get);
var actual = transcoder.Decode<Person>(new ArraySegment<byte>(bytes), 0, bytes.Length, flags, OperationCode.Get);
Assert.AreEqual(value.Name, actual.Name);
}
public void Test_Deserialize_Int()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
var five = 5;
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = five.GetTypeCode()
};
var bytes = transcoder.Encode(five, flags, OperationCode.Get);
var actual = transcoder.Decode<int>(bytes, 0, bytes.Length, flags, OperationCode.Get);
Assert.AreEqual(five, actual);
}
public void Test_Char()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
var value = 'o';
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = value.GetTypeCode()
};
var expected = new byte[] { 0x6f };
var actual = transcoder.Encode(value, flags, OperationCode.Get);
Assert.AreEqual(expected, actual);
}
public void ScramShaMechanism_WhenMechanismIsInavlid_ThrowArgumentOutOfRangeException(string mechanismType)
{
var service = new Mock<IIOService>().Object;
ITypeTranscoder transcoder = new DefaultTranscoder(new DefaultConverter());
string username = "******";
string password = "******";
// ReSharper disable once ExpressionIsAlwaysNull
// ReSharper disable once ObjectCreationAsStatement
Assert.Throws<ArgumentOutOfRangeException>(() => new ScramShaMechanism(service, transcoder, username, password, mechanismType));
}
public void When_ByteArray_Is_Stored_With_Legacy_Flags_It_Is_Decoded_As_A_ByteArray()
{
var legacyByteArray = new byte[]
{
129, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 8, 0,
0, 0, 5, 19, 185, 8, 248, 3, 104, 208, 188, 0,
0, 250, 82, 116, 101, 115, 116
};
var converter = new DefaultConverter();
var format = new byte();
var temp = converter.ToByte(legacyByteArray, 24);
converter.SetBit(ref format, 0, converter.GetBit(temp, 0));
converter.SetBit(ref format, 1, converter.GetBit(temp, 1));
converter.SetBit(ref format, 2, converter.GetBit(temp, 2));
converter.SetBit(ref format, 3, converter.GetBit(temp, 3));
var compression = new byte();
converter.SetBit(ref compression, 4, converter.GetBit(temp, 4));
converter.SetBit(ref compression, 5, converter.GetBit(temp, 5));
converter.SetBit(ref compression, 6, converter.GetBit(temp, 6));
var flags = new Flags
{
DataFormat = (DataFormat)format,
Compression = (Compression)compression,
TypeCode = (TypeCode)(converter.ToUInt16(legacyByteArray, 26) & 0xff),
};
var transcoder = new DefaultTranscoder(new DefaultConverter());
var result = transcoder.Decode<byte[]>(legacyByteArray, 28, 4, flags, OperationCode.Get);
Assert.AreEqual("test", Encoding.UTF8.GetString(result));
}
public void ScramShaMechanism_Authenticate_IsPopulated()
{
var service = new Mock<IIOService>().Object;
var transcoder = new DefaultTranscoder(new DefaultConverter());
string password = "******";
string username = "******";
var mech = new ScramShaMechanism(service, transcoder, username, password, MechanismType.ScramSha256);
Assert.That(() => !string.IsNullOrEmpty(mech.ClientNonce));
}
public void Should_Convert_To_CamelCase_Json_With_Default_Serialization_Settings()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
var data = new Pascal
{
SomeProperty = "SOME",
SomeIntProperty = 12345,
HasPascalCase = true
};
var expectedJsonBytes = Encoding.UTF8.GetBytes("{\"someProperty\":\"SOME\",\"someIntProperty\":12345,\"hasPascalCase\":true}");
var actualJsonBytes = transcoder.SerializeAsJson(data);
var actualJsonEncoded = transcoder.Encode(data, new Flags{DataFormat = DataFormat.Json}, OperationCode.Get);
Assert.AreEqual(expectedJsonBytes, actualJsonBytes);
Assert.AreEqual(expectedJsonBytes, actualJsonEncoded);
}
public void Test_Serialize_String()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
string data = "Hello";
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = data.GetTypeCode()
};
var expected = new byte[] { 0x48, 0x65, 0x6c, 0x6c, 0x6f };
var actual = transcoder.Encode(data, flags, OperationCode.Get);
Assert.AreEqual(expected, actual);
}
public void Test_Null()
{
var transcoder = new DefaultTranscoder(new DefaultConverter());
var flags = new Flags
{
Compression = Compression.None,
DataFormat = DataFormat.Reserved,
TypeCode = TypeCode.Empty
};
var expected = new byte[0];
var actual = transcoder.Encode<string>(null, flags, OperationCode.Get);
Assert.AreEqual(expected, actual);
}
