public void MemcacheClientReplicasTest()
{
var client = new MemcacheClient(_configuration);
for (int replicas = 0; replicas < _configuration.NodesEndPoints.Count; replicas++)
{
_configuration.Replicas = replicas;
// SET
NodeMock.trySendCounter = 0;
Assert.IsTrue(client.Set("toto", new byte[0], TimeSpan.MaxValue, null));
Assert.AreEqual(replicas + 1, NodeMock.trySendCounter);
// GET
NodeMock.trySendCounter = 0;
Assert.IsTrue(client.Get("toto", null));
Assert.AreEqual(replicas + 1, NodeMock.trySendCounter);
// DELETE
NodeMock.trySendCounter = 0;
Assert.IsTrue(client.Delete("toto", null));
Assert.AreEqual(replicas + 1, NodeMock.trySendCounter);
}
// Set number of replicas to a number strictly greater than the number of nodes, minus one.
NodeMock.trySendCounter = 0;
_configuration.Replicas = _configuration.NodesEndPoints.Count;
Assert.IsTrue(client.Set("toto", new byte[0], TimeSpan.MaxValue, null));
Assert.AreEqual(_configuration.NodesEndPoints.Count, NodeMock.trySendCounter);
}
public void SerializationThrows()
{
var serializerMoq = new Mock<ISerializer<TestType>>();
serializerMoq.Setup(s => s.FromBytes(It.IsAny<byte[]>())).Throws(new SerializationException());
serializerMoq.Setup(s => s.ToBytes(It.IsAny<TestType>())).Throws(new SerializationException());
serializerMoq.Setup(s => s.TypeFlag).Returns(314);
Exception raised = null;
var config = new MemcacheClientConfiguration
{
ClusterFactory = c => _clusterMock,
};
var serialiserMoqObj = serializerMoq.Object;
config.SetSerializer(serialiserMoqObj);
var client = new MemcacheClient(config);
client.CallbackError += e => raised = e;
// test that the throws of the serializer is synchronously propagated
Assert.Throws(typeof(SerializationException), () => client.Set("Hello", new TestType(), TimeSpan.Zero));
// test that the failing serializer does not synchronously throws but sends a CallbackError event
_responseHeader = new MemcacheResponseHeader
{
ExtraLength = 4,
TotalBodyLength = 4,
Opcode = Opcode.Get,
};
_extra = new byte[] { 0, 0, 0, 0};
Assert.True(client.Get("Hello", (Status s, TestType v) => { }));
Assert.IsNotNull(raised);
Assert.IsInstanceOf<SerializationException>(raised);
}
public void UnsupportedSerializationThrows()
{
var config = new MemcacheClientConfiguration
{
ClusterFactory = c => _clusterMock,
};
var client = new MemcacheClient(config);
// assert that both set and get throws NotSupportedException for an unknown type
Assert.Throws(typeof(NotSupportedException), () => client.Set("Hello", new TestType(), TimeSpan.Zero));
Assert.Throws(typeof(NotSupportedException), () => client.Get("Hello", (Status s, TestType v) => { }));
}
public void MemcacheClientReplicasTest()
{
var callbackMutex = new ManualResetEventSlim(false);
var client = new MemcacheClient(_configuration);
// The number of requests sent is capped by the number of nodes in the cluster.
// The last iteration of the loop below actually tests the case where the total
// number of copies (Replicas+1) is strictly greater than the number of nodes.
int nodeCount = _configuration.NodesEndPoints.Count;
for (int replicas = 0; replicas <= nodeCount; replicas++)
{
_configuration.Replicas = replicas;
// SET
callbackMutex.Reset();
NodeMock.TrySendCounter = 0;
Assert.IsTrue(client.Set("toto", new byte[0], TimeSpan.MaxValue, s => callbackMutex.Set()));
Assert.AreEqual(Math.Min(replicas + 1, nodeCount), NodeMock.TrySendCounter);
Assert.IsTrue(callbackMutex.Wait(1000),
string.Format("The SET callback has not been received after 1 second (Replicas = {0})", replicas));
// GET
callbackMutex.Reset();
NodeMock.TrySendCounter = 0;
Assert.IsTrue(client.Get("toto", (s, data) => callbackMutex.Set()));
Assert.AreEqual(Math.Min(replicas + 1, nodeCount), NodeMock.TrySendCounter);
Assert.IsTrue(callbackMutex.Wait(1000),
string.Format("The GET callback has not been received after 1 second (Replicas = {0})", replicas));
// DELETE
callbackMutex.Reset();
NodeMock.TrySendCounter = 0;
Assert.IsTrue(client.Delete("toto", s => callbackMutex.Set()));
Assert.AreEqual(Math.Min(replicas + 1, nodeCount), NodeMock.TrySendCounter);
Assert.IsTrue(callbackMutex.Wait(1000),
string.Format("The DELETE callback has not been received after 1 second (Replicas = {0})", replicas));
}
}
public void MemcacheClientReplicasTest()
{
var callbackMutex = new ManualResetEventSlim(false);
var client = new MemcacheClient(_configuration);
// The number of requests sent is capped by the number of nodes in the cluster.
// The last iteration of the loop below actually tests the case where the total
// number of copies (Replicas+1) is strictly greater than the number of nodes.
int nodeCount = _configuration.NodesEndPoints.Count;
for (int replicas = 0; replicas <= nodeCount; replicas++)
{
_configuration.Replicas = replicas;
// SET
callbackMutex.Reset();
NodeMock.TrySendCounter = 0;
Assert.IsTrue(client.Set("toto", new byte[0], TimeSpan.MaxValue, s => callbackMutex.Set()));
Assert.AreEqual(Math.Min(replicas + 1, nodeCount), NodeMock.TrySendCounter);
Assert.IsTrue(callbackMutex.Wait(1000),
string.Format("The SET callback has not been received after 1 second (Replicas = {0})", replicas));
// GET
callbackMutex.Reset();
NodeMock.TrySendCounter = 0;
Assert.IsTrue(client.Get("toto", (Status s, byte[] data) => callbackMutex.Set()));
Assert.AreEqual(Math.Min(replicas + 1, nodeCount), NodeMock.TrySendCounter);
Assert.IsTrue(callbackMutex.Wait(1000),
string.Format("The GET callback has not been received after 1 second (Replicas = {0})", replicas));
// DELETE
callbackMutex.Reset();
NodeMock.TrySendCounter = 0;
Assert.IsTrue(client.Delete("toto", s => callbackMutex.Set()));
Assert.AreEqual(Math.Min(replicas + 1, nodeCount), NodeMock.TrySendCounter);
Assert.IsTrue(callbackMutex.Wait(1000),
string.Format("The DELETE callback has not been received after 1 second (Replicas = {0})", replicas));
}
}
public void SerializationThrows()
{
var serializerMoq = new Mock <ISerializer <TestType> >();
serializerMoq.Setup(s => s.FromBytes(It.IsAny <byte[]>())).Throws(new SerializationException());
serializerMoq.Setup(s => s.ToBytes(It.IsAny <TestType>())).Throws(new SerializationException());
serializerMoq.Setup(s => s.TypeFlag).Returns(314);
Exception raised = null;
var config = new MemcacheClientConfiguration
{
ClusterFactory = c => _clusterMock,
};
var serialiserMoqObj = serializerMoq.Object;
config.SetSerializer(serialiserMoqObj);
var client = new MemcacheClient(config);
client.CallbackError += e => raised = e;
// test that the throws of the serializer is synchronously propagated
Assert.Throws(typeof(SerializationException), () => client.Set("Hello", new TestType(), TimeSpan.Zero));
// test that the failing serializer does not synchronously throws but sends a CallbackError event
_responseHeader = new MemcacheResponseHeader
{
ExtraLength = 4,
TotalBodyLength = 4,
Opcode = Opcode.Get,
};
_extra = new byte[] { 0, 0, 0, 0 };
Assert.True(client.Get("Hello", (Status s, TestType v) => { }));
Assert.IsNotNull(raised);
Assert.IsInstanceOf <SerializationException>(raised);
}
public void UnsupportedSerializationThrows()
{
var config = new MemcacheClientConfiguration
{
ClusterFactory = c => _clusterMock,
};
var client = new MemcacheClient(config);
// assert that both set and get throws NotSupportedException for an unknown type
Assert.Throws(typeof(NotSupportedException), () => client.Set("Hello", new TestType(), TimeSpan.Zero));
Assert.Throws(typeof(NotSupportedException), () => client.Get("Hello", (Status s, TestType v) => { }));
}